text
stringlengths 1
22.8M
|
|---|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.beam.runners.dataflow;
import static org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.base.MoreObjects.toStringHelper;
import java.util.ArrayDeque;
import org.apache.beam.sdk.Pipeline;
import org.apache.beam.sdk.runners.AppliedPTransform;
import org.apache.beam.sdk.runners.PTransformMatcher;
import org.apache.beam.sdk.runners.TransformHierarchy;
import org.apache.beam.sdk.transforms.Combine;
import org.apache.beam.sdk.transforms.PTransform;
/**
* A set of {@link PTransformMatcher PTransformMatchers} that are used in the Dataflow Runner and
* not general enough to be shared between runners.
*/
@SuppressWarnings({
"nullness" // TODO(path_to_url
})
class DataflowPTransformMatchers {
private DataflowPTransformMatchers() {}
/**
* Matches {@link PTransform}s of class {@link Combine.GroupedValues} that have no side inputs.
*/
static class CombineValuesWithoutSideInputsPTransformMatcher implements PTransformMatcher {
@Override
public boolean matches(AppliedPTransform<?, ?, ?> application) {
return application.getTransform().getClass().equals(Combine.GroupedValues.class)
&& ((Combine.GroupedValues<?, ?, ?>) application.getTransform())
.getSideInputs()
.isEmpty();
}
@Override
public String toString() {
return toStringHelper(CombineValuesWithoutSideInputsPTransformMatcher.class).toString();
}
}
/**
* Matches {@link PTransform}s of class {@link Combine.GroupedValues} that have no side inputs and
* are direct subtransforms of a {@link Combine.PerKey}.
*/
static class CombineValuesWithParentCheckPTransformMatcher implements PTransformMatcher {
@Override
public boolean matches(AppliedPTransform<?, ?, ?> application) {
return application.getTransform().getClass().equals(Combine.GroupedValues.class)
&& ((Combine.GroupedValues<?, ?, ?>) application.getTransform()).getSideInputs().isEmpty()
&& parentIsCombinePerKey(application);
}
private boolean parentIsCombinePerKey(AppliedPTransform<?, ?, ?> application) {
// We want the PipelineVisitor below to change the parent, but the parent must be final to
// be captured in there. To work around this issue, wrap the parent in a one element array.
final TransformHierarchy.Node[] parent = new TransformHierarchy.Node[1];
// Traverse the pipeline to find the parent transform to application. Do this by maintaining
// a stack of each composite transform being entered, and grabbing the top transform of the
// stack once the target node is visited.
Pipeline pipeline = application.getPipeline();
pipeline.traverseTopologically(
new Pipeline.PipelineVisitor.Defaults() {
private ArrayDeque<TransformHierarchy.Node> parents = new ArrayDeque<>();
@Override
public CompositeBehavior enterCompositeTransform(TransformHierarchy.Node node) {
CompositeBehavior behavior = CompositeBehavior.ENTER_TRANSFORM;
// Combine.GroupedValues is a composite transform in the hierarchy, so when entering
// a composite first we check if we found our target node.
if (!node.isRootNode()
&& node.toAppliedPTransform(getPipeline()).equals(application)) {
// If we found the target node grab the node's parent.
if (parents.isEmpty()) {
parent[0] = null;
} else {
parent[0] = parents.peekFirst();
}
behavior = CompositeBehavior.DO_NOT_ENTER_TRANSFORM;
}
// Even if we found the target node we must add it to the list to maintain parity
// with the number of removeFirst calls.
parents.addFirst(node);
return behavior;
}
@Override
public void leaveCompositeTransform(TransformHierarchy.Node node) {
if (!node.isRootNode()) {
parents.removeFirst();
}
}
});
if (parent[0] == null) {
return false;
}
// If the parent transform cannot be converted to an appliedPTransform it's definitely not
// a CombinePerKey.
AppliedPTransform<?, ?, ?> appliedParent;
try {
appliedParent = parent[0].toAppliedPTransform(pipeline);
} catch (NullPointerException e) {
return false;
}
return appliedParent.getTransform().getClass().equals(Combine.PerKey.class);
}
@Override
public String toString() {
return toStringHelper(CombineValuesWithParentCheckPTransformMatcher.class).toString();
}
}
}
```
|
The Dutch Eerste Divisie in the 2003–04 season was contested by 19 teams, one more than in the previous season. This was due to AGOVV Apeldoorn entering from the amateurs. FC Den Bosch won the championship.
Promoted Teams
These teams were promoted to the Eredivisie
Den Bosch — Eerste Divisie champions
De Graafschap — playoff winners
New entrants
Entering from amateur football
AGOVV Apeldoorn
Relegated from the 2002–03 Eredivisie
Excelsior
De Graafschap
League standings
Playoff standings
See also
2003–04 Eredivisie
2003–04 KNVB Cup
References
Netherlands - List of final tables (RSSSF)
Eerste Divisie seasons
2003–04 in Dutch football
Neth
|
```smalltalk
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System.Collections.Generic;
public class InputNetworkEventProxy : IInputProxyBase
{
const int c_msgPoolSize = 5; //
const int c_connectMsgPool = 2; //
public static void DispatchStatusEvent(NetworkState status)
{
//
if (IsActive)
{
InitPool();
InputNetworkConnectStatusEvent e = GetConnectMsgEvent(status);
InputManager.Dispatch("InputNetworkConnectStatusEvent",e);
}
}
public static void DispatchMessageEvent(string massageType, Dictionary<string, object> data)
{
//
if (IsActive)
{
InitPool();
InputNetworkMessageEvent e = GetMsgEvent();
e.m_MessgaeType = massageType;
e.Data = data;
InputManager.Dispatch("InputNetworkMessageEvent",e);
}
}
#region
static InputNetworkMessageEvent[] m_msgPool;
static InputNetworkConnectStatusEvent[] m_connectMsgPool;
static int m_connectIndex = 0;
static int m_msgIndex = 0;
static bool isInit = false;
static void InitPool()
{
if (!isInit)
{
isInit = true;
m_connectMsgPool = new InputNetworkConnectStatusEvent[c_connectMsgPool];
for (int i = 0; i < c_connectMsgPool; i++)
{
m_connectMsgPool[i] = new InputNetworkConnectStatusEvent();
}
m_msgPool = new InputNetworkMessageEvent[c_msgPoolSize];
for (int i = 0; i < c_msgPoolSize; i++)
{
m_msgPool[i] = new InputNetworkMessageEvent();
}
}
}
static InputNetworkMessageEvent GetMsgEvent()
{
InputNetworkMessageEvent msg = m_msgPool[m_msgIndex];
msg.Reset();
m_msgIndex++;
if (m_msgIndex >= m_msgPool.Length)
{
m_msgIndex = 0;
}
return msg;
}
static InputNetworkConnectStatusEvent GetConnectMsgEvent(NetworkState status)
{
InputNetworkConnectStatusEvent msg = m_connectMsgPool[m_connectIndex];
msg.Reset();
msg.m_status = status;
m_connectIndex++;
if (m_connectIndex >= m_connectMsgPool.Length)
{
m_connectIndex = 0;
}
return msg;
}
#endregion
}
```
|
A Posey vest is a type of medical restraint used to restrain a patient to a bed or chair. Its name comes from the J.T. Posey Company, its inventor, though the term "Posey" is used generically to describe all such devices. The vest is placed on the patient, and meshy straps extending from each corner are tied either individually to each side of the bed or together to the back of a chair. Poseys are most often used to prevent patients from injuring themselves by falling or climbing out of the bed or chair. They allow patients the freedom to move around their arms and legs if no limb restraints have been applied.
Laws in many places require Posey vests be applied with the opening at the patient's front. Misuse in which a Posey vest is applied backwards has resulted in patients being choked to death. Many lawsuits have been litigated in which a patient has died while restrained by a Posey.
Variations
A cushion belt is a belt that does not include a vest, and simply fastens around the waist, and is tied to the sides of a bed or to a chair.
An alternate version of the Posey is a vest that is placed on with an opening in the back and a back zipper, and straps that extend from the sides.
See also
Straitjacket
References
Safety clothing
Physical restraint
|
```makefile
APP_ABI := armeabi-v7a arm64-v8a x86 x86_64
APP_PLATFORM := android-14
```
|
```c
/*
*
*/
/** @file mqtt_encoder.c
*
* @brief Encoding functions needed to create packet to be sent to the broker.
*/
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(net_mqtt_enc, CONFIG_MQTT_LOG_LEVEL);
#include "mqtt_internal.h"
#include "mqtt_os.h"
static const struct mqtt_utf8 mqtt_3_1_0_proto_desc =
MQTT_UTF8_LITERAL("MQIsdp");
static const struct mqtt_utf8 mqtt_3_1_1_proto_desc =
MQTT_UTF8_LITERAL("MQTT");
/** Never changing ping request, needed for Keep Alive. */
static const uint8_t ping_packet[MQTT_FIXED_HEADER_MIN_SIZE] = {
MQTT_PKT_TYPE_PINGREQ,
0x00
};
/** Never changing disconnect request. */
static const uint8_t disc_packet[MQTT_FIXED_HEADER_MIN_SIZE] = {
MQTT_PKT_TYPE_DISCONNECT,
0x00
};
/**
* @brief Packs unsigned 8 bit value to the buffer at the offset requested.
*
* @param[in] val Value to be packed.
* @param[inout] buf A pointer to the buf_ctx structure containing current
* buffer position.
*
* @retval 0 if procedure is successful.
* @retval -ENOMEM if there is no place in the buffer to store the value.
*/
static int pack_uint8(uint8_t val, struct buf_ctx *buf)
{
uint8_t *cur = buf->cur;
uint8_t *end = buf->end;
if ((end - cur) < sizeof(uint8_t)) {
return -ENOMEM;
}
NET_DBG(">> val:%02x cur:%p, end:%p", val, (void *)cur, (void *)end);
/* Pack value. */
cur[0] = val;
buf->cur = (cur + sizeof(uint8_t));
return 0;
}
/**
* @brief Packs unsigned 16 bit value to the buffer at the offset requested.
*
* @param[in] val Value to be packed.
* @param[inout] buf A pointer to the buf_ctx structure containing current
* buffer position.
*
* @retval 0 if the procedure is successful.
* @retval -ENOMEM if there is no place in the buffer to store the value.
*/
static int pack_uint16(uint16_t val, struct buf_ctx *buf)
{
uint8_t *cur = buf->cur;
uint8_t *end = buf->end;
if ((end - cur) < sizeof(uint16_t)) {
return -ENOMEM;
}
NET_DBG(">> val:%04x cur:%p, end:%p", val, (void *)cur, (void *)end);
/* Pack value. */
sys_put_be16(val, cur);
buf->cur = (cur + sizeof(uint16_t));
return 0;
}
/**
* @brief Packs utf8 string to the buffer at the offset requested.
*
* @param[in] str UTF-8 string and its length to be packed.
* @param[inout] buf A pointer to the buf_ctx structure containing current
* buffer position.
*
* @retval 0 if the procedure is successful.
* @retval -ENOMEM if there is no place in the buffer to store the string.
*/
static int pack_utf8_str(const struct mqtt_utf8 *str, struct buf_ctx *buf)
{
if ((buf->end - buf->cur) < GET_UT8STR_BUFFER_SIZE(str)) {
return -ENOMEM;
}
NET_DBG(">> str_size:%08x cur:%p, end:%p",
(uint32_t)GET_UT8STR_BUFFER_SIZE(str), (void *)buf->cur, (void *)buf->end);
/* Pack length followed by string. */
(void)pack_uint16(str->size, buf);
memcpy(buf->cur, str->utf8, str->size);
buf->cur += str->size;
return 0;
}
/**
* @brief Computes and encodes length for the MQTT fixed header.
*
* @note The remaining length is not packed as a fixed unsigned 32 bit integer.
* Instead it is packed on algorithm below:
*
* @code
* do
* encodedByte = X MOD 128
* X = X DIV 128
* // if there are more data to encode, set the top bit of this byte
* if ( X > 0 )
* encodedByte = encodedByte OR 128
* endif
* 'output' encodedByte
* while ( X > 0 )
* @endcode
*
* @param[in] length Length of variable header and payload in the MQTT message.
* @param[inout] buf A pointer to the buf_ctx structure containing current
* buffer position. May be NULL (in this case function will
* only calculate number of bytes needed).
*
* @return Number of bytes needed to encode length value.
*/
static uint8_t packet_length_encode(uint32_t length, struct buf_ctx *buf)
{
uint8_t encoded_bytes = 0U;
NET_DBG(">> length:0x%08x cur:%p, end:%p", length,
(buf == NULL) ? 0 : (void *)buf->cur, (buf == NULL) ? 0 : (void *)buf->end);
do {
encoded_bytes++;
if (buf != NULL) {
*(buf->cur) = length & MQTT_LENGTH_VALUE_MASK;
}
length >>= MQTT_LENGTH_SHIFT;
if (buf != NULL) {
if (length > 0) {
*(buf->cur) |= MQTT_LENGTH_CONTINUATION_BIT;
}
buf->cur++;
}
} while (length > 0);
return encoded_bytes;
}
/**
* @brief Encodes fixed header for the MQTT message and provides pointer to
* start of the header.
*
* @param[in] message_type Message type containing packet type and the flags.
* Use @ref MQTT_MESSAGES_OPTIONS to construct the
* message_type.
* @param[in] start Pointer to the start of the variable header.
* @param[inout] buf Buffer context used to encode the frame.
* The 5 bytes before the start of the message are assumed
* by the routine to be available to pack the fixed header.
* However, since the fixed header length is variable
* length, the pointer to the start of the MQTT message
* along with encoded fixed header is supplied as output
* parameter if the procedure was successful.
* As output, the pointers will point to beginning and the end
* of the frame.
*
* @retval 0 if the procedure is successful.
* @retval -EMSGSIZE if the message is too big for MQTT.
*/
static uint32_t mqtt_encode_fixed_header(uint8_t message_type, uint8_t *start,
struct buf_ctx *buf)
{
uint32_t length = buf->cur - start;
uint8_t fixed_header_length;
if (length > MQTT_MAX_PAYLOAD_SIZE) {
return -EMSGSIZE;
}
NET_DBG("<< msg type:0x%02x length:0x%08x", message_type, length);
fixed_header_length = packet_length_encode(length, NULL);
fixed_header_length += sizeof(uint8_t);
NET_DBG("Fixed header length = %02x", fixed_header_length);
/* Set the pointer at the start of the frame before encoding. */
buf->cur = start - fixed_header_length;
(void)pack_uint8(message_type, buf);
(void)packet_length_encode(length, buf);
/* Set the cur pointer back at the start of the frame,
* and end pointer to the end of the frame.
*/
buf->cur = buf->cur - fixed_header_length;
buf->end = buf->cur + length + fixed_header_length;
return 0;
}
/**
* @brief Encodes a string of a zero length.
*
* @param[in] buffer_len Total size of the buffer on which string will be
* encoded. This shall not be zero.
* @param[inout] buf A pointer to the buf_ctx structure containing current
* buffer position.
*
* @retval 0 if the procedure is successful.
* @retval -ENOMEM if there is no place in the buffer to store the binary
* string.
*/
static int zero_len_str_encode(struct buf_ctx *buf)
{
return pack_uint16(0x0000, buf);
}
/**
* @brief Encodes and sends messages that contain only message id in
* the variable header.
*
* @param[in] message_type Message type and reserved bit fields.
* @param[in] message_id Message id to be encoded in the variable header.
* @param[inout] buf_ctx Pointer to the buffer context structure,
* containing buffer for the encoded message.
*
* @retval 0 or an error code indicating a reason for failure.
*/
static int mqtt_message_id_only_enc(uint8_t message_type, uint16_t message_id,
struct buf_ctx *buf)
{
int err_code;
uint8_t *start;
/* Message id zero is not permitted by spec. */
if (message_id == 0U) {
return -EINVAL;
}
/* Reserve space for fixed header. */
buf->cur += MQTT_FIXED_HEADER_MAX_SIZE;
start = buf->cur;
err_code = pack_uint16(message_id, buf);
if (err_code != 0) {
return err_code;
}
return mqtt_encode_fixed_header(message_type, start, buf);
}
int connect_request_encode(const struct mqtt_client *client,
struct buf_ctx *buf)
{
uint8_t connect_flags = client->clean_session << 1;
const uint8_t message_type =
MQTT_MESSAGES_OPTIONS(MQTT_PKT_TYPE_CONNECT, 0, 0, 0);
const struct mqtt_utf8 *mqtt_proto_desc;
uint8_t *connect_flags_pos;
int err_code;
uint8_t *start;
if (client->protocol_version == MQTT_VERSION_3_1_1) {
mqtt_proto_desc = &mqtt_3_1_1_proto_desc;
} else {
mqtt_proto_desc = &mqtt_3_1_0_proto_desc;
}
/* Reserve space for fixed header. */
buf->cur += MQTT_FIXED_HEADER_MAX_SIZE;
start = buf->cur;
NET_HEXDUMP_DBG(mqtt_proto_desc->utf8, mqtt_proto_desc->size,
"Encoding Protocol Description.");
err_code = pack_utf8_str(mqtt_proto_desc, buf);
if (err_code != 0) {
return err_code;
}
NET_DBG("Encoding Protocol Version %02x.", client->protocol_version);
err_code = pack_uint8(client->protocol_version, buf);
if (err_code != 0) {
return err_code;
}
/* Remember position of connect flag and leave one byte for it to
* be packed once we determine its value.
*/
connect_flags_pos = buf->cur;
err_code = pack_uint8(0, buf);
if (err_code != 0) {
return err_code;
}
NET_DBG("Encoding Keep Alive Time %04x.", client->keepalive);
err_code = pack_uint16(client->keepalive, buf);
if (err_code != 0) {
return err_code;
}
NET_HEXDUMP_DBG(client->client_id.utf8, client->client_id.size,
"Encoding Client Id.");
err_code = pack_utf8_str(&client->client_id, buf);
if (err_code != 0) {
return err_code;
}
/* Pack will topic and QoS */
if (client->will_topic != NULL) {
connect_flags |= MQTT_CONNECT_FLAG_WILL_TOPIC;
/* QoS is always 1 as of now. */
connect_flags |= ((client->will_topic->qos & 0x03) << 3);
connect_flags |= client->will_retain << 5;
NET_HEXDUMP_DBG(client->will_topic->topic.utf8,
client->will_topic->topic.size,
"Encoding Will Topic.");
err_code = pack_utf8_str(&client->will_topic->topic, buf);
if (err_code != 0) {
return err_code;
}
if (client->will_message != NULL) {
NET_HEXDUMP_DBG(client->will_message->utf8,
client->will_message->size,
"Encoding Will Message.");
err_code = pack_utf8_str(client->will_message, buf);
if (err_code != 0) {
return err_code;
}
} else {
NET_DBG("Encoding Zero Length Will Message.");
err_code = zero_len_str_encode(buf);
if (err_code != 0) {
return err_code;
}
}
}
/* Pack Username if any. */
if (client->user_name != NULL) {
connect_flags |= MQTT_CONNECT_FLAG_USERNAME;
NET_HEXDUMP_DBG(client->user_name->utf8,
client->user_name->size,
"Encoding Username.");
err_code = pack_utf8_str(client->user_name, buf);
if (err_code != 0) {
return err_code;
}
}
/* Pack Password if any. */
if (client->password != NULL) {
connect_flags |= MQTT_CONNECT_FLAG_PASSWORD;
NET_HEXDUMP_DBG(client->password->utf8,
client->password->size,
"Encoding Password.");
err_code = pack_utf8_str(client->password, buf);
if (err_code != 0) {
return err_code;
}
}
/* Write the flags the connect flags. */
*connect_flags_pos = connect_flags;
return mqtt_encode_fixed_header(message_type, start, buf);
}
int publish_encode(const struct mqtt_publish_param *param, struct buf_ctx *buf)
{
const uint8_t message_type = MQTT_MESSAGES_OPTIONS(
MQTT_PKT_TYPE_PUBLISH, param->dup_flag,
param->message.topic.qos, param->retain_flag);
int err_code;
uint8_t *start;
/* Message id zero is not permitted by spec. */
if ((param->message.topic.qos) && (param->message_id == 0U)) {
return -EINVAL;
}
/* Reserve space for fixed header. */
buf->cur += MQTT_FIXED_HEADER_MAX_SIZE;
start = buf->cur;
err_code = pack_utf8_str(¶m->message.topic.topic, buf);
if (err_code != 0) {
return err_code;
}
if (param->message.topic.qos) {
err_code = pack_uint16(param->message_id, buf);
if (err_code != 0) {
return err_code;
}
}
/* Do not copy payload. We move the buffer pointer to ensure that
* message length in fixed header is encoded correctly.
*/
buf->cur += param->message.payload.len;
err_code = mqtt_encode_fixed_header(message_type, start, buf);
if (err_code != 0) {
return err_code;
}
buf->end -= param->message.payload.len;
return 0;
}
int publish_ack_encode(const struct mqtt_puback_param *param,
struct buf_ctx *buf)
{
const uint8_t message_type =
MQTT_MESSAGES_OPTIONS(MQTT_PKT_TYPE_PUBACK, 0, 0, 0);
return mqtt_message_id_only_enc(message_type, param->message_id, buf);
}
int publish_receive_encode(const struct mqtt_pubrec_param *param,
struct buf_ctx *buf)
{
const uint8_t message_type =
MQTT_MESSAGES_OPTIONS(MQTT_PKT_TYPE_PUBREC, 0, 0, 0);
return mqtt_message_id_only_enc(message_type, param->message_id, buf);
}
int publish_release_encode(const struct mqtt_pubrel_param *param,
struct buf_ctx *buf)
{
const uint8_t message_type =
MQTT_MESSAGES_OPTIONS(MQTT_PKT_TYPE_PUBREL, 0, 1, 0);
return mqtt_message_id_only_enc(message_type, param->message_id, buf);
}
int publish_complete_encode(const struct mqtt_pubcomp_param *param,
struct buf_ctx *buf)
{
const uint8_t message_type =
MQTT_MESSAGES_OPTIONS(MQTT_PKT_TYPE_PUBCOMP, 0, 0, 0);
return mqtt_message_id_only_enc(message_type, param->message_id, buf);
}
int disconnect_encode(struct buf_ctx *buf)
{
uint8_t *cur = buf->cur;
uint8_t *end = buf->end;
if ((end - cur) < sizeof(disc_packet)) {
return -ENOMEM;
}
memcpy(cur, disc_packet, sizeof(disc_packet));
buf->end = (cur + sizeof(disc_packet));
return 0;
}
int subscribe_encode(const struct mqtt_subscription_list *param,
struct buf_ctx *buf)
{
const uint8_t message_type = MQTT_MESSAGES_OPTIONS(
MQTT_PKT_TYPE_SUBSCRIBE, 0, 1, 0);
int err_code, i;
uint8_t *start;
/* Message id zero is not permitted by spec. */
if (param->message_id == 0U) {
return -EINVAL;
}
/* Reserve space for fixed header. */
buf->cur += MQTT_FIXED_HEADER_MAX_SIZE;
start = buf->cur;
err_code = pack_uint16(param->message_id, buf);
if (err_code != 0) {
return err_code;
}
for (i = 0; i < param->list_count; i++) {
err_code = pack_utf8_str(¶m->list[i].topic, buf);
if (err_code != 0) {
return err_code;
}
err_code = pack_uint8(param->list[i].qos, buf);
if (err_code != 0) {
return err_code;
}
}
return mqtt_encode_fixed_header(message_type, start, buf);
}
int unsubscribe_encode(const struct mqtt_subscription_list *param,
struct buf_ctx *buf)
{
const uint8_t message_type = MQTT_MESSAGES_OPTIONS(
MQTT_PKT_TYPE_UNSUBSCRIBE, 0, MQTT_QOS_1_AT_LEAST_ONCE, 0);
int err_code, i;
uint8_t *start;
/* Reserve space for fixed header. */
buf->cur += MQTT_FIXED_HEADER_MAX_SIZE;
start = buf->cur;
err_code = pack_uint16(param->message_id, buf);
if (err_code != 0) {
return err_code;
}
for (i = 0; i < param->list_count; i++) {
err_code = pack_utf8_str(¶m->list[i].topic, buf);
if (err_code != 0) {
return err_code;
}
}
return mqtt_encode_fixed_header(message_type, start, buf);
}
int ping_request_encode(struct buf_ctx *buf)
{
uint8_t *cur = buf->cur;
uint8_t *end = buf->end;
if ((end - cur) < sizeof(ping_packet)) {
return -ENOMEM;
}
memcpy(cur, ping_packet, sizeof(ping_packet));
buf->end = (cur + sizeof(ping_packet));
return 0;
}
```
|
Coombabah is a suburb in the City of Gold Coast, Queensland, Australia. In the , Coombabah had a population of 10,388 people.
Geography
Surrounding Coombabah is Paradise Point and Hope Island to the north, Arundel to the south, Runaway Bay and Biggera Waters to the east and Helensvale to the west and the Coombabah State High School. The minor arterial road servicing Coombabah is Oxley Drive.
History
The suburb takes its name from Coombabah Lake and Coombabah Creek, which in turn are named using Bundjalung language, Ngaraangbal dialect words meaning place of the wood grubs, from the word goombo meaning teredo worm, which was a deliberately cultivated food source by the Indigenous people.
Coombabah Provisional School opened circa July 1887 as a special school for the children of parents who were employed in Public Works in the area. The school was moved to Acrobat Creek and re-opened on 10 Jan 1889 as Acrobat Creek Provisional School for the children of workers building railways in the area. It closed in September 1890.
In August 1920, another Coombabah Provisional School opened as a half-time provisional school in conjunction with Pine Ridge Provisional School (meaning the schools shared the teacher). closed on April-24. In JUly 1922 it closed due to low student number, but later that year re-opened as a full-time previsional school (having its own teacher). It closed permanently in April 1924.
Coombabah State School opened on 27 January 1981.
Coombabah State High School opened on 28 January 1986.
In the , Coombabah had a population of 9,303. It grew to 9,774 by the .
In the , Coombabah recorded a population of 9,774 people, 54.1% female and 45.9% male. The median age of the Coombabah population was 45 years, 8 years above the national median of 37. 61.6% of people living in Coombabah were born in Australia. The other top responses for country of birth were New Zealand 10.6%, England 8.8%, Scotland 1.2%, South Africa 1.1%, Philippines 1%. 87% of people spoke only English at home; the next most common languages were 0.5% Tagalog, 0.5% French, 0.5% Japanese, 0.5% Italian, 0.5% Mandarin.
In the , Coombabah had a population of 10,388 people.
Coombabah Conservation Area
Sometimes called Coombabah Lake, the Coombabah Lakelands is one of only five sites in Queensland included in the Ramsar international convention for significant wetlands. The conservation area is surrounded by homes, roads and businesses. The land was bought by Council in the 1980s as a buffer zone for a sewerage plant. In 1994 that Council declared the Coombabah Lakeland Conservation Area. The integrity of the conservation and animal habitat is overseen by several Authorities. There are ten kilometres worth of dirt tracks, gravel and boardwalks for access by the public. For marine habitat the area is a protected fish habitat under the Queensland Fisheries Act and a protected marine conservation and habitat zone under the Moreton Bay Marine Park Zoning plan. Guided bush walks day and night are run by the council's Natural Areas Management Unit. Three is a carpark on Rain Tree Glen for access to tracks.
Birds
Griffith University's Healthy Rivers Institute conduct ongoing research in the area. Over 150 bird species use the area, so conservation of the wetlands aims to ensure migratory birds can use the area, and will continue to come. Coombabah is also part of migratory bird agreements with China and Japan. The threatened migratory eastern curlew rests at Coombabah on its way to Russia or north-eastern China breeding grounds. A bird hide is accessed off Shelter Road. Brisbane/Gold Coast branch of Bird Observation and Conservation Australia organise guided bird watching visits.
Education
Coombabah State School is a government primary (Prep-6) school for boys and girls at 164-172 Oxley Drive (). In 2017, the school had an enrolment of 734 students with 53 teachers (46 full-time equivalent) and 25 non-teaching staff (17 full-time equivalent). It includes a special education program.
Coombabah State High School is a government secondary (7-12) school for boys and girls at Pine Ridge Road (). In 2017, the school had an enrolment of 1100 students with 92 teachers (88 full-time equivalent) and 41 non-teaching staff (32 full-time equivalent). It includes a special education program.
Notable residents
Ugly Dave Gray, television personality.
Taine Tuaupiki, rugby league player.
References
Sources
Allen, J. Grammar, Vocabulary and Notes of the Wangerriburra Tribe.
Gresty, J.A., The Numinbah Valley; its geography, history and Aboriginal associations.
Steele, J.G., Aboriginal Pathways in Southeast Queensland and the Richmond River, p. 63.
Hanlon, W.E., The Early Settlers of the Logan and Albert Districts.
External links
Suburbs of the Gold Coast, Queensland
|
```forth
*> \brief <b> DPTSVX computes the solution to system of linear equations A * X = B for PT matrices</b>
*
* =========== DOCUMENTATION ===========
*
* Online html documentation available at
* path_to_url
*
*> \htmlonly
*> Download DPTSVX + dependencies
*> <a href="path_to_url">
*> [TGZ]</a>
*> <a href="path_to_url">
*> [ZIP]</a>
*> <a href="path_to_url">
*> [TXT]</a>
*> \endhtmlonly
*
* Definition:
* ===========
*
* SUBROUTINE DPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX,
* RCOND, FERR, BERR, WORK, INFO )
*
* .. Scalar Arguments ..
* CHARACTER FACT
* INTEGER INFO, LDB, LDX, N, NRHS
* DOUBLE PRECISION RCOND
* ..
* .. Array Arguments ..
* DOUBLE PRECISION B( LDB, * ), BERR( * ), D( * ), DF( * ),
* $ E( * ), EF( * ), FERR( * ), WORK( * ),
* $ X( LDX, * )
* ..
*
*
*> \par Purpose:
* =============
*>
*> \verbatim
*>
*> DPTSVX uses the factorization A = L*D*L**T to compute the solution
*> to a real system of linear equations A*X = B, where A is an N-by-N
*> symmetric positive definite tridiagonal matrix and X and B are
*> N-by-NRHS matrices.
*>
*> Error bounds on the solution and a condition estimate are also
*> provided.
*> \endverbatim
*
*> \par Description:
* =================
*>
*> \verbatim
*>
*> The following steps are performed:
*>
*> 1. If FACT = 'N', the matrix A is factored as A = L*D*L**T, where L
*> is a unit lower bidiagonal matrix and D is diagonal. The
*> factorization can also be regarded as having the form
*> A = U**T*D*U.
*>
*> 2. If the leading principal minor of order i is not positive,
*> then the routine returns with INFO = i. Otherwise, the factored
*> form of A is used to estimate the condition number of the matrix
*> A. If the reciprocal of the condition number is less than machine
*> precision, INFO = N+1 is returned as a warning, but the routine
*> still goes on to solve for X and compute error bounds as
*> described below.
*>
*> 3. The system of equations is solved for X using the factored form
*> of A.
*>
*> 4. Iterative refinement is applied to improve the computed solution
*> matrix and calculate error bounds and backward error estimates
*> for it.
*> \endverbatim
*
* Arguments:
* ==========
*
*> \param[in] FACT
*> \verbatim
*> FACT is CHARACTER*1
*> Specifies whether or not the factored form of A has been
*> supplied on entry.
*> = 'F': On entry, DF and EF contain the factored form of A.
*> D, E, DF, and EF will not be modified.
*> = 'N': The matrix A will be copied to DF and EF and
*> factored.
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*> N is INTEGER
*> The order of the matrix A. N >= 0.
*> \endverbatim
*>
*> \param[in] NRHS
*> \verbatim
*> NRHS is INTEGER
*> The number of right hand sides, i.e., the number of columns
*> of the matrices B and X. NRHS >= 0.
*> \endverbatim
*>
*> \param[in] D
*> \verbatim
*> D is DOUBLE PRECISION array, dimension (N)
*> The n diagonal elements of the tridiagonal matrix A.
*> \endverbatim
*>
*> \param[in] E
*> \verbatim
*> E is DOUBLE PRECISION array, dimension (N-1)
*> The (n-1) subdiagonal elements of the tridiagonal matrix A.
*> \endverbatim
*>
*> \param[in,out] DF
*> \verbatim
*> DF is DOUBLE PRECISION array, dimension (N)
*> If FACT = 'F', then DF is an input argument and on entry
*> contains the n diagonal elements of the diagonal matrix D
*> from the L*D*L**T factorization of A.
*> If FACT = 'N', then DF is an output argument and on exit
*> contains the n diagonal elements of the diagonal matrix D
*> from the L*D*L**T factorization of A.
*> \endverbatim
*>
*> \param[in,out] EF
*> \verbatim
*> EF is DOUBLE PRECISION array, dimension (N-1)
*> If FACT = 'F', then EF is an input argument and on entry
*> contains the (n-1) subdiagonal elements of the unit
*> bidiagonal factor L from the L*D*L**T factorization of A.
*> If FACT = 'N', then EF is an output argument and on exit
*> contains the (n-1) subdiagonal elements of the unit
*> bidiagonal factor L from the L*D*L**T factorization of A.
*> \endverbatim
*>
*> \param[in] B
*> \verbatim
*> B is DOUBLE PRECISION array, dimension (LDB,NRHS)
*> The N-by-NRHS right hand side matrix B.
*> \endverbatim
*>
*> \param[in] LDB
*> \verbatim
*> LDB is INTEGER
*> The leading dimension of the array B. LDB >= max(1,N).
*> \endverbatim
*>
*> \param[out] X
*> \verbatim
*> X is DOUBLE PRECISION array, dimension (LDX,NRHS)
*> If INFO = 0 of INFO = N+1, the N-by-NRHS solution matrix X.
*> \endverbatim
*>
*> \param[in] LDX
*> \verbatim
*> LDX is INTEGER
*> The leading dimension of the array X. LDX >= max(1,N).
*> \endverbatim
*>
*> \param[out] RCOND
*> \verbatim
*> RCOND is DOUBLE PRECISION
*> The reciprocal condition number of the matrix A. If RCOND
*> is less than the machine precision (in particular, if
*> RCOND = 0), the matrix is singular to working precision.
*> This condition is indicated by a return code of INFO > 0.
*> \endverbatim
*>
*> \param[out] FERR
*> \verbatim
*> FERR is DOUBLE PRECISION array, dimension (NRHS)
*> The forward error bound for each solution vector
*> X(j) (the j-th column of the solution matrix X).
*> If XTRUE is the true solution corresponding to X(j), FERR(j)
*> is an estimated upper bound for the magnitude of the largest
*> element in (X(j) - XTRUE) divided by the magnitude of the
*> largest element in X(j).
*> \endverbatim
*>
*> \param[out] BERR
*> \verbatim
*> BERR is DOUBLE PRECISION array, dimension (NRHS)
*> The componentwise relative backward error of each solution
*> vector X(j) (i.e., the smallest relative change in any
*> element of A or B that makes X(j) an exact solution).
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*> WORK is DOUBLE PRECISION array, dimension (2*N)
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*> INFO is INTEGER
*> = 0: successful exit
*> < 0: if INFO = -i, the i-th argument had an illegal value
*> > 0: if INFO = i, and i is
*> <= N: the leading principal minor of order i of A
*> is not positive, so the factorization could not
*> be completed, and the solution has not been
*> computed. RCOND = 0 is returned.
*> = N+1: U is nonsingular, but RCOND is less than machine
*> precision, meaning that the matrix is singular
*> to working precision. Nevertheless, the
*> solution and error bounds are computed because
*> there are a number of situations where the
*> computed solution can be more accurate than the
*> value of RCOND would suggest.
*> \endverbatim
*
* Authors:
* ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup ptsvx
*
* =====================================================================
SUBROUTINE DPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX,
$ RCOND, FERR, BERR, WORK, INFO )
*
* -- LAPACK driver routine --
* -- LAPACK is a software package provided by Univ. of Tennessee, --
* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
* .. Scalar Arguments ..
CHARACTER FACT
INTEGER INFO, LDB, LDX, N, NRHS
DOUBLE PRECISION RCOND
* ..
* .. Array Arguments ..
DOUBLE PRECISION B( LDB, * ), BERR( * ), D( * ), DF( * ),
$ E( * ), EF( * ), FERR( * ), WORK( * ),
$ X( LDX, * )
* ..
*
* =====================================================================
*
* .. Parameters ..
DOUBLE PRECISION ZERO
PARAMETER ( ZERO = 0.0D+0 )
* ..
* .. Local Scalars ..
LOGICAL NOFACT
DOUBLE PRECISION ANORM
* ..
* .. External Functions ..
LOGICAL LSAME
DOUBLE PRECISION DLAMCH, DLANST
EXTERNAL LSAME, DLAMCH, DLANST
* ..
* .. External Subroutines ..
EXTERNAL DCOPY, DLACPY, DPTCON, DPTRFS, DPTTRF,
$ DPTTRS,
$ XERBLA
* ..
* .. Intrinsic Functions ..
INTRINSIC MAX
* ..
* .. Executable Statements ..
*
* Test the input parameters.
*
INFO = 0
NOFACT = LSAME( FACT, 'N' )
IF( .NOT.NOFACT .AND. .NOT.LSAME( FACT, 'F' ) ) THEN
INFO = -1
ELSE IF( N.LT.0 ) THEN
INFO = -2
ELSE IF( NRHS.LT.0 ) THEN
INFO = -3
ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
INFO = -9
ELSE IF( LDX.LT.MAX( 1, N ) ) THEN
INFO = -11
END IF
IF( INFO.NE.0 ) THEN
CALL XERBLA( 'DPTSVX', -INFO )
RETURN
END IF
*
IF( NOFACT ) THEN
*
* Compute the L*D*L**T (or U**T*D*U) factorization of A.
*
CALL DCOPY( N, D, 1, DF, 1 )
IF( N.GT.1 )
$ CALL DCOPY( N-1, E, 1, EF, 1 )
CALL DPTTRF( N, DF, EF, INFO )
*
* Return if INFO is non-zero.
*
IF( INFO.GT.0 )THEN
RCOND = ZERO
RETURN
END IF
END IF
*
* Compute the norm of the matrix A.
*
ANORM = DLANST( '1', N, D, E )
*
* Compute the reciprocal of the condition number of A.
*
CALL DPTCON( N, DF, EF, ANORM, RCOND, WORK, INFO )
*
* Compute the solution vectors X.
*
CALL DLACPY( 'Full', N, NRHS, B, LDB, X, LDX )
CALL DPTTRS( N, NRHS, DF, EF, X, LDX, INFO )
*
* Use iterative refinement to improve the computed solutions and
* compute error bounds and backward error estimates for them.
*
CALL DPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR, BERR,
$ WORK, INFO )
*
* Set INFO = N+1 if the matrix is singular to working precision.
*
IF( RCOND.LT.DLAMCH( 'Epsilon' ) )
$ INFO = N + 1
*
RETURN
*
* End of DPTSVX
*
END
```
|
```yaml
### YamlMime:HowTo
metadata:
title: Attach a data disk to a Linux VM
description: Use the portal to attach new or existing data disk to a Linux VM.
author: roygara
ms.author: rogarana
ms.date: 03/19/2024
ms.service: azure-disk-storage
ms.topic: how-to
ms.collection: linux
ms.custom:
- linux-related-content
- ge-structured-content-pilot
title: |
Use the portal to attach a data disk to a Linux VM
introduction: |
**Applies to:** :heavy_check_mark: Linux VMs :heavy_check_mark: Flexible scale sets
This article shows you how to attach both new and existing disks to a Linux virtual machine through the Azure portal. You can also [attach a data disk to a Windows VM in the Azure portal](../windows/attach-managed-disk-portal.yml).
prerequisites:
summary: |
Before you attach disks to your VM, review these tips:
dependencies:
- The size of the virtual machine controls how many data disks you can attach. For details, see [Sizes for virtual machines](../sizes.md).
procedureSection:
- title: |
Find the virtual machine
summary: |
Follow these steps:
steps:
- |
Go to the [Azure portal](path_to_url to find the VM. Search for and select **Virtual machines**.
- |
Select the VM you'd like to attach the disk to from the list.
- |
In the **Virtual machines** page, under **Settings**, select **Disks**.
- title: |
Attach a new disk
summary: |
Follow these steps:
steps:
- |
On the **Disks** pane, under **Data disks**, select **Create and attach a new disk**.
- |
Enter a name for your managed disk. Review the default settings, and update the **Storage type**, **Size (GiB)**, **Encryption** and **Host caching** as necessary.
:::image type="content" source="./media/attach-disk-portal/create-new-md.png" alt-text="Screenshot of review disk settings." lightbox="./media/attach-disk-portal/create-new-md.png":::
- |
When you're done, select **Save** at the top of the page to create the managed disk and update the VM configuration.
- title: |
Attach an existing disk
summary: |
Follow these steps:
steps:
- |
On the **Disks** pane, under **Data disks**, select **Attach existing disks**.
- |
Select the drop-down menu for **Disk name** and select a disk from the list of available managed disks.
- |
Select **Save** to attach the existing managed disk and update the VM configuration:
- title: |
Connect to the Linux VM to mount the new disk
summary: |
To partition, format, and mount your new disk so your Linux VM can use it, SSH into your VM. For more information, see [How to use SSH with Linux on Azure](mac-create-ssh-keys.md). The following example connects to a VM with the public IP address of *10.123.123.25* with the username *azureuser*:
code: |
```bash
ssh azureuser@10.123.123.25
```
- title: |
Find the disk
summary: |
Once connected to your VM, you need to find the disk. In this example, we're using `lsblk` to list the disks.
code: |
```bash
lsblk -o NAME,HCTL,SIZE,MOUNTPOINT | grep -i "sd"
```
The output is similar to the following example:
```output
sda 0:0:0:0 30G
sda1 29.9G /
sda14 4M
sda15 106M /boot/efi
sdb 1:0:1:0 14G
sdb1 14G /mnt
sdc 3:0:0:0 4G
```
In this example, the disk that was added was `sdc`. It's a LUN 0 and is 4GB.
For a more complex example, here's what multiple data disks look like in the portal:
:::image type="content" source="./media/attach-disk-portal/find-disk.png" alt-text="Screenshot of multiple disks shown in the portal.":::
In the image, you can see that there are 3 data disks: 4 GB on LUN 0, 16GB at LUN 1, and 32G at LUN 2.
Here's what that might look like using `lsblk`:
```output
sda 0:0:0:0 30G
sda1 29.9G /
sda14 4M
sda15 106M /boot/efi
sdb 1:0:1:0 14G
sdb1 14G /mnt
sdc 3:0:0:0 4G
sdd 3:0:0:1 16G
sde 3:0:0:2 32G
```
From the output of `lsblk` you can see that the 4GB disk at LUN 0 is `sdc`, the 16GB disk at LUN 1 is `sdd`, and the 32G disk at LUN 2 is `sde`.
### Prepare a new empty disk
> [!IMPORTANT]
> If you are using an existing disk that contains data, skip to [mounting the disk](#mount-the-disk).
> The following instructions will delete data on the disk.
If you're attaching a new disk, you need to partition the disk.
The `parted` utility can be used to partition and to format a data disk.
- Use the latest version `parted` that is available for your distro.
- If the disk size is 2 tebibytes (TiB) or larger, you must use GPT partitioning. If disk size is under 2 TiB, then you can use either MBR or GPT partitioning.
The following example uses `parted` on `/dev/sdc`, which is where the first data disk will typically be on most VMs. Replace `sdc` with the correct option for your disk. We're also formatting it using the [XFS](path_to_url filesystem.
```bash
sudo parted /dev/sdc --script mklabel gpt mkpart xfspart xfs 0% 100%
sudo mkfs.xfs /dev/sdc1
sudo partprobe /dev/sdc1
```
Use the [`partprobe`](path_to_url utility to make sure the kernel is aware of the new partition and filesystem. Failure to use `partprobe` can cause the blkid or lslbk commands to not return the UUID for the new filesystem immediately.
### Mount the disk
Create a directory to mount the file system using `mkdir`. The following example creates a directory at `/datadrive`:
```bash
sudo mkdir /datadrive
```
Use `mount` to then mount the filesystem. The following example mounts the */dev/sdc1* partition to the `/datadrive` mount point:
```bash
sudo mount /dev/sdc1 /datadrive
```
To ensure that the drive is remounted automatically after a reboot, it must be added to the */etc/fstab* file. It's also highly recommended that the UUID (Universally Unique Identifier) is used in */etc/fstab* to refer to the drive rather than just the device name (such as, */dev/sdc1*). If the OS detects a disk error during boot, using the UUID avoids the incorrect disk being mounted to a given location. Remaining data disks would then be assigned those same device IDs. To find the UUID of the new drive, use the `blkid` utility:
```bash
sudo blkid
```
The output looks similar to the following example:
```output
/dev/sda1: LABEL="cloudimg-rootfs" UUID="11111111-1b1b-1c1c-1d1d-1e1e1e1e1e1e" TYPE="ext4" PARTUUID="1a1b1c1d-11aa-1234-1a1a1a1a1a1a"
/dev/sda15: LABEL="UEFI" UUID="BCD7-96A6" TYPE="vfat" PARTUUID="1e1g1cg1h-11aa-1234-1u1u1a1a1u1u"
/dev/sdb1: UUID="22222222-2b2b-2c2c-2d2d-2e2e2e2e2e2e" TYPE="ext4" TYPE="ext4" PARTUUID="1a2b3c4d-01"
/dev/sda14: PARTUUID="2e2g2cg2h-11aa-1234-1u1u1a1a1u1u"
/dev/sdc1: UUID="33333333-3b3b-3c3c-3d3d-3e3e3e3e3e3e" TYPE="xfs" PARTLABEL="xfspart" PARTUUID="c1c2c3c4-1234-cdef-asdf3456ghjk"
```
> [!NOTE]
> Improperly editing the **/etc/fstab** file could result in an unbootable system. If unsure, refer to the distribution's documentation for information on how to properly edit this file. You should create a backup of the **/etc/fstab** file is created before editing.
Next, open the **/etc/fstab** file in a text editor. Add a line to the end of the file, using the UUID value for the `/dev/sdc1` device that was created in the previous steps, and the mountpoint of `/datadrive`. Using the example from this article, the new line would look like the following:
```config
UUID=33333333-3b3b-3c3c-3d3d-3e3e3e3e3e3e /datadrive xfs defaults,nofail 1 2
```
When you're done editing the file, save and close the editor.
> [!NOTE]
> Later removing a data disk without editing fstab could cause the VM to fail to boot. Most distributions provide either the *nofail* and/or *nobootwait* fstab options. These options allow a system to boot even if the disk fails to mount at boot time. Consult your distribution's documentation for more information on these parameters.
>
> The *nofail* option ensures that the VM starts even if the filesystem is corrupt or the disk does not exist at boot time. Without this option, you may encounter behavior as described in [Cannot SSH to Linux VM due to FSTAB errors](/archive/blogs/linuxonazure/your_sha256_hashbooting)
- title: |
Verify the disk
summary: |
You can now use `lsblk` again to see the disk and the mountpoint.
```bash
lsblk -o NAME,HCTL,SIZE,MOUNTPOINT | grep -i "sd"
```
The output will look something like this:
```output
sda 0:0:0:0 30G
sda1 29.9G /
sda14 4M
sda15 106M /boot/efi
sdb 1:0:1:0 14G
sdb1 14G /mnt
sdc 3:0:0:0 4G
sdc1 4G /datadrive
```
You can see that `sdc` is now mounted at `/datadrive`.
### TRIM/UNMAP support for Linux in Azure
Some Linux kernels support TRIM/UNMAP operations to discard unused blocks on the disk. This feature is primarily useful to inform Azure that deleted pages are no longer valid and can be discarded. This feature can save money on disks that are billed based on the amount of consumed storage, such as unmanaged standard disks and disk snapshots.
There are two ways to enable TRIM support in your Linux VM. As usual, consult your distribution for the recommended approach:
steps:
- |
Use the `discard` mount option in */etc/fstab*, for example:
```config
UUID=33333333-3b3b-3c3c-3d3d-3e3e3e3e3e3e /datadrive xfs defaults,discard 1 2
```
- |
In some cases, the `discard` option may have performance implications. Alternatively, you can run the `fstrim` command manually from the command line, or add it to your crontab to run regularly:
**Ubuntu**
```bash
sudo apt-get install util-linux
sudo fstrim /datadrive
```
**RHEL**
```bash
sudo yum install util-linux
sudo fstrim /datadrive
```
**SUSE**
```bash
sudo zypper install util-linux
sudo fstrim /datadrive
```
relatedContent:
- text: Troubleshoot Linux VM device name changes
url: /troubleshoot/azure/virtual-machines/troubleshoot-device-names-problems
- text: Attach a data disk using the Azure CLI
url: add-disk.md
#For more information, and to help troubleshoot disk issues, see [Troubleshoot Linux VM device name changes](/troubleshoot/azure/virtual-machines/troubleshoot-device-names-problems).
#You can also [attach a data disk](add-disk.md) using the Azure CLI.
```
|
```xml
<vector xmlns:android="path_to_url" android:height="34.0dp" android:tint="?attr/colorControlNormal" android:viewportHeight="15" android:viewportWidth="15" android:width="34.0dp">
<path android:fillColor="@android:color/white" android:pathData="M3 2L4 0L11 0L12 2L12.5 2C12.78 2 13 2.22 13 2.5L13 3.5C13 3.78 12.78 4 12.5 4L12 4L11 15L4 15L3 4L2.5 4C2.22 4 2 3.78 2 3.5L2 2.5C2 2.22 2.22 2 2.5 2L3 2L3 2ZM10.82 6L11 4L4 4L4.19 6L10.82 6L10.82 6ZM10.27 12L4.73 12L4.91 14L10.09 14L10.27 12L10.27 12Z"/>
</vector>
```
|
Valcourt may refer to:
Places
Valcourt (city), a city in Quebec, Canada
Valcourt (township), surrounding the city of Valcourt
Valcourt, Haute-Marne, a commune in the Haute-Marne department, France
People
Bernard Valcourt (born 1952), Canadian politician and lawyer
David P. Valcourt (born 1951), United States Army general
See also
Valcour (disambiguation)
|
```php
<?php
namespace PragmaRX\Health\Tests\PhpUnit\Service;
use PragmaRX\Health\Support\Timer;
use PragmaRX\Health\Tests\PhpUnit\TestCase;
class TimerTest extends TestCase
{
public function testCanStartTimer()
{
Timer::start();
sleep(1);
$this->assertEquals(1, (int) Timer::stop());
}
}
```
|
The Texaco Footballer of the Year was a Gaelic football award, created in 1958, that honoured the achievements of a footballer of outstanding excellence. The award was part of the Texaco Sportstars Awards, in which Irish sportspeople from all fields were honoured.
The award was presented annually to the Gaelic footballer considered to have performed the best over the previous year in the Football Championship. Voting for the award was undertaken by a select group of journalists from television and the print media. The award itself, standing 14 inches high, was one of the most sought-after accolades in Irish sport.
This award is distinct from the All Stars Footballer of the Year, awarded by the GAA since 1995, as part of the GAA GPA All Stars Awards. Marc and Tomás Ó Sé of Kerry, and Alan and Bernard Brogan (junior) of Dublin are the only pairs of brothers to have won the award. Jack O'Shea of Kerry has won the award the most times, with four wins.
The award was discontinued in 2012 after Texaco withdrew their sponsorship.
Recipients
References
1958 establishments in Ireland
Awards established in 1958
Gaelic football awards
Texaco
Annual events in Ireland
|
Como Park Senior High School (CPSHS or commonly known as CPHS) is a public high school located in the Lake Como area of Saint Paul, Minnesota, United States, serving grades nine through twelve. Along with nine other public high schools, Como Park comprises the Saint Paul Public Schools. Newsweek ranked the school in their "List of the Top High Schools in America" for the fourth time in five years (2006, 2007, 2009, and 2010).
History
Originally opened in 1957, Como Park Junior High School was converted into a senior high school in the fall of 1979, accepting students from the just closed Washington and Murray High Schools, both of which became junior highs that same year. The school originally began with only three classes - sophomores, juniors, and seniors. The freshman class was added in 1981. Construction was not completed when the school year began. The class of 1985 was the first four-year graduating class.
Renovation
In early 2016, plans to renovate the Como Park facilities were drafted by a school design committee, with the final plans including redoing artificial turf on the schools sports field, a building addition and interior renovations to create compacity for 100 new students through new education spaces, and a 2-story addition to the building. The construction of these additions first broke ground through early and late 2017, with the returfing of the field being completed the same year while the other projects were not complete until fall of 2020.
Education
Como Park's average score on the ACT exam was 21.2 compared to a state average of 22.6 and a national average of 21.1. 51.56% of students were considered proficient in reading while 22.08% were proficient in math. The school is currently meeting 83.9% of the Adequate Yearly Progress (AYP) requirements but is not meeting AYP due to low proficiency in mathematics. Como Park has an AYP graduation rate of 96%.
Through the Minnesota state Post Secondary Enrollment Options (PSEO) program, students are eligible to take classes at state colleges and universities.
Enrollment
Como Park enrolled 1,163 students in its 2020–2021 school year. Of the enrolled, those identifying as African American and Asian students are tied for the plurality at 33%, while 20% identify as Caucasian and 10% as Hispanic. Additionally, American Indian students compose 1% of the population, along with 3% identifying as 2 or more ethnicities. A little more than half, 62%, qualified for Free and Reduced Price Lunch, a measure of poverty. 37% of the students are enrolled in English Language Learning, and 13% are enrolled in special education.
Athletics
Cougar athletic programs compete in Class 4AA of the Minnesota State High School League.
Fall Sports
Boys': Cross-Country, Football, Soccer
Girls': Cross-Country, Soccer, Swimming & Diving, Tennis, Volleyball
Winter Sports
Boys': Basketball, Hockey, Nordic Skiing, Swimming & Diving, Wrestling
Girls': Alpine Skiing, Basketball, Gymnastics, Hockey, Nordic Skiing
Spring Sports
Boys': Baseball, Golf, Tennis, Track & Field, Ultimate
Girls': Badminton, Golf, Softball, Track & Field, Ultimate
State championships
In 2013, Como Park's boys soccer team won the class A state title in a 2–1 victory against Hill-Murray, earning their first state championship title.
Extracurricular activities
Robotics
Como Park's robotics team, BEASTBOT#2855, has competed in the FIRST Robotics Competition since 2009. From its founding date until 2019, the team competed in the Minnesota 10,000 lakes regional, Minnesota State High School League State Championships, Minnesota Robotics Invitational, Lake Superior Regional and the Minnesota North Star Regional. At these events, they earned the Minnesota 10000 Lakes Regional Entrepreneurship Award in 2016, and in the same year came in first at the Minnesota Robotics Invitational. The team stopped operating in 2019, but came back to compete in the 2023 Minnesota 10,000 lakes regional, where they came rank 30 out of 61 competitors.
Notable alumni
Lexii Alijai, rapper
Josh Blue, stand-up comedian, winner of Last Comic Standing
Andre Smith, former basketball power forward for North Dakota State University
Jay Xiong, politician
References
External links
Como Park Senior High School
Saint Paul Public Schools Athletic Department Website
1979 establishments in Minnesota
Educational institutions established in 1979
High schools in Saint Paul, Minnesota
Public high schools in Minnesota
|
```asciidoc
```
|
```xml
export * from './accessibility'
export * from './annotations'
export * from './axes'
export * from './chart-dimensions'
export * from './colors'
export * from './grid'
export * from './interactivity'
```
|
The Lollipop Generation is a 2008 Canadian underground experimental film written, produced, and directed by G. B. Jones, whose previous films include The Troublemakers and The Yo-Yo Gang. It premiered as the Gala Feature presentation of the Images Festival in Toronto on April 3, 2008.
Starring Jena von Brücker, the film tells the story of Georgie, a teenager who is forced to run away from home after coming out to her parents, and the homeless queer youth and other people she meets on the streets.
Synopsis
G. B. Jones’ The Lollipop Generation is a film about runaway queer kids, a gang of lollipop-eating social misfits let loose on the streets of Toronto. They stumble into drugs, danger, and prostitution, and inhabit an underground culture infused with a pervasive yet innocent kind of sleaze. Seasoned with a bottom-up punk aesthetic and a good handful of homemade porn, the film presents an altogether refreshing critique of the stultifying norms of convention.
Cast
Jena von Brücker as Georgie
Mark Ewert as Rufus
Jane Danger as Janie
KC Klass as Peanut
Vaginal Davis as Beulah Blacktress
Calvin Johnson as Playground pervert
Joel Gibb as Retardo
Jen Smith as Redheaded hopscotch girl
Johnny Noxzema as Porn director
Mitchell Watkins as Porn star
Rachel Pepper as Rich girl (Peanut's trick)
Torry Colichio as Metro Theatre girl
Becky Palov as Blonde hopscotch girl
DD Donato as Peanut's boyfriend
Andrew Cecil as Skateboarding streetkid in washroom
Paul P. as Washroom boy
Scott Treleaven as Washroom boy
Christy Cameron as Girl in store
Anonymous Boy as Hustler in a black leather jacket
Gary Fembot as New wave hustler
Ian Philips as Hustler
Kevin Constrictor as Hustler
Stevec as Hustler
Helen Bed as Shop owner
Clitoris Turner as Shop clerk
Rick Castro as Photographer
Ronster as Dumpster diver
G. B. Jones as Doorway denizen
Production
The film was made over a period of 15 years, "one Super-8 reel at a time", whenever the director could afford to buy another cartridge of film. In the end, the Toronto band Kids on TV organized a benefit so that G.B. Jones could finish it.
When asked if the film belonged to the "queer experimental" genre, G. B. Jones replied, "No, no, no. I mean, I think some people don't really get what we're doing, so they try to stick a label on us, to try to define and limit us. Some people call it experimental film, some people call it documentary filmmaking, other people call it “New Queer Cinema.” But we're going beyond the borders they're trying to impose on us. It is an experiment."
Filming
The film was shot on location across Canada and the United States, and features scenes at sites that have since been demolished, such as the Metro Theatre; Riverdale Hospital by architects Howard Chapman and Len Hurst; Adventure playground in Toronto; and Retail Slut in Los Angeles, California.
Reception
The Lollipop Generation was described by the Buenos Aires International Festival of Independent Cinema as, "...a trip through epileptic shots of documentary ugliness that go right to the origins and essence of sexually anarchic cinema...".
However, Peter Keough of The Boston Phoenix insists, "There's a fine line between the trash of early John Waters and just plain garbage. G.B. Jones, perhaps to her credit, ignores it completely." Using Canadian pop culture reference points, Toronto's Eye Weekly called it, "Scrappy as hell, yet often charming, it's a lost Degrassi High episode remade as an amateur porn flick and sometimes as sweet as all that candy."
Time Out described the film as serving "a diaristic function, documenting the people the director has met and the cities she travelled to, capturing an entire generation of underground performers." The 23rd Annual London L & G Film Festival catalogue says, "Shot on Super 8 and video, The Lollipop Generation harnesses these tools of the traditional home movie and uses them to make a fucked up family film."
References
Further reading
Liss, Sarah (2 April 2008). "The Lollipop Generation". Eye Weekly. Archived from the original on 17 May 2008.
External links
The Lollipop Generation at British Film Institute
The Lollipop Generation trailer
2008 films
2000s avant-garde and experimental films
2008 LGBT-related films
Canadian avant-garde and experimental films
Canadian LGBT-related films
English-language Canadian films
Punk films
Films about runaways
2000s English-language films
2000s Canadian films
|
```xml
<?xml version="1.0" encoding="utf-8"?>
<!--
~
~
~ path_to_url
~
~ Unless required by applicable law or agreed to in writing, software
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-->
<!-- Material3 alternative to textColorSecondary for dynamic dark theme -->
<selector xmlns:android="path_to_url">
<item android:state_enabled="false" android:alpha="@dimen/material_emphasis_disabled"
android:color="@color/m3_sys_color_dynamic_dark_on_surface"/>
<item android:color="@color/m3_sys_color_dynamic_dark_on_surface_variant"/>
</selector>
```
|
is the name of a series of co-joined appeals heard by the English Court of Appeal in relation to the efficacy of certain provisions under the standard form ISDA Master Agreement (1992 form). Four appeals were consolidated into a single hearing, and in a comprehensive joint judgment delivered by Lord Justice Longmore the Court attempted to provide definitive resolutions to various issues of interpretation which had given rise to conflicting judgments at first instance. One academic commentator has referred to the case as a "comprehensive judgment [which] masterfully resolved a number of conflicting strands of jurisprudence".<ref name=CMLR>{{cite journal |url=http://cmlj.oxfordjournals.org/content/8/4/395.short |title=Lomas v Firth Rixson: 'As you were!' |journal=Capital Markets Law Journal |volume=8 |page=395 |author=Edward Murray |accessdate=3 September 2015}}</ref>
The decision dealt with many of the same issues as the controversial Metavante ruling in the New York courts, although coming to the opposite conclusion under English law.
Facts
The facts varied between the individual appeals, but the common theme in each of them was that an Event of Default (as defined) had occurred under an ISDA Master Agreement, but the Defaulting Party (as defined) was "in the money", in the sense that if the open positions were all to be terminated, the non-Defaulting Party would have had to pay over considerable sums to the Defaulting Party to close out the various positions. However, in each case the relevant Master Agreements had not provided for automatic early termination upon an Event of Default. Accordingly, each non-Defaulting Party could simply elect not to terminate on the basis of the Event of Default and avoid paying the sums otherwise due to the Defaulting Party.
This problem was then compounded by the drafting of the ISDA Master Agreement which stated that non-occurrence of an Event of Default was a "condition precedent" to any payment obligation. In the cases before the court, because the Event of Default was continuing up until the time when the financial contracts would naturally have come due for payment, the non-Defaulting Parties argued that they never had to pay the sums due because the condition precedent was not satisfied; in essence they were entitled to a windfall and could avoid their liabilities under the relevant derivative contracts because of the other party's default.
The need for a comprehensive statement of the law by the Court of Appeal had been driven in part by a decision of Flaux J in Marine Trade SA v Pioneer Freight Futures Co Ltd [2010] Lloyds Rep 631 where the court had taken a position contrary to the orthodox market view in relation to the close-out provisions.
The different appeals had different derivative contracts under consideration, but most of the legal issues which arose were capable of being dealt with on a cojoined basis. The consolidated appeals were:
Judgment
In a long and often difficult judgment, the Court of Appeal sought to break the various points into individual issues which it addressed separately.
Suspension of payment
The Court of Appeal confirmed that because the non-occurrence of an Event of Default was a condition precedent to payment under the Master Agreement, this meant that if an Event of Default was continuing that no party could be under an obligation to make payment even if payment was otherwise due unless the non-Defaulting Party exercised its right to early termination. Effectively, under the contractual terms of the ISDA Master Agreement, the non-Defaulting Party was able to preclude its own liability to pay by relying upon the occurrence of an Event of Default in relation to the other party and simply not exercising the right to terminate. They rejected any argument that there was an implied term on the part of the non-Defaulting Party to terminate within a reasonable period of time or at all after the occurrence of an Event of Default.
Extinguishment of underlying right
Whilst an Event of Default subsisted any right to payment was effectively suspended. However, it was necessary to distinguish the debt from the obligation to pay; the underlying debt would continue to exist despite the fact that the payment obligation in respect of that debt did not arise under the terms of the Master Agreement.
Accordingly, the Court held, following the decision of the Supreme Court of New South Wales in Enron Australia v TXU Electricity [2003] NSWSC 1169, that the underlying debt remains in existing even though the payment obligation is inoperable. Accordingly, if the provisions preventing the operation of the payment obligation fall away, the "payment obligation will spring up under a pre-existing trade once the relevant condition is satisfied, and in that sense it might be said (with only approximate accuracy) that the payment obligation is 'suspended' while the condition remains unfulfilled."
It is important to note that these issues only arose in the first two appeals because the parties elected not to utilise the automatic early termination (AET) provisions in the Master Agreement. Accordingly, early termination could only by election, and that left the non-Defaulting Parties free to withhold making that election and crystallising their payment obligations. However the underlying analysis would be relevant to issues raised in the second two appeals.
Revival of payment right
The Court further held that there is no necessary implication that the payment right must inevitably revive at some point, after effluxion of time or otherwise. Arguments to the effect that there should be an implied term in the ISDA Master Agreement to that effect were dismissed. Although it might be administratively inconvenient, the result of the factual situation was that the non-Defaulting Party would remain liable to the Defaulting Party potentially forever, but never be under an obligation to make actual payment with respect to that liability.
Maturity of the transaction
At first instance it was held that the payment obligation of the non-Defaulting Party was suspended during the currency of the transaction, the suspension ended on maturity whereupon the liability was then extinguished. The court at first instance appeared to feel compelled to so hold, as otherwise the obligation would remain outstanding but not due for payment indefinitely. After considerably analysis of the various issues the Court of Appeal held however that this in fact the result:
The Court noted that this arguably was an administratively inconvenient result. It meant that one party continued to be indebted to another party, but that other party could never enforce the right to payment. The Court further noted that if the condition precedent was subsequently cured after maturity, then payment could still occur at that time. Ironically, under the defined terms in the agreement that would constitute "early" termination, although the actual termination would occur long after stated maturity.
Effect of condition precedent on netting
The Court of Appeal also had to consider (in the context of the second appeal) whether the fact that a condition precedent remained unsatisfied would prevent an underlying obligation accruing for the purposes of calculating a net position between the parties. In line with the decisions on the other issues, the Court of Appeal held that the rights may accrue, and may net-out; only the payment obligation is suspended. This followed from the analysis of the earlier points, but the Court was also reinforced in its conclusions by the wording of the netting provisions which used the express words "would otherwise be payable".
Anti-deprivation rule
In one of the cojoined appeals it was argued that if an Event of Default suspended the right of the Defaulting Party to receive payment indefinitely, then that would be a breach of the anti-deprivation rule. Because in this case the Event of Default was one party going into liquidation, that meant that the operating effect of the provision was to deprive the company's creditors of assets as a consequence of it going into liquidation. The Court referred to the recent decision of the Supreme Court in Belmont Park Investments Pty Ltd v BNY Corporate Trustee Services Ltd [2011] UKSC 38 and held that relevant test was to consider each transaction on its merits to see whether the shift in interests complained of could be justified as a genuine and justifiable commercial response to the consequences of insolvency. The Court of Appeal held that "If this is the touchstone then it is difficult to see how Section 2(a)(iii) of the Master Agreement can be said to offend against the anti-deprivation principle. ... There is no suggestion that it was formulated in order to avoid the effect of any insolvency law or to give the non-defaulting party a greater or disproportionate return as a creditor of the bankrupt estate."
Calculation of "Loss"
In the fourth appeal the Court of Appeal had to consider a Master Agreement where the parties had selected automatic early termination (AET). They had to therefore consider a separate point raised whereby whether the AET provisions necessarily assumed that all conditions precedent were satisfied (i.e. amongst other things, there was no Event of Default) for the purposes of carrying out the calculation of the amounts payable (defined as "Loss" under the agreement). The Court framed the question thus: "is Bulk as the Non-defaulting Party obliged to calculate its loss by reference to sums which would have become due to Britannia Bulk had Britannia Bulk not remained subject to an Event of Default after Automatic Early Termination?" The Court held not, and upheld the existing line of authority on this point, most notably in the decision of Gloster J in Pioneer Freight Co Ltd v TMT Asia Ltd [2011] 2 Lloyds Rep 96. In line with its decision on the earlier points in the decision, the Court of Appeal held that absence of a condition precedent preventing the payment mechanism working, but it did not otherwise affect the underlying debt accruing and being calculated in accordance with the terms of the agreement.
Other
Although not part of the ratio decidendi of the case, the Court of Appeal made a number of other notable pronouncements in the course of their judgment.
Definition of a derivative
The Court judicially approved the definition of a derivative adopted by the editors of Firth on Derivatives'':
Single agreement concept
The Court also definitively upheld the "single agreement" concept under the ISDA Master Agreement. Section 1(c) of the Master Agreement provides:
The Court confirmed that the effect of Section 1(c) is that the parties are agreeing that the obligations
contained in "all Transactions ... entered into" are not to be treated as separate and distinct, but rather are made subject to the overarching contractual framework constituted by the Master Agreement. The Court rejected the approach adopted by Flaux J at first instance (whereby all Transactions are not treated in the same way but are treated differently).
See also
Court of Appeal rules on key provisions of the ISDA Master Agreement
Section 2(a)(iii) ISDA Master Agreement: Court of Appeal judgment on four appeals
The ISDA Master Agreement: from here to eternity
Notes
The International Swaps and Derivatives Association (ISDA) appeared as an intervener to argue in favour of a more benign interpretation of the provisions of the Master Agreement, but were largely unsuccessful.
Permission to appeal to the Supreme Court was refused.
Footnotes
Court of Appeal (England and Wales) cases
English derivatives case law
2012 in United Kingdom case law
|
Beaver Dam (officially, Township of Beaver Dam) is a township in Cumberland County, North Carolina, United States. It is situated at an elevation of 115 feet (35 m).
References
Populated places in Cumberland County, North Carolina
|
Jintang Island (金塘岛) is an island in the Zhoushan prefecture-level city in China's eastern Zhejiang province. It has a population of about 41700.
It is one of the closest islands to the continental shore of Zhejiang, being only from the southern Ningbo Beilun port and from the eastern Zhoushan Island. Jintang is Zhoushan's fourth largest island with an area of .
History
The name Jintang Island is literally translated as "Golden Pond Island".
It derived its name from the two ponds built on the western side of the island by the locals to prevent erosion of the western coastline. The soil of the inner pond coastline became fertile and rich in minerals, bringing about bountiful harvests to the locals who dub the island "Golden Pond" (金塘).
Industries
Jintang Island is largely an agricultural community. Its thriving industries include farming, fishing and furniture production.
It is most famous for the production of Jintang Plums (金塘李), a local fruit. The fruit has received a number of awards and accolades, earning a Zhejiang Province High Quality Agricultural Product Exhibition Silver Award in 1998 and subsequently a Gold Award in 1999 when the island was also conferred the namesake of "Jintang Plum Township (金塘李之乡)" by the provincial government.
Jintang Island coastal waters produce a large number of marine products, such as squid, cuttlefish, fish, and more.
Transportation
Transport between Jintang and Zhoushan is made by boat.
In April 2006 work began for the construction of two bridges, the Xihoumen Bridge (西堠门大桥) and Jintang Bridge (金塘大桥) connecting Zhoushan Archipelago with the country's continental area, an improvement long-awaited by Zhoushan people. They are scheduled to be completed in 2008.
The two bridges are the second phase of a huge "continent-island joint project" launched by Zhoushan in 1999 to link the archipelago with the mainland through five bridges. Construction of the other three bridges have been completed.
Xihoumen Bridge
The 5.3-kilometer-long Xihoumen Bridge, linking Jintang and Cezi, two major islands of the archipelago, is a suspension bridge consisting of a 2.6-kilometer sea-crossing bridge and 2.7-kilometer side joint sections on both ends, costing 2.48 billion yuan (US$299.87 million). It allows the passage of ships of 30,000 dead weight tonnage.
Jintang Bridge
The Jintang Bridge, linking Jintang Island and Zhenhai (on Ningbo prefecture), will be long. The 7-billion-yuan project consists of an sea bridge and joint sections totaling .
On 27 March 2008, there has been an accident involving a Taizhou freighter that hit the bridge construction site. Two pieces of reinforced concrete from the bridge weighing 3000 tons each got stuck in the cockpit of the freighter, which was moving at a fast pace. The accident will result in further delay to the completion of its construction.
There are plans by a Sino-Italian consortium to build an archimedes bridge in the Jintang strait.
Ningbo Ports Group is also planning to build a proposed 12 container berths worth 10 billion yuan (US$1.25billion) in future at Jintang Island in anticipation of fierce competition from Shanghai's Yangshan Deep-Water Port.
References
External links
JinTangDao , Jintang Island discussion forum
Zhoushan
|
```objective-c
/* Make a string describing file modes.
Inc.
This program is free software: you can redistribute it and/or modify
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
along with this program. If not, see <path_to_url */
#ifndef FILEMODE_H_
# include <sys/types.h>
# include <sys/stat.h>
/* Get the declaration of strmode. */
# if HAVE_DECL_STRMODE
# include <string.h> /* Mac OS X, FreeBSD, OpenBSD */
# include <unistd.h> /* NetBSD */
# endif
# ifdef __cplusplus
extern "C" {
# endif
# if !HAVE_DECL_STRMODE
extern void strmode (mode_t mode, char *str);
# endif
extern void filemodestring (struct stat const *statp, char *str);
# ifdef __cplusplus
}
# endif
#endif
```
|
Dinotrema is a genus of wasps in the family Braconidae. Species are amongst the largest parasitoid wasps in the tribe Alysiini (Alysiinae). There are approximately 350 species described around worldwide.
Economic significance
Generally, Dinotrema species are parasitoids of the larvae of Diptera predominantly from families Anthomyiidae, Phoridae and Platypezidae, groups considered as pests.
Distribution
Dinotrema comprises a large number of species described from Afrotropical, Australasian, Nearctic, Neotropical, Oceanic, Oriental and Palaearctic (mainly from Western Europe) regions.
Identification
This genus has tridentate and small mandibles, with paraclypeal fovea short, not reaching ventral edge of eyes. Vein cuqu1 (2-SR) present and sclerotized and nervulus (cu-a) postfurcal. It is differentiated from the genus Aspilota by the short size of the paraclypeal fovea far separated from the inner margin of the eye. Moreover, this genus can be differentiated from the genus Synaldis Foerster, 1862 by the presence of the vein cuqu1 (2-SR) and Adelphenaldis Fischer, 2003 by the short size of the paraclypeal fovea and the presence of the vein cuqu1 (2-SR).
References
Braconidae genera
|
```objective-c
#ifndef TACO_ITERATION_GRAPH_H
#define TACO_ITERATION_GRAPH_H
#include <memory>
#include <vector>
namespace taco {
class TensorVar;
class IndexVar;
class IndexExpr;
class Assignment;
class TensorPath;
enum class IndexVarType {
Free,
Sum
};
/// An iteration graph constist of index variables arranged in a forest
/// together with tensor paths super-imposed on the forest.
/// - The iteration graph is arranged in a forest decomposition where all
/// tensor paths move from index variables higher in the tree to index
/// variables strictly lower in the tree.
/// - The tensor paths describe how to iterate over the index variables through
/// the indices of the corresponding (sparse or dense) tensors.
class IterationGraph {
public:
IterationGraph();
/// Creates an iteration graph for a tensor with a defined expression.
static IterationGraph make(Assignment);
/// Returns the iteration graph roots; the index variables with no parents.
const std::vector<IndexVar>& getRoots() const;
/// Returns the children of the index variable
const std::vector<IndexVar>& getChildren(const IndexVar&) const;
/// Returns the parent of the index variable
const IndexVar& getParent(const IndexVar&) const;
/// Returns the ancestors of the index variable including itself.
std::vector<IndexVar> getAncestors(const IndexVar&) const;
/// Returns all descendant of the index variable, including itself.
std::vector<IndexVar> getDescendants(const IndexVar&) const;
/// Returns the tensor paths of the operand tensors in the iteration graph.
const std::vector<TensorPath>& getTensorPaths() const;
/// Returns the tensor path corresponding to a tensor read expression.
const TensorPath& getTensorPath(const IndexExpr&) const;
/// Returns the tensor path of the result tensor.
const TensorPath& getResultTensorPath() const;
/// Returns the index variable type.
IndexVarType getIndexVarType(const IndexVar&) const;
/// Returns true iff the index variable is free.
bool isFree(const IndexVar&) const;
/// Returns true iff the index variable is a reduction.
bool isReduction(const IndexVar&) const;
/// Returns true if the index variable is the only free var in its subtree.
bool isLastFreeVariable(const IndexVar&) const;
/// Returns true if the index variable is the ancestor of any free variable.
bool hasFreeVariableDescendant(const IndexVar&) const;
/// Returns true if the index variable has a reduction variable ancestor.
bool hasReductionVariableAncestor(const IndexVar&) const;
/// Returns the index expression at the given index variable.
const IndexExpr& getIndexExpr(const IndexVar&) const;
/// Print an iteration graph as a dot file.
void printAsDot(std::ostream&);
/// Print an iteration graph.
friend std::ostream& operator<<(std::ostream&, const IterationGraph&);
private:
struct Content;
std::shared_ptr<Content> content;
};
}
#endif
```
|
Alexander Louis London (August 31, 1913 – March 19, 2008) was an American mechanical engineer and professor of mechanical engineering at Stanford University.
London was elected to the National Academy of Engineering "for contributions to the theory and applications of compact heat exchangers, especially in the gas turbine field".
The National Academy of Engineering called London "one of the world's best known experts in heat transfer equipment design, performance and analysis."
The Stanford University called him "engineering expert on heat transfer".
London received the R. Tom Sawyer Award by the Gas Turbine Division of the American Society of Mechanical Engineers, The James Harry Potter Gold Metal, and the Max Jakob Memorial Award.
References
American mechanical engineers
Stanford University School of Engineering faculty
1913 births
2008 deaths
Members of the United States National Academy of Engineering
20th-century American engineers
|
The superformula is a generalization of the superellipse and was proposed by Johan Gielis around 2000. Gielis suggested that the formula can be used to describe many complex shapes and curves that are found in nature. Gielis has filed a patent application related to the synthesis of patterns generated by the superformula, which expired effective 2020-05-10.
In polar coordinates, with the radius and the angle, the superformula is:
By choosing different values for the parameters and different shapes can be generated.
The formula was obtained by generalizing the superellipse, named and popularized by Piet Hein, a Danish mathematician.
2D plots
In the following examples the values shown above each figure should be m, n1, n2 and n3.
A GNU Octave program for generating these figures
function sf2d(n, a)
u = [0:.001:2 * pi];
raux = abs(1 / a(1) .* abs(cos(n(1) * u / 4))) .^ n(3) + abs(1 / a(2) .* abs(sin(n(1) * u / 4))) .^ n(4);
r = abs(raux) .^ (- 1 / n(2));
x = r .* cos(u);
y = r .* sin(u);
plot(x, y);
end
Extension to higher dimensions
It is possible to extend the formula to 3, 4, or n dimensions, by means of the spherical product of superformulas. For example, the 3D parametric surface is obtained by multiplying two superformulas r1 and r2. The coordinates are defined by the relations:
where (latitude) varies between −π/2 and π/2 and θ (longitude) between −π and π.
3D plots
3D superformula: a = b = 1; m, n1, n2 and n3 are shown in the pictures.
A GNU Octave program for generating these figures:
function sf3d(n, a)
u = [- pi:.05:pi];
v = [- pi / 2:.05:pi / 2];
nu = length(u);
nv = length(v);
for i = 1:nu
for j = 1:nv
raux1 = abs(1 / a(1) * abs(cos(n(1) .* u(i) / 4))) .^ n(3) + abs(1 / a(2) * abs(sin(n(1) * u(i) / 4))) .^ n(4);
r1 = abs(raux1) .^ (- 1 / n(2));
raux2 = abs(1 / a(1) * abs(cos(n(1) * v(j) / 4))) .^ n(3) + abs(1 / a(2) * abs(sin(n(1) * v(j) / 4))) .^ n(4);
r2 = abs(raux2) .^ (- 1 / n(2));
x(i, j) = r1 * cos(u(i)) * r2 * cos(v(j));
y(i, j) = r1 * sin(u(i)) * r2 * cos(v(j));
z(i, j) = r2 * sin(v(j));
endfor;
endfor;
mesh(x, y, z);
endfunction;
Generalization
The superformula can be generalized by allowing distinct m parameters in the two terms of the superformula. By replacing the first parameter with y and second parameter with z:
This allows the creation of rotationally asymmetric and nested structures. In the following examples a, b, and are 1:
References
External links
Some Experiments on Fitting of Gielis Curves by Simulated Annealing and Particle Swarm Methods of Global Optimization
Least Squares Fitting of Chacón-Gielis Curves By the Particle Swarm Method of Optimization
Superformula 2D Plotter & SVG Generator
Interactive example using JSXGraph
SuperShaper: An OpenSource, OpenCL accelerated, interactive 3D SuperShape generator with shader based visualisation (OpenGL3)
Simpel, WebGL based SuperShape implementation
Geometric shapes
Curves
Surfaces
|
Ray Kirchmeyer was an American football and basketball player and coach. He played college football at Columbia University from 1923 to 1925 and was later the head football and basketball coach at Wagner College on Staten Island.
Early years
Kirchmeyer attended Technical High School in Buffalo, New York, where he played football and basketball.
Kirchmeyer played college football as a fullback for Columbia from 1923 to 1925. In a game rated as one of the greatest upsets in Columbia's football history, Kirchmeyer ran 60 yards for a touchdown against Army in 1925. He also starred for the Columbia basketball team that won the Eastern Intercollegiate Basketball League championship of 1925–26.
He also reportedly played professional football for Dan Blaine's Staten Island Stapletons in the National Football League.
Coaching career
In September 1928, Kirchmeyer was hired as the head football coach at Wagner College on Staten Island.
He served as the head football coach at Wagner College in Staten Island, New York from 1928 to 1932 and 1937 to 1946. Wagner did not field a team from 1942 to 1945 due to World War II. In 11 seasons as head football coach at Wagner, he compiled a 29–39–4 record.
Kirchmeyer also practice law on Staten Island.
Head coaching record
Football
References
Year of birth missing
Year of death missing
American football fullbacks
Centers (basketball)
Columbia Lions football players
Columbia Lions men's basketball players
Staten Island Stapletons players
Wagner Seahawks football coaches
Wagner Seahawks men's basketball coaches
Players of American football from Buffalo, New York
Basketball players from Buffalo, New York
Lawyers from New York City
Coaches of American football from New York (state)
Basketball coaches from New York (state)
|
The Stunt Man is a 1980 American action comedy film starring Peter O'Toole, Steve Railsback and Barbara Hershey, and directed by Richard Rush. The film was adapted by Lawrence B. Marcus and Rush from the 1970 novel of the same name by Paul Brodeur. It tells the story of a young fugitive who hides as a stunt double on the set of a World War I movie whose charismatic director will do seemingly anything for the sake of his art. The line between illusion and reality is blurred as scenes from the inner movie cut seamlessly to "real life" and vice versa. There are examples of "movie magic", where a scene of wartime carnage is revealed as just stunt men and props, and where a shot of a crying woman becomes, with scenery, props and sound track, a portrait of a grieving widow at a Nazi rally. The protagonist begins to doubt everything he sees and hears, and at the end is faced with real danger when a stunt seems to go wrong.
It was nominated for three Academy Awards: Best Actor in a Leading Role (Peter O'Toole), Best Director (Richard Rush), and Best Writing, Screenplay Based on Material from Another Medium. However, due to its limited release, it never earned much attention from audiences at large. As O'Toole remarked in a DVD audio commentary, "The film wasn't released. It escaped." The film has since developed a cult following.
Plot
Cameron, a Vietnam veteran who is wanted for attempted murder, is caught by police but escapes. Crossing a bridge, he dodges a car that seems to be trying to run him down; when he turns around, the car has disappeared. A helicopter flies close to the bridge and a man inside looks at Cameron. Later, Cameron is attracted to a movie shoot — a World War I battle scene. Afterwards, he notices an older woman who walks through the set greeting the actors, then falls in the water. Cameron dives in to rescue her and is horrified when she pulls off her face — a mask. She is the movie's leading actress, Nina Franklin, testing make-up for scenes set late in her character's life.
The director, Eli Cross, the man in the helicopter, descends from the sky on his camera crane. He offers Cameron a job, explaining that their last stunt man just ran a car off a bridge. They haven't found the body, and Eli can't afford the production delays if police get involved. The police chief is aware of the accident but Eli convinces him that Cameron is the stuntman. Cameron accepts the job. Eli shows the police film footage that seems to show that Cameron was never on the bridge.
Denise, the film's hair stylist, dyes Cameron's hair in order to make him resemble the leading man, Raymond Bailey, and harder to recognize. Cameron is convinced Eli is selling him out to the police but Eli reassures him that he is not. Cameron learns from Chuck, the stunt coordinator, and films a scene where he is chased across the roof of a large building and falls through a skylight into a bordello. At the same time, Cameron gets involved with Nina, who once had a romance with Eli, who becomes jealous of Cameron.
The last shoot at the current location involves Cameron's most difficult stunt, driving off a bridge and escaping under water — the same scene Burt was shooting when he died. Cameron believes Eli is trying to kill him, and will use the stunt to make it look like an accident.
The morning before the shoot Cameron tells Nina he planned to open an ice cream shop when he got home from Vietnam with a friend, but his friend did not want Cameron around because Cameron's girlfriend had left Cameron for the friend. Enraged, Cameron destroyed the ice cream shop. When a cop showed up, Cameron knocked him out, leaving his head freezing in a bucket of ice cream, resulting in an attempted murder charge. Nina and Cameron plan to escape together: Nina will hide in the trunk of the car, which Cameron will drive away in the morning instead of driving off the bridge.
Chuck has planted an explosive in one of the tires to make the car's tumble look more realistic. Cameron starts the scene too early. The car goes into the water when Chuck triggers the exploding tire, and Cameron scrambles to reach Nina in the trunk, until he looks out the window and sees Nina with Eli on the bridge. The air bottle Cameron is supposed to use to breathe seems to have been sabotaged, but he is able to get out of the car anyway. Cameron emerges and notices there were divers in the water with him all the time. Nina tells him that she was found in the trunk hours before the shoot, and Eli told her Cameron had decided to do the stunt. Eli explains that he would not let Cameron run off thinking he was trying to kill him. The best way to convince Cameron of Eli's good will, Eli felt, was to make sure Cameron got through the stunt in one piece. Cameron, though furious, is amused and relieved to survive. Cameron and Eli bicker over Cameron's pay and plan to catch a plane to the production's next location.
Cast
Production
During the early 1970s, Columbia Pictures owned film rights to the novel, with Arthur Penn and François Truffaut considered for directing it. Columbia offered the film to Richard Rush on the strength of the success of his previous film, Getting Straight. Rush initially rejected, then ultimately accepted directing The Stunt Man.
In July 1971, Columbia announced that Rush would direct the film with William Castle executive producer.
Rush then penned a 150-page treatment different from the book; in the novel, the characters were all crazy, and in the screenplay, they were instead "sane in a world gone mad." Columbia executives then rejected the script, saying it was difficult to find a genre to place it in. Said Rush: "They couldn't figure out if it was a comedy, a drama, if it was a social satire, if it was an action adventure...and, of course, the answer was, 'Yes, it's all those things.' But that isn't a satisfactory answer to a studio executive." Rush then bought the film rights from Columbia and shopped the film to other studios, to no avail. Funding for the picture finally came from Melvin Simon, who had made a fortune in real estate.
Production took place in 1978. Many scenes were filmed in and around the historic Hotel del Coronado in Coronado, California.
Peter O'Toole mentions in his DVD commentary that he based his character on David Lean who directed him in Lawrence of Arabia.
Reception
Reviewing it upon its release, Roger Ebert wrote "there was a great deal in it that I admired... [but] there were times when I felt cheated". He gave the film two stars but noted that others had "highly recommended" it. In an October 17, 1980, review in The New York Times, Janet Maslin noted "the film's cleverness is aggressive and cool," but concluded that although "the gamesmanship of The Stunt Man is fast and furious... gamesmanship is almost all it manages to be". Jay Scott called it "[t]he best movie about making a movie ever made, but the achievement merely begins there. ... Imagine a picture an eight-year-old and Wittgenstein could enjoy with equal fervor." Pauline Kael considered it "a virtuoso piece of kinetic moviemaking" and rated it one of year's best films; she called O'Toole's comic performance "peerless".
, the comedy drama film held a 90% "Fresh" rating on Rotten Tomatoes based on 40 reviews. The critics consensus states, "The Stunt Man is a preposterously entertaining thriller with a clever narrative and Oscar-worthy (nomination, at least!) Peter O'Toole performance."
Awards
Montreal World Film Festival – Grand Prix des Amériques (Best Film) for Richard Rush
Golden Globe awards – Best Original Score for Dominic Frontiere
National Society of Film Critics Awards – Best Actor for Peter O'Toole
Nominations
The Stunt Man received three Oscar nominations:
Best Director – Richard Rush
Best Actor – Peter O'Toole
Best Adapted Screenplay – Lawrence B. Marcus, Richard Rush
Home media
The Stunt Man was released on DVD on November 20, 2001 in two versions by Anchor Bay Entertainment. The first version is a standard release featuring two deleted scenes and a commentary by director Richard Rush. The second version is a limited edition (100,000 copies) containing everything from the standard release as well as the 2000 documentary The Sinister Saga of Making "The Stunt Man".
The film's theme song "Bits & Pieces" is sung by Dusty Springfield.
See also
List of films featuring fictional films
References
External links
1980 films
1980s action comedy-drama films
1980 black comedy films
1980s comedy thriller films
20th Century Fox films
American action comedy films
American black comedy films
American comedy thriller films
1980s English-language films
Films about filmmaking
Films about stunt performers
Films based on American novels
Films directed by Richard Rush
Films scored by Dominic Frontiere
Films shot in San Diego
1980 comedy films
1980s American films
Films about veterans
Vietnam War films
|
RAF West Kirby was a Royal Air Force basic training camp near West Kirby, Cheshire, later Merseyside, England.
Location
The camp at Larton, then in Cheshire, was actually located from West Kirby village, from which it took its name. The camp entrance was on Saughall Massie Road, almost opposite Oldfield Lane.
History
It was set up at the beginning of the Second World War, as a basic training camp, to train new recruits for the Royal Air Force. Known as a "square bashing camp" in the vernacular, it was the very first base (after kitting out at RAF Cardington) of most personnel there during the 1940s to 1960, although the final passing out parade took place on the 20th of December 1957. Most of the personnel were newly called up in the rank of AC2, the very lowest rank in the RAF, for their 2 years National Service in the British armed forces.
At this RAF Station, the men were given their initial training on their first entry into the RAF which included first learning the RAF parade ground drill. With rifles, intensive physical fitness training in ground combat and defense under non-commissioned officers of the RAF Regiment, and some education about the RAF and its history. Men, while undergoing their basic training at West Kirby, were accommodated in wooden barrack huts, each one housing about twenty men. Because West Kirby was a basic training camp, with no airfield there, discipline was very much stricter than in any normal RAF operational or trade training camp.
Recruits normally spent a period of eight weeks, (later on 6 weeks) on their training at West Kirby before being posted on to their "trade training" camp elsewhere in the United Kingdom. Approximately 150,000 conscripts went through its gates up until 1960, when the camp was demolished and the land converted back into farming fields. A dedication plaque was installed, where the camp entrance used to be, in 2004. Later, a commemorative stone was installed.
Gallery
References
History of RAF West Kirby
"The best years of their lives" 1945-1963 published by ITV for LWT
Further reading
External links
RAF West Kirby Association
West Kirby
Metropolitan Borough of Wirral
|
```c++
/**
* Before running this C++ code example, set up your development environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* path_to_url
*
* For information on the structure of the code examples and how to build and run the examples, see
* path_to_url
*
**/
#include <aws/core/Aws.h>
#include <aws/iot/IoTClient.h>
#include <aws/iot/model/DescribeThingRequest.h>
#include <iostream>
#include "iot_samples.h"
// snippet-start:[cpp.example_code.iot.DescribeThing]
//! Describe an AWS IoT thing.
/*!
\param thingName: The name for the thing.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::IoT::describeThing(const Aws::String &thingName,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::IoT::IoTClient iotClient(clientConfiguration);
Aws::IoT::Model::DescribeThingRequest request;
request.SetThingName(thingName);
Aws::IoT::Model::DescribeThingOutcome outcome = iotClient.DescribeThing(request);
if (outcome.IsSuccess()) {
const Aws::IoT::Model::DescribeThingResult &result = outcome.GetResult();
std::cout << "Retrieved thing '" << result.GetThingName() << "'" << std::endl;
std::cout << "thingArn: " << result.GetThingArn() << std::endl;
std::cout << result.GetAttributes().size() << " attribute(s) retrieved"
<< std::endl;
for (const auto &attribute: result.GetAttributes()) {
std::cout << " attribute: " << attribute.first << "=" << attribute.second
<< std::endl;
}
}
else {
std::cerr << "Error describing thing " << thingName << ": " <<
outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
// snippet-end:[cpp.example_code.iot.DescribeThing]
/*
*
* main function
*
* Usage: 'run_describe_thing <thing_name>'
*
*/
#ifndef EXCLUDE_ACTION_MAIN
int main(int argc, char **argv) {
if (argc != 2) {
std::cout << "Usage: 'run_describe_thing <thing_name>'" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
const Aws::String thingName(argv[1]);
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
AwsDoc::IoT::describeThing(thingName, clientConfig);
}
Aws::ShutdownAPI(options);
return 0;
}
#endif // EXCLUDE_ACTION_MAIN
```
|
Autochloris xanthogastroides is a moth of the subfamily Arctiinae. It was described by Schaus in 1901. It is found in Brazil.
References
Arctiinae
Moths described in 1901
Moths of South America
|
Scott Glenndale Martin King (born June 25, 1967) is a Canadian former professional ice hockey goaltender. He played in two National Hockey League games for the Detroit Red Wings during the 1990–91 and 1991–92 seasons. The rest of his career, which lasted from 1990 to 1993, was spent in the minor leagues. He was drafted 10th (190th overall) in the 1986 NHL Entry Draft.
Early life
King was born in Thunder Bay, Ontario. He headed west from his hometown to join the Richmond Sockeyes of the British Columbia Junior Hockey League during his teenage years.
Career
Minor league hockey
A fast reflex goalie with a right-handed catch, King quickly earned the starting job for the Sockeyes and played 40 games that year, winning 23 and with a 5.05 goals against average (GAA). During the 1985–86 season, King played for the Vernon Lakers and posting an even better 17–9–0 record in 29 games with a 4.64 GAA. The Detroit Red Wings decided to draft King 190th overall in the 1986 NHL Entry Draft.
King attended University of Maine after beginning the 1986–87 season with the Abbotsford Falcons. He had four successful years with the Maine Black Bears men's ice hockey team, being named to all-star teams, his last three years there and winning the Hockey East championship game in 1989 against the Boston College Eagles.
NHL
For the 1990–91 season, King had graduated from the University Maine and joined the Detroit Red Wings organization. He started play for the Hampton Roads Admirals of the East Coast Hockey League playing 15 games. His 8–4–1 record allowed him to be quickly called up to the Adirondack Red Wings of the American Hockey League. In 24 games King posted an 8–10–2 record, but showed promise and poise in the crease. When injury struck Red Wings goalie Tim Cheveldae, a slew of promising minors were called up to try and fill the void for the big club. King was called up on January 28, 1991 to back up goaltender Glen Hanlon in a game against the New Jersey Devils. New Jersey scored four goals against Hanlon in the first 15 minutes and he was pulled, putting King into his first NHL game. King gave up two goals on 11 shots but ended up with no record as the Wings lost 2–6. King finished out the year with Adirondack.
During the 1991–92 season, King moved between Adirondack, the ECHL affiliate Toledo Storm, and the main club. King again was put into an NHL game on November 30, 1991,, as he played the last 16 minutes of a game, replacing Cheveldae in a 3–7 loss against the St. Louis Blues. King played 33 games in Adirondack, finishing with a 14–14–3 record and a 3.53 GAA. Young goalie Chris Osgood was picked up by Detroit for the 1992–93 season and was instantly given the start in most of the games. King was relegated to Toledo where he had a productive year. Having a solid goalie veteran on the team, Toledo excelled and King finished with 26–11–7 record and a playoff berth. King ended the playoffs with a 10–3 record and a Riley Cup victory in six games over the Wheeling Thunderbirds.
Career statistics
Regular season and playoffs
Awards and honors
Named to BCJHL Coastal Division First All-Star Team: 1985
Named to ECHL Second All-Star Team: 1993
Riley Cup Champion: (Toledo Storm – 1993)
References
External links
1967 births
Living people
Adirondack Red Wings players
Canadian ice hockey goaltenders
Detroit Red Wings draft picks
Detroit Red Wings players
Hampton Roads Admirals players
Richmond Sockeyes players
Maine Black Bears men's ice hockey players
Ice hockey people from Thunder Bay
Toledo Storm players
Vernon Lakers players
|
Agounit (also transliterated Aghouinite, Aghounit, Aghoueinit, Agueinit, Agwenit, Agwanit, Agüenit, Aguanit; Arabic: أغوانيت) is a small town or village in the Río de Oro area of the disputed territory of Western Sahara. It is situated in the Polisario Front-held Free Zone of Western Sahara, under the jurisdiction of the Sahrawi Arab Democratic Republic, and near the Mauritanian border, 72 km. south-west from Fderik. It is claimed by Morocco as a rural commune in the Aousserd Province in the region of Dakhla-Oued Ed-Dahab. At the time of the 2004 census, the commune had a total population of 222 people living in 43 households. It has a hospital, a school and a mosque. It is the head of the 7th military region of the Sahrawi Arab Democratic Republic.
It is also the name of a daïra of the wilaya of Auserd, in the Sahrawi refugee camps.
Infrastructure
On June 7, 2006, and during the celebrations of the 30th anniversary of the "Day of the Martyr" (commemorating the death in combat of El-Ouali Mustapha Sayed, first president of the SADR), Mohamed Abdelaziz (president of the SADR) inaugurated a hospital (built up with help from the Basque country government), a desalination centre (built with the help of Andalusia government), a school and the Mayoralty of Agwenit.
Politics
In May 2000, the Polisario Front celebrated the 27th anniversary of the beginning of their armed struggle with a military parade in Agounit.
In June 2006 (during the celebrations of the 30th anniversary of the "Day of the Martyr") the town was the host of the annual conference of the Sahrawi communities abroad (Sahrawi diaspora).
International relations
Twin towns and sister cities
Agounit is twinned with:
Amurrio, Álava, Basque Country, Spain
Busturia, Biscay, Basque Country, Spain
Campiglia Marittima, Livorno, Tuscany, Italy
Gatika, Biscay, Basque Country, Spain
Lapuebla de Labarca, Álava, Basque Country, Spain
Mallabia, Biscay, Basque Country, Spain
Motril, Granada, Andalucía, Spain
Poggio a Caiano, Prato, Tuscany, Italy
Ponsacco, Pisa, Tuscany, Italy
Portoferraio, Livorno, Tuscany, Italy (since November 8, 2004)
Puçol, Valencia, Comunidad Valenciana, Spain (since September 1, 2002)
Quarrata, Pistoia, Tuscany, Italy
Rignano sull'Arno, Florence, Tuscany, Italy
Tres Cantos, Madrid, Spain (since 1995)
References
External links
1970's black and white photos of the Spanish hospital in Agüenit
Sahrawi Arab Democratic Republic
Populated places in Western Sahara
Populated places in Aousserd Province
|
```python
from routersploit.core.exploit import *
from routersploit.modules.creds.generic.ftp_default import Exploit as FTPDefault
class Exploit(FTPDefault):
__info__ = {
"name": "Grandstream Camera Default FTP Creds",
"description": "Module performs dictionary attack against Grandstream Camera FTP service. "
"If valid credentials are found, they are displayed to the user.",
"authors": (
"Marcin Bury <marcin[at]threat9.com>", # routersploit module
),
"devices": (
"Grandstream Camera",
)
}
target = OptIP("", "Target IPv4, IPv6 address or file with ip:port (file://)")
port = OptPort(21, "Target FTP port")
threads = OptInteger(1, "Number of threads")
defaults = OptWordlist("admin:admin", "User:Pass or file with default credentials (file://)")
```
|
```xml
import * as React from 'react';
import ComponentExample from '../../../../components/ComponentDoc/ComponentExample';
import ExampleSection from '../../../../components/ComponentDoc/ExampleSection';
const Content = () => (
<ExampleSection title="Content">
<ComponentExample
title="Actions"
description="A chat message can contain actions."
examplePath="components/Chat/Content/ChatExampleActions"
/>
<ComponentExample
title="Reaction group"
description="A chat message can contain group of reactions."
examplePath="components/Chat/Content/ChatExampleReactionGroup"
/>
<ComponentExample
title="Header"
description="A chat message can have a custom header."
examplePath="components/Chat/Content/ChatExampleHeader"
/>
<ComponentExample
title="Override Header Styles"
description="A chat message header can have styles override to fit one line."
examplePath="components/Chat/Content/ChatExampleHeaderOverride"
/>
<ComponentExample
title="Read Status"
description="A chat message can have a read status indicator"
examplePath="components/Chat/Content/ChatExampleReadStatus"
/>
</ExampleSection>
);
export default Content;
```
|
Steven Greene (born 25 January 1982) is a former Australian rules footballer who played with Hawthorn in the Australian Football League (AFL).
As the son of former leading AFL player Russell Greene, Greene was eligible for both Hawthorn and St Kilda under the Father-Son Rule. He opted for the former and Hawthorn secured him with the 28th selection of the 2000 AFL Draft, from TAC Cup side Sandringham Dragons.
Greene, a hard running player, got a regular game late in the 2001 season and received a Rising Star nomination in the final round. He took part in Hawthorn's finals series and had 17 disposals plus two goals in their win over Sydney in the elimination final. Greene finished the season averaging 16 disposals a game.
Unable to hold down a spot in the team over the next few seasons, Greene spent much of his time playing for Victorian Football League (VFL) side Box Hill, winning their "Best and Fairest" in 2005. Greene was delisted by Hawthorn and in 2006 signed with Williamstown. He won the Williamstown "Best and Fairest" award in his first season.
Greene is currently a part owner of Melbourne-based apparel company Jaggad.
References
https://www.mamamia.com.au/jaggad-sued-for-sexual-discrimination/
https://www.equalopportunitytraining.com.au/whats-been-happening-in-australia-in-relation-to-sexual-harassment-discrimination-and-bullying-from-7-13-august-2017/
http://www.ladieswantmore.com/they-think-theyre-untouchable-bec-and-chris-judds-luxury-sportswear-label-sued-for-sexual-harassment-amid/
http://expressdigest.com/chris-judds-brand-settles-sexual-discrimination-claim/
1982 births
Hawthorn Football Club players
Box Hill Football Club players
Williamstown Football Club players
Living people
Australian rules footballers from Victoria (state)
Sandringham Dragons players
People educated at Melbourne Grammar School
|
State Route 213 (SR 213), also known as Grays Camp Road and Phillippy Road, is a short 3.6 miles long east–west state highway in northeastern Lake County, Tennessee. It provides access to many homes, marinas, businesses, and camps along the shores of Reelfoot Lake, as well as the Reelfoot Lake Airport.
Route description
SR 213 begins as Grays Camp Road just south of the community of Phillippy at an intersection with SR 78. It goes southeast through farmland for a couple of miles before arriving at some lakeside camps, such as Gray’s Camp, where it turns northeast along Phillippy Road. For the next mile or so, SR 213 travels along the banks of Reelfoot Lake, passing by many lakeside homes, camps, businesses, and marinas, before turning more northward away from the lake and coming to an end at the main entrance of Reelfoot Lake Airport. The Phillippy Road portion of the highway stays no more than a half-mile west of the Obion County line at all times. The entire route of SR 213 is a two-lane highway.
Major intersections
References
213
Transportation in Lake County, Tennessee
|
The annual election to the Labour Party's Shadow Cabinet (more formally, its "Parliamentary Committee") was conducted in 1987. In addition to the 16 members elected, the Leader (Neil Kinnock), Deputy Leader (Roy Hattersley), Labour Chief Whip (Derek Foster), Labour Leader in the House of Lords (Cledwyn Hughes), and Chairman of the Parliamentary Labour Party (Stan Orme) were automatically members.
Following the 1987 general election, there were significant changes to the cabinet. Barry Jones, Peter Shore, Peter Archer and Giles Radice lost their seats, and other familiar faces such as Denis Healey did not stand. Michael Meacher, Robert Hughes, Robin Cook, Frank Dobson, Gordon Brown, Jo Richardson and Jack Straw gained seats.
Footnotes
Notes
References
1987
1987 elections in the United Kingdom
|
```objective-c
//===- llvm/ADT/SparseBitVector.h - Efficient Sparse BitVector --*- C++ -*-===//
//
// See path_to_url for license information.
//
//===your_sha256_hash------===//
///
/// \file
/// This file defines the SparseBitVector class. See the doxygen comment for
/// SparseBitVector for more details on the algorithm used.
///
//===your_sha256_hash------===//
#ifndef LLVM_ADT_SPARSEBITVECTOR_H
#define LLVM_ADT_SPARSEBITVECTOR_H
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <climits>
#include <cstring>
#include <iterator>
#include <list>
namespace llvm {
/// SparseBitVector is an implementation of a bitvector that is sparse by only
/// storing the elements that have non-zero bits set. In order to make this
/// fast for the most common cases, SparseBitVector is implemented as a linked
/// list of SparseBitVectorElements. We maintain a pointer to the last
/// SparseBitVectorElement accessed (in the form of a list iterator), in order
/// to make multiple in-order test/set constant time after the first one is
/// executed. Note that using vectors to store SparseBitVectorElement's does
/// not work out very well because it causes insertion in the middle to take
/// enormous amounts of time with a large amount of bits. Other structures that
/// have better worst cases for insertion in the middle (various balanced trees,
/// etc) do not perform as well in practice as a linked list with this iterator
/// kept up to date. They are also significantly more memory intensive.
template <unsigned ElementSize = 128> struct SparseBitVectorElement {
public:
using BitWord = unsigned long;
using size_type = unsigned;
enum {
BITWORD_SIZE = sizeof(BitWord) * CHAR_BIT,
BITWORDS_PER_ELEMENT = (ElementSize + BITWORD_SIZE - 1) / BITWORD_SIZE,
BITS_PER_ELEMENT = ElementSize
};
private:
// Index of Element in terms of where first bit starts.
unsigned ElementIndex;
BitWord Bits[BITWORDS_PER_ELEMENT];
SparseBitVectorElement() {
ElementIndex = ~0U;
memset(&Bits[0], 0, sizeof (BitWord) * BITWORDS_PER_ELEMENT);
}
public:
explicit SparseBitVectorElement(unsigned Idx) {
ElementIndex = Idx;
memset(&Bits[0], 0, sizeof (BitWord) * BITWORDS_PER_ELEMENT);
}
// Comparison.
bool operator==(const SparseBitVectorElement &RHS) const {
if (ElementIndex != RHS.ElementIndex)
return false;
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
if (Bits[i] != RHS.Bits[i])
return false;
return true;
}
bool operator!=(const SparseBitVectorElement &RHS) const {
return !(*this == RHS);
}
// Return the bits that make up word Idx in our element.
BitWord word(unsigned Idx) const {
assert(Idx < BITWORDS_PER_ELEMENT);
return Bits[Idx];
}
unsigned index() const {
return ElementIndex;
}
bool empty() const {
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
if (Bits[i])
return false;
return true;
}
void set(unsigned Idx) {
Bits[Idx / BITWORD_SIZE] |= 1L << (Idx % BITWORD_SIZE);
}
bool test_and_set(unsigned Idx) {
bool old = test(Idx);
if (!old) {
set(Idx);
return true;
}
return false;
}
void reset(unsigned Idx) {
Bits[Idx / BITWORD_SIZE] &= ~(1L << (Idx % BITWORD_SIZE));
}
bool test(unsigned Idx) const {
return Bits[Idx / BITWORD_SIZE] & (1L << (Idx % BITWORD_SIZE));
}
size_type count() const {
unsigned NumBits = 0;
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
NumBits += llvm::popcount(Bits[i]);
return NumBits;
}
/// find_first - Returns the index of the first set bit.
int find_first() const {
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i)
if (Bits[i] != 0)
return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
llvm_unreachable("Illegal empty element");
}
/// find_last - Returns the index of the last set bit.
int find_last() const {
for (unsigned I = 0; I < BITWORDS_PER_ELEMENT; ++I) {
unsigned Idx = BITWORDS_PER_ELEMENT - I - 1;
if (Bits[Idx] != 0)
return Idx * BITWORD_SIZE + BITWORD_SIZE -
countLeadingZeros(Bits[Idx]) - 1;
}
llvm_unreachable("Illegal empty element");
}
/// find_next - Returns the index of the next set bit starting from the
/// "Curr" bit. Returns -1 if the next set bit is not found.
int find_next(unsigned Curr) const {
if (Curr >= BITS_PER_ELEMENT)
return -1;
unsigned WordPos = Curr / BITWORD_SIZE;
unsigned BitPos = Curr % BITWORD_SIZE;
BitWord Copy = Bits[WordPos];
assert(WordPos <= BITWORDS_PER_ELEMENT
&& "Word Position outside of element");
// Mask off previous bits.
Copy &= ~0UL << BitPos;
if (Copy != 0)
return WordPos * BITWORD_SIZE + countTrailingZeros(Copy);
// Check subsequent words.
for (unsigned i = WordPos+1; i < BITWORDS_PER_ELEMENT; ++i)
if (Bits[i] != 0)
return i * BITWORD_SIZE + countTrailingZeros(Bits[i]);
return -1;
}
// Union this element with RHS and return true if this one changed.
bool unionWith(const SparseBitVectorElement &RHS) {
bool changed = false;
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
BitWord old = changed ? 0 : Bits[i];
Bits[i] |= RHS.Bits[i];
if (!changed && old != Bits[i])
changed = true;
}
return changed;
}
// Return true if we have any bits in common with RHS
bool intersects(const SparseBitVectorElement &RHS) const {
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
if (RHS.Bits[i] & Bits[i])
return true;
}
return false;
}
// Intersect this Element with RHS and return true if this one changed.
// BecameZero is set to true if this element became all-zero bits.
bool intersectWith(const SparseBitVectorElement &RHS,
bool &BecameZero) {
bool changed = false;
bool allzero = true;
BecameZero = false;
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
BitWord old = changed ? 0 : Bits[i];
Bits[i] &= RHS.Bits[i];
if (Bits[i] != 0)
allzero = false;
if (!changed && old != Bits[i])
changed = true;
}
BecameZero = allzero;
return changed;
}
// Intersect this Element with the complement of RHS and return true if this
// one changed. BecameZero is set to true if this element became all-zero
// bits.
bool intersectWithComplement(const SparseBitVectorElement &RHS,
bool &BecameZero) {
bool changed = false;
bool allzero = true;
BecameZero = false;
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
BitWord old = changed ? 0 : Bits[i];
Bits[i] &= ~RHS.Bits[i];
if (Bits[i] != 0)
allzero = false;
if (!changed && old != Bits[i])
changed = true;
}
BecameZero = allzero;
return changed;
}
// Three argument version of intersectWithComplement that intersects
// RHS1 & ~RHS2 into this element
void intersectWithComplement(const SparseBitVectorElement &RHS1,
const SparseBitVectorElement &RHS2,
bool &BecameZero) {
bool allzero = true;
BecameZero = false;
for (unsigned i = 0; i < BITWORDS_PER_ELEMENT; ++i) {
Bits[i] = RHS1.Bits[i] & ~RHS2.Bits[i];
if (Bits[i] != 0)
allzero = false;
}
BecameZero = allzero;
}
};
template <unsigned ElementSize = 128>
class SparseBitVector {
using ElementList = std::list<SparseBitVectorElement<ElementSize>>;
using ElementListIter = typename ElementList::iterator;
using ElementListConstIter = typename ElementList::const_iterator;
enum {
BITWORD_SIZE = SparseBitVectorElement<ElementSize>::BITWORD_SIZE
};
ElementList Elements;
// Pointer to our current Element. This has no visible effect on the external
// state of a SparseBitVector, it's just used to improve performance in the
// common case of testing/modifying bits with similar indices.
mutable ElementListIter CurrElementIter;
// This is like std::lower_bound, except we do linear searching from the
// current position.
ElementListIter FindLowerBoundImpl(unsigned ElementIndex) const {
// We cache a non-const iterator so we're forced to resort to const_cast to
// get the begin/end in the case where 'this' is const. To avoid duplication
// of code with the only difference being whether the const cast is present
// 'this' is always const in this particular function and we sort out the
// difference in FindLowerBound and FindLowerBoundConst.
ElementListIter Begin =
const_cast<SparseBitVector<ElementSize> *>(this)->Elements.begin();
ElementListIter End =
const_cast<SparseBitVector<ElementSize> *>(this)->Elements.end();
if (Elements.empty()) {
CurrElementIter = Begin;
return CurrElementIter;
}
// Make sure our current iterator is valid.
if (CurrElementIter == End)
--CurrElementIter;
// Search from our current iterator, either backwards or forwards,
// depending on what element we are looking for.
ElementListIter ElementIter = CurrElementIter;
if (CurrElementIter->index() == ElementIndex) {
return ElementIter;
} else if (CurrElementIter->index() > ElementIndex) {
while (ElementIter != Begin
&& ElementIter->index() > ElementIndex)
--ElementIter;
} else {
while (ElementIter != End &&
ElementIter->index() < ElementIndex)
++ElementIter;
}
CurrElementIter = ElementIter;
return ElementIter;
}
ElementListConstIter FindLowerBoundConst(unsigned ElementIndex) const {
return FindLowerBoundImpl(ElementIndex);
}
ElementListIter FindLowerBound(unsigned ElementIndex) {
return FindLowerBoundImpl(ElementIndex);
}
// Iterator to walk set bits in the bitmap. This iterator is a lot uglier
// than it would be, in order to be efficient.
class SparseBitVectorIterator {
private:
bool AtEnd;
const SparseBitVector<ElementSize> *BitVector = nullptr;
// Current element inside of bitmap.
ElementListConstIter Iter;
// Current bit number inside of our bitmap.
unsigned BitNumber;
// Current word number inside of our element.
unsigned WordNumber;
// Current bits from the element.
typename SparseBitVectorElement<ElementSize>::BitWord Bits;
// Move our iterator to the first non-zero bit in the bitmap.
void AdvanceToFirstNonZero() {
if (AtEnd)
return;
if (BitVector->Elements.empty()) {
AtEnd = true;
return;
}
Iter = BitVector->Elements.begin();
BitNumber = Iter->index() * ElementSize;
unsigned BitPos = Iter->find_first();
BitNumber += BitPos;
WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
Bits = Iter->word(WordNumber);
Bits >>= BitPos % BITWORD_SIZE;
}
// Move our iterator to the next non-zero bit.
void AdvanceToNextNonZero() {
if (AtEnd)
return;
while (Bits && !(Bits & 1)) {
Bits >>= 1;
BitNumber += 1;
}
// See if we ran out of Bits in this word.
if (!Bits) {
int NextSetBitNumber = Iter->find_next(BitNumber % ElementSize) ;
// If we ran out of set bits in this element, move to next element.
if (NextSetBitNumber == -1 || (BitNumber % ElementSize == 0)) {
++Iter;
WordNumber = 0;
// We may run out of elements in the bitmap.
if (Iter == BitVector->Elements.end()) {
AtEnd = true;
return;
}
// Set up for next non-zero word in bitmap.
BitNumber = Iter->index() * ElementSize;
NextSetBitNumber = Iter->find_first();
BitNumber += NextSetBitNumber;
WordNumber = (BitNumber % ElementSize) / BITWORD_SIZE;
Bits = Iter->word(WordNumber);
Bits >>= NextSetBitNumber % BITWORD_SIZE;
} else {
WordNumber = (NextSetBitNumber % ElementSize) / BITWORD_SIZE;
Bits = Iter->word(WordNumber);
Bits >>= NextSetBitNumber % BITWORD_SIZE;
BitNumber = Iter->index() * ElementSize;
BitNumber += NextSetBitNumber;
}
}
}
public:
SparseBitVectorIterator() = default;
SparseBitVectorIterator(const SparseBitVector<ElementSize> *RHS,
bool end = false):BitVector(RHS) {
Iter = BitVector->Elements.begin();
BitNumber = 0;
Bits = 0;
WordNumber = ~0;
AtEnd = end;
AdvanceToFirstNonZero();
}
// Preincrement.
inline SparseBitVectorIterator& operator++() {
++BitNumber;
Bits >>= 1;
AdvanceToNextNonZero();
return *this;
}
// Postincrement.
inline SparseBitVectorIterator operator++(int) {
SparseBitVectorIterator tmp = *this;
++*this;
return tmp;
}
// Return the current set bit number.
unsigned operator*() const {
return BitNumber;
}
bool operator==(const SparseBitVectorIterator &RHS) const {
// If they are both at the end, ignore the rest of the fields.
if (AtEnd && RHS.AtEnd)
return true;
// Otherwise they are the same if they have the same bit number and
// bitmap.
return AtEnd == RHS.AtEnd && RHS.BitNumber == BitNumber;
}
bool operator!=(const SparseBitVectorIterator &RHS) const {
return !(*this == RHS);
}
};
public:
using iterator = SparseBitVectorIterator;
SparseBitVector() : Elements(), CurrElementIter(Elements.begin()) {}
SparseBitVector(const SparseBitVector &RHS)
: Elements(RHS.Elements), CurrElementIter(Elements.begin()) {}
SparseBitVector(SparseBitVector &&RHS)
: Elements(std::move(RHS.Elements)), CurrElementIter(Elements.begin()) {}
// Clear.
void clear() {
Elements.clear();
}
// Assignment
SparseBitVector& operator=(const SparseBitVector& RHS) {
if (this == &RHS)
return *this;
Elements = RHS.Elements;
CurrElementIter = Elements.begin();
return *this;
}
SparseBitVector &operator=(SparseBitVector &&RHS) {
Elements = std::move(RHS.Elements);
CurrElementIter = Elements.begin();
return *this;
}
// Test, Reset, and Set a bit in the bitmap.
bool test(unsigned Idx) const {
if (Elements.empty())
return false;
unsigned ElementIndex = Idx / ElementSize;
ElementListConstIter ElementIter = FindLowerBoundConst(ElementIndex);
// If we can't find an element that is supposed to contain this bit, there
// is nothing more to do.
if (ElementIter == Elements.end() ||
ElementIter->index() != ElementIndex)
return false;
return ElementIter->test(Idx % ElementSize);
}
void reset(unsigned Idx) {
if (Elements.empty())
return;
unsigned ElementIndex = Idx / ElementSize;
ElementListIter ElementIter = FindLowerBound(ElementIndex);
// If we can't find an element that is supposed to contain this bit, there
// is nothing more to do.
if (ElementIter == Elements.end() ||
ElementIter->index() != ElementIndex)
return;
ElementIter->reset(Idx % ElementSize);
// When the element is zeroed out, delete it.
if (ElementIter->empty()) {
++CurrElementIter;
Elements.erase(ElementIter);
}
}
void set(unsigned Idx) {
unsigned ElementIndex = Idx / ElementSize;
ElementListIter ElementIter;
if (Elements.empty()) {
ElementIter = Elements.emplace(Elements.end(), ElementIndex);
} else {
ElementIter = FindLowerBound(ElementIndex);
if (ElementIter == Elements.end() ||
ElementIter->index() != ElementIndex) {
// We may have hit the beginning of our SparseBitVector, in which case,
// we may need to insert right after this element, which requires moving
// the current iterator forward one, because insert does insert before.
if (ElementIter != Elements.end() &&
ElementIter->index() < ElementIndex)
++ElementIter;
ElementIter = Elements.emplace(ElementIter, ElementIndex);
}
}
CurrElementIter = ElementIter;
ElementIter->set(Idx % ElementSize);
}
bool test_and_set(unsigned Idx) {
bool old = test(Idx);
if (!old) {
set(Idx);
return true;
}
return false;
}
bool operator!=(const SparseBitVector &RHS) const {
return !(*this == RHS);
}
bool operator==(const SparseBitVector &RHS) const {
ElementListConstIter Iter1 = Elements.begin();
ElementListConstIter Iter2 = RHS.Elements.begin();
for (; Iter1 != Elements.end() && Iter2 != RHS.Elements.end();
++Iter1, ++Iter2) {
if (*Iter1 != *Iter2)
return false;
}
return Iter1 == Elements.end() && Iter2 == RHS.Elements.end();
}
// Union our bitmap with the RHS and return true if we changed.
bool operator|=(const SparseBitVector &RHS) {
if (this == &RHS)
return false;
bool changed = false;
ElementListIter Iter1 = Elements.begin();
ElementListConstIter Iter2 = RHS.Elements.begin();
// If RHS is empty, we are done
if (RHS.Elements.empty())
return false;
while (Iter2 != RHS.Elements.end()) {
if (Iter1 == Elements.end() || Iter1->index() > Iter2->index()) {
Elements.insert(Iter1, *Iter2);
++Iter2;
changed = true;
} else if (Iter1->index() == Iter2->index()) {
changed |= Iter1->unionWith(*Iter2);
++Iter1;
++Iter2;
} else {
++Iter1;
}
}
CurrElementIter = Elements.begin();
return changed;
}
// Intersect our bitmap with the RHS and return true if ours changed.
bool operator&=(const SparseBitVector &RHS) {
if (this == &RHS)
return false;
bool changed = false;
ElementListIter Iter1 = Elements.begin();
ElementListConstIter Iter2 = RHS.Elements.begin();
// Check if both bitmaps are empty.
if (Elements.empty() && RHS.Elements.empty())
return false;
// Loop through, intersecting as we go, erasing elements when necessary.
while (Iter2 != RHS.Elements.end()) {
if (Iter1 == Elements.end()) {
CurrElementIter = Elements.begin();
return changed;
}
if (Iter1->index() > Iter2->index()) {
++Iter2;
} else if (Iter1->index() == Iter2->index()) {
bool BecameZero;
changed |= Iter1->intersectWith(*Iter2, BecameZero);
if (BecameZero) {
ElementListIter IterTmp = Iter1;
++Iter1;
Elements.erase(IterTmp);
} else {
++Iter1;
}
++Iter2;
} else {
ElementListIter IterTmp = Iter1;
++Iter1;
Elements.erase(IterTmp);
changed = true;
}
}
if (Iter1 != Elements.end()) {
Elements.erase(Iter1, Elements.end());
changed = true;
}
CurrElementIter = Elements.begin();
return changed;
}
// Intersect our bitmap with the complement of the RHS and return true
// if ours changed.
bool intersectWithComplement(const SparseBitVector &RHS) {
if (this == &RHS) {
if (!empty()) {
clear();
return true;
}
return false;
}
bool changed = false;
ElementListIter Iter1 = Elements.begin();
ElementListConstIter Iter2 = RHS.Elements.begin();
// If either our bitmap or RHS is empty, we are done
if (Elements.empty() || RHS.Elements.empty())
return false;
// Loop through, intersecting as we go, erasing elements when necessary.
while (Iter2 != RHS.Elements.end()) {
if (Iter1 == Elements.end()) {
CurrElementIter = Elements.begin();
return changed;
}
if (Iter1->index() > Iter2->index()) {
++Iter2;
} else if (Iter1->index() == Iter2->index()) {
bool BecameZero;
changed |= Iter1->intersectWithComplement(*Iter2, BecameZero);
if (BecameZero) {
ElementListIter IterTmp = Iter1;
++Iter1;
Elements.erase(IterTmp);
} else {
++Iter1;
}
++Iter2;
} else {
++Iter1;
}
}
CurrElementIter = Elements.begin();
return changed;
}
bool intersectWithComplement(const SparseBitVector<ElementSize> *RHS) const {
return intersectWithComplement(*RHS);
}
// Three argument version of intersectWithComplement.
// Result of RHS1 & ~RHS2 is stored into this bitmap.
void intersectWithComplement(const SparseBitVector<ElementSize> &RHS1,
const SparseBitVector<ElementSize> &RHS2)
{
if (this == &RHS1) {
intersectWithComplement(RHS2);
return;
} else if (this == &RHS2) {
SparseBitVector RHS2Copy(RHS2);
intersectWithComplement(RHS1, RHS2Copy);
return;
}
Elements.clear();
CurrElementIter = Elements.begin();
ElementListConstIter Iter1 = RHS1.Elements.begin();
ElementListConstIter Iter2 = RHS2.Elements.begin();
// If RHS1 is empty, we are done
// If RHS2 is empty, we still have to copy RHS1
if (RHS1.Elements.empty())
return;
// Loop through, intersecting as we go, erasing elements when necessary.
while (Iter2 != RHS2.Elements.end()) {
if (Iter1 == RHS1.Elements.end())
return;
if (Iter1->index() > Iter2->index()) {
++Iter2;
} else if (Iter1->index() == Iter2->index()) {
bool BecameZero = false;
Elements.emplace_back(Iter1->index());
Elements.back().intersectWithComplement(*Iter1, *Iter2, BecameZero);
if (BecameZero)
Elements.pop_back();
++Iter1;
++Iter2;
} else {
Elements.push_back(*Iter1++);
}
}
// copy the remaining elements
std::copy(Iter1, RHS1.Elements.end(), std::back_inserter(Elements));
}
void intersectWithComplement(const SparseBitVector<ElementSize> *RHS1,
const SparseBitVector<ElementSize> *RHS2) {
intersectWithComplement(*RHS1, *RHS2);
}
bool intersects(const SparseBitVector<ElementSize> *RHS) const {
return intersects(*RHS);
}
// Return true if we share any bits in common with RHS
bool intersects(const SparseBitVector<ElementSize> &RHS) const {
ElementListConstIter Iter1 = Elements.begin();
ElementListConstIter Iter2 = RHS.Elements.begin();
// Check if both bitmaps are empty.
if (Elements.empty() && RHS.Elements.empty())
return false;
// Loop through, intersecting stopping when we hit bits in common.
while (Iter2 != RHS.Elements.end()) {
if (Iter1 == Elements.end())
return false;
if (Iter1->index() > Iter2->index()) {
++Iter2;
} else if (Iter1->index() == Iter2->index()) {
if (Iter1->intersects(*Iter2))
return true;
++Iter1;
++Iter2;
} else {
++Iter1;
}
}
return false;
}
// Return true iff all bits set in this SparseBitVector are
// also set in RHS.
bool contains(const SparseBitVector<ElementSize> &RHS) const {
SparseBitVector<ElementSize> Result(*this);
Result &= RHS;
return (Result == RHS);
}
// Return the first set bit in the bitmap. Return -1 if no bits are set.
int find_first() const {
if (Elements.empty())
return -1;
const SparseBitVectorElement<ElementSize> &First = *(Elements.begin());
return (First.index() * ElementSize) + First.find_first();
}
// Return the last set bit in the bitmap. Return -1 if no bits are set.
int find_last() const {
if (Elements.empty())
return -1;
const SparseBitVectorElement<ElementSize> &Last = *(Elements.rbegin());
return (Last.index() * ElementSize) + Last.find_last();
}
// Return true if the SparseBitVector is empty
bool empty() const {
return Elements.empty();
}
unsigned count() const {
unsigned BitCount = 0;
for (ElementListConstIter Iter = Elements.begin();
Iter != Elements.end();
++Iter)
BitCount += Iter->count();
return BitCount;
}
iterator begin() const {
return iterator(this);
}
iterator end() const {
return iterator(this, true);
}
};
// Convenience functions to allow Or and And without dereferencing in the user
// code.
template <unsigned ElementSize>
inline bool operator |=(SparseBitVector<ElementSize> &LHS,
const SparseBitVector<ElementSize> *RHS) {
return LHS |= *RHS;
}
template <unsigned ElementSize>
inline bool operator |=(SparseBitVector<ElementSize> *LHS,
const SparseBitVector<ElementSize> &RHS) {
return LHS->operator|=(RHS);
}
template <unsigned ElementSize>
inline bool operator &=(SparseBitVector<ElementSize> *LHS,
const SparseBitVector<ElementSize> &RHS) {
return LHS->operator&=(RHS);
}
template <unsigned ElementSize>
inline bool operator &=(SparseBitVector<ElementSize> &LHS,
const SparseBitVector<ElementSize> *RHS) {
return LHS &= *RHS;
}
// Convenience functions for infix union, intersection, difference operators.
template <unsigned ElementSize>
inline SparseBitVector<ElementSize>
operator|(const SparseBitVector<ElementSize> &LHS,
const SparseBitVector<ElementSize> &RHS) {
SparseBitVector<ElementSize> Result(LHS);
Result |= RHS;
return Result;
}
template <unsigned ElementSize>
inline SparseBitVector<ElementSize>
operator&(const SparseBitVector<ElementSize> &LHS,
const SparseBitVector<ElementSize> &RHS) {
SparseBitVector<ElementSize> Result(LHS);
Result &= RHS;
return Result;
}
template <unsigned ElementSize>
inline SparseBitVector<ElementSize>
operator-(const SparseBitVector<ElementSize> &LHS,
const SparseBitVector<ElementSize> &RHS) {
SparseBitVector<ElementSize> Result;
Result.intersectWithComplement(LHS, RHS);
return Result;
}
// Dump a SparseBitVector to a stream
template <unsigned ElementSize>
void dump(const SparseBitVector<ElementSize> &LHS, raw_ostream &out) {
out << "[";
typename SparseBitVector<ElementSize>::iterator bi = LHS.begin(),
be = LHS.end();
if (bi != be) {
out << *bi;
for (++bi; bi != be; ++bi) {
out << " " << *bi;
}
}
out << "]\n";
}
} // end namespace llvm
#endif // LLVM_ADT_SPARSEBITVECTOR_H
```
|
Camargo Municipality may refer to:
Camargo Municipality, Chihuahua, Mexico
Camargo Municipality, Tamaulipas, Mexico
See also
Camargo (disambiguation)
Municipality name disambiguation pages
|
The 4th annual Venice International Film Festival was held between 10 and 31 August 1936. This year saw an international jury nominated for the first time.
Jury
Giuseppe Volpi di Misurata (president) (Italy)
Neville Kearney (UK)
Oswald Lehnich (Germany)
Karl Meltzer (Germany)
Ryszard Ordynski (Poland)
Louis Villani (Hungary)
Émile Vuillermoz (France)
Luigi Freddi (Italy)
Mario Gromo (Italy)
Antonio Maraini (Italy)
Giacomo Paolucci de Calboli Barone (Italy)
Filippo Sacchi (Italy)
Ottavio Croze (Italy)
In-Competition films
La Kermesse héroïque by Jacques Feyder
Der Kaiser von Kalifornien by Luis Trenker
The Ghost Goes West by René Clair
The Great Ziegfeld by Robert Z. Leonard
Lo squadrone bianco by Augusto Genina
Mayerling by Anatole Litvak
Mr. Deeds Goes to Town by Frank Capra
Show Boat by James Whale
The Story of Louis Pasteur by William Dieterle
Veille d'armes by Marcel L'Herbier
Awards
Best Foreign Film: Der Kaiser von Kalifornien by Luis Trenker
Best Italian Film: Lo squadrone bianco by Augusto Genina
Volpi Cup:
Best Actor: Paul Muni for The Story of Louis Pasteur
Best Actress: Annabella for Veille d'armes
Special Recommendation:
Ave Maria by Johannes Riemann
Children's Corner by Marcel L'Herbier, Emile Vuillermoz
Mary of Scotland by John Ford
Marysa by Josef Rovenský
Metropolitan Nocturne by Leigh Jason
Mr. Deeds Goes to Town by Frank Capra
Opernring by Carmine Gallone
Polesie by Maksymilian Emmer, Jerzy Maliniak
Pompei by Giorgio Ferroni
Scrooge by Henry Edwards
The Mine by J. B. Holmes
The Robber Symphony by Friedrich Feher
Verräter by Karl Ritter
Animated Film: Who Killed Cock Robin? by Walt Disney
Color Film: The Trail of the Lonesome Pine by Henry Hathaway
Best Director: La Kermesse héroïque by Jacques Feyder
Best Cinematography: Tudor Rose by Mutz Greenbaum
References
External links
Venice Film Festival 1936 Awards on IMDb
V
Venice Film Festival
1936 film festivals
Film
August 1936 events
|
```objective-c
#pragma once
#include <vcruntime_internal.h>
#include <corecrt_internal.h>
#include <trnsctrl.h>
#define EHTRACE_ENTER_FMT1(...)
#define EHTRACE_ENTER_FMT2(...)
#define EHTRACE_FMT1(...)
#define EHTRACE_FMT2(...)
#define EHTRACE_ENTER
#define EHTRACE_EXIT
#define EHTRACE_EXCEPT(x) x
#define EHTRACE_HANDLER_EXIT(x)
#define EHTRACE_RESET
#define DASSERT(x)
#define _VCRT_VERIFY(x)
#define _ValidateRead(ptr) (ptr != NULL)
#define _ValidateWrite(ptr) (ptr != NULL)
#define _ValidateExecute(ptr) (ptr != NULL)
#define RENAME_EH_EXTERN(x) x
#if _EH_RELATIVE_FUNCINFO
EXTERN_C uintptr_t __cdecl _GetImageBase();
EXTERN_C void __cdecl _SetImageBase(uintptr_t ImageBaseToRestore);
#endif
#if _EH_RELATIVE_TYPEINFO
EXTERN_C uintptr_t __cdecl _GetThrowImageBase();
EXTERN_C void __cdecl _SetThrowImageBase(uintptr_t NewThrowImageBase);
#endif
EXTERN_C _VCRTIMP FRAMEINFO * __cdecl _CreateFrameInfo(
FRAMEINFO * pFrameInfo,
PVOID pExceptionObject
);
EXTERN_C _VCRTIMP void __cdecl _FindAndUnlinkFrame(
FRAMEINFO * pFrameInfo
);
EXTERN_C _VCRTIMP BOOL __cdecl _IsExceptionObjectToBeDestroyed(
PVOID pExceptionObject
);
#if _CRT_NTDDI_MIN >= NTDDI_WIN6
#define __pSETranslator (_se_translator_function)(((_ptd_msvcrt_win6_shared*)__acrt_getptd())->_translator)
#else
static __inline void* __fastcall __pSETranslator_fun()
{
auto ptd = __acrt_getptd();
const auto OSVersion = __LTL_GetOsMinVersion();
#if defined(_M_IX86)
if (OSVersion < 0x00050001)
{
return ((_ptd_msvcrt_win2k*)ptd)->_translator;
}
#endif
if (OSVersion < 0x00060000)
{
return ((_ptd_msvcrt_winxp*)ptd)->_translator;
}
return ((_ptd_msvcrt_win6_shared*)ptd)->_translator;
}
#define __pSETranslator (_se_translator_function)(__pSETranslator_fun())
#endif
#ifdef _EH_RELATIVE_FUNCINFO
template <class T>
BOOL _CallSETranslator(
EHExceptionRecord *pExcept, // The exception to be translated
EHRegistrationNode *pRN, // Dynamic info of function with catch
CONTEXT *pContext, // Context info
DispatcherContext *pDC, // More dynamic info of function with catch (ignored)
typename T::FuncInfo *pFuncInfo, // Static info of function with catch
ULONG CatchDepth, // How deeply nested in catch blocks are we?
EHRegistrationNode *pMarkerRN // Marker for parent context
);
#endif
#if defined(_M_X64)
EXTERN_C void* __cdecl _CallSettingFrame(
void* handler,
EHRegistrationNode* pEstablisher,
ULONG NLG_CODE
);
EXTERN_C void* __cdecl _CallSettingFrameEncoded(
void* handler,
EHRegistrationNode pEstablisher,
void* object,
ULONG NLG_CODE
);
EXTERN_C void* __cdecl _CallSettingFrame_LookupContinuationIndex(
void* handler,
EHRegistrationNode *pEstablisher,
ULONG NLG_CODE
);
EXTERN_C void* __cdecl _CallSettingFrame_NotifyContinuationAddr(
void* handler,
EHRegistrationNode *pEstablisher
);
#elif defined(_M_ARM_NT) || defined(_M_ARM64) || defined(_CHPE_X86_ARM64_EH_)
EXTERN_C void* __cdecl _CallSettingFrame(
void* handler,
EHRegistrationNode* pRN,
PULONG pNonVolatiles,
ULONG NLG_CODE
);
#endif
```
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var tape = require( 'tape' );
var isnan = require( '@stdlib/math/base/assert/is-nan' );
var abs = require( '@stdlib/math/base/special/abs' );
var EPS = require( '@stdlib/constants/float64/eps' );
var kernelLog1p = require( './../lib' );
// TESTS //
tape( 'main export is a function', function test( t ) {
t.ok( true, __filename );
t.strictEqual( typeof kernelLog1p, 'function', 'main export is a function' );
t.end();
});
tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
var v = kernelLog1p( NaN );
t.equal( isnan( v ), true, 'returns expected value' );
t.end();
});
tape( 'the function correctly computes `log(1+f) - f` for `1+f` satisfying `sqrt( 2 ) / 2 < 1+f < sqrt( 2 )`', function test( t ) {
var expected;
var delta;
var tol;
var x;
var y;
var i;
var e;
x = [
1.4142135623730951
];
expected = [
0.46716000147788844
];
for ( i = 0; i < x.length; i++ ) {
y = kernelLog1p( x[ i ] );
e = expected[ i ];
if ( y === e ) {
t.equal( y, e, 'x: '+x[ i ]+'. E: '+e );
} else {
delta = abs( y - e );
tol = 1.0 * EPS * abs( e );
t.ok( delta <= tol, 'within tolerance. x: '+x[ i ]+'. y: '+y+'. E: '+e+'. tol: '+tol+'. : '+delta+'.' );
}
}
t.end();
});
```
|
Sandown does not appear in Lloyd's Register. A does appear in Lloyd's Register between 1789 and 1798, but it is a different vessel from the Sandown of this article, though the two vessels are sometimes conflated.
In January 1786 Sandown, a foreign-built ship, had grounded at Sandown Bay on the back of the Isle of Wight. She had since been repaired.
The French privateer Guillotine captured Sandown, Apsey, master, on 28 July at , about 100 miles WNW from Havana. The single ship action took about an hour before Sandown struck.
On 2 August, captured Guillotine, and recaptured Sandown; Scorpion took them into Havana. Then on 27 and 28 August Sandown, Apsey, master, was driven ashore at Havana in a hurricane and lost. At the time she was on her way from Jamaica and Havana to London. The hurricane destroyed over 76 vessels; only two were identified – Sandown, and the Spanish warship Flor. Most of the cargoes were salvaged.
It is clear from the log of Captain Gamble, master of Sandown (1788) that this Sandown is not Gamble's Sandown. In his account Gamble reports that on 15 August 1794 he had spoken with Mano, which reported that a British sloop-of-war had brought into Havana a privateer and her prize, which had been bound from Jamaica to Liverpool. Gamble further remarked that the merchantman had sailed from Jamaica some 14 days before the fleet that Sandown (1788) was part of had left. The prize money notice for the capture of Guillotine, and the salvage money notice for Sandown above support that the first account above in Lloyd's List is not a false report.
Notes
Citations
References
1780s ships
Age of Sail merchant ships of England
Captured ships
Maritime incidents in 1794
|
```php
<?php
namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\Calculation\Internal\WildcardMatch;
abstract class DatabaseAbstract
{
abstract public static function evaluate(array $database, array|null|int|string $field, array $criteria): null|float|int|string;
/**
* fieldExtract.
*
* Extracts the column ID to use for the data field.
*
* @param mixed[] $database The range of cells that makes up the list or database.
* A database is a list of related data in which rows of related
* information are records, and columns of data are fields. The
* first row of the list contains labels for each column.
* @param mixed $field Indicates which column is used in the function. Enter the
* column label enclosed between double quotation marks, such as
* "Age" or "Yield," or a number (without quotation marks) that
* represents the position of the column within the list: 1 for
* the first column, 2 for the second column, and so on.
*/
protected static function fieldExtract(array $database, mixed $field): ?int
{
$field = strtoupper(Functions::flattenSingleValue($field) ?? '');
if ($field === '') {
return null;
}
$fieldNames = array_map('strtoupper', array_shift($database));
if (is_numeric($field)) {
$field = (int) $field - 1;
if ($field < 0 || $field >= count($fieldNames)) {
return null;
}
return $field;
}
$key = array_search($field, array_values($fieldNames), true);
return ($key !== false) ? (int) $key : null;
}
/**
* filter.
*
* Parses the selection criteria, extracts the database rows that match those criteria, and
* returns that subset of rows.
*
* @param mixed[] $database The range of cells that makes up the list or database.
* A database is a list of related data in which rows of related
* information are records, and columns of data are fields. The
* first row of the list contains labels for each column.
* @param mixed[] $criteria The range of cells that contains the conditions you specify.
* You can use any range for the criteria argument, as long as it
* includes at least one column label and at least one cell below
* the column label in which you specify a condition for the
* column.
*
* @return mixed[]
*/
protected static function filter(array $database, array $criteria): array
{
$fieldNames = array_shift($database);
$criteriaNames = array_shift($criteria);
// Convert the criteria into a set of AND/OR conditions with [:placeholders]
$query = self::buildQuery($criteriaNames, $criteria);
// Loop through each row of the database
return self::executeQuery($database, $query, $criteriaNames, $fieldNames);
}
protected static function getFilteredColumn(array $database, ?int $field, array $criteria): array
{
// reduce the database to a set of rows that match all the criteria
$database = self::filter($database, $criteria);
$defaultReturnColumnValue = ($field === null) ? 1 : null;
// extract an array of values for the requested column
$columnData = [];
foreach ($database as $rowKey => $row) {
$keys = array_keys($row);
$key = $keys[$field] ?? null;
$columnKey = $key ?? 'A';
$columnData[$rowKey][$columnKey] = $row[$key] ?? $defaultReturnColumnValue;
}
return $columnData;
}
private static function buildQuery(array $criteriaNames, array $criteria): string
{
$baseQuery = [];
foreach ($criteria as $key => $criterion) {
foreach ($criterion as $field => $value) {
$criterionName = $criteriaNames[$field];
if ($value !== null) {
$condition = self::buildCondition($value, $criterionName);
$baseQuery[$key][] = $condition;
}
}
}
$rowQuery = array_map(
fn ($rowValue): string => (count($rowValue) > 1) ? 'AND(' . implode(',', $rowValue) . ')' : ($rowValue[0] ?? ''),
$baseQuery
);
return (count($rowQuery) > 1) ? 'OR(' . implode(',', $rowQuery) . ')' : ($rowQuery[0] ?? '');
}
private static function buildCondition(mixed $criterion, string $criterionName): string
{
$ifCondition = Functions::ifCondition($criterion);
// Check for wildcard characters used in the condition
$result = preg_match('/(?<operator>[^"]*)(?<operand>".*[*?].*")/ui', $ifCondition, $matches);
if ($result !== 1) {
return "[:{$criterionName}]{$ifCondition}";
}
$trueFalse = ($matches['operator'] !== '<>');
$wildcard = WildcardMatch::wildcard($matches['operand']);
$condition = "WILDCARDMATCH([:{$criterionName}],{$wildcard})";
if ($trueFalse === false) {
$condition = "NOT({$condition})";
}
return $condition;
}
private static function executeQuery(array $database, string $query, array $criteria, array $fields): array
{
foreach ($database as $dataRow => $dataValues) {
// Substitute actual values from the database row for our [:placeholders]
$conditions = $query;
foreach ($criteria as $criterion) {
$conditions = self::processCondition($criterion, $fields, $dataValues, $conditions);
}
// evaluate the criteria against the row data
$result = Calculation::getInstance()->_calculateFormulaValue('=' . $conditions);
// If the row failed to meet the criteria, remove it from the database
if ($result !== true) {
unset($database[$dataRow]);
}
}
return $database;
}
private static function processCondition(string $criterion, array $fields, array $dataValues, string $conditions): string
{
$key = array_search($criterion, $fields, true);
$dataValue = 'NULL';
if (is_bool($dataValues[$key])) {
$dataValue = ($dataValues[$key]) ? 'TRUE' : 'FALSE';
} elseif ($dataValues[$key] !== null) {
$dataValue = $dataValues[$key];
// escape quotes if we have a string containing quotes
if (is_string($dataValue) && str_contains($dataValue, '"')) {
$dataValue = str_replace('"', '""', $dataValue);
}
$dataValue = (is_string($dataValue)) ? Calculation::wrapResult(strtoupper($dataValue)) : $dataValue;
}
return str_replace('[:' . $criterion . ']', $dataValue, $conditions);
}
}
```
|
Issogne Castle is a castle in Issogne, in lower Aosta Valley, in northwestern Italy. It is one of the most famous manors of the region, and is located on the right bank of the Dora Baltea at the centre of the inhabited area of Issogne. As a seigniorial residence of the Renaissance, the Castle has quite a different look from that of the austere Verrès Castle, which is located in Verrès, on the opposite bank of the river.
Issogne Castle is most noteworthy for its fountain in the form of pomegranate tree and its highly decorated portico, a rare example of medieval Alpine painting, with its frescoed cycle of scenes of daily life from the late Middle Ages.
History
Middle ages
The earliest mention of the castle of Issogne is in a papal bull issued by Pope Eugene III in 1151, which refers to a fortified building at Issogne, the property of the Bishop of Aosta. Some walling discovered in the cellars of the current castle may be evidence of a Roman villa, dating from the 1st century BC, on the site.
Tensions between the Bishop of Aosta and the De Verrecio family, lords of the nearby town of Verrès, reached boiling point around 1333, when the castle of Issogne, the episcopal seat, was attacked and damaged by fire. Issogne remained the seat of the bishop until 1379, when the bishop of Aosta submitted to the jurisdiction of the then lord of Verrès, Yblet of Challant. Ibleto transformed the episcopal stronghold into an elegant princely residence in Gothic style, with a series of towers and buildings enclosed by an encircling wall.
When Yblet died in 1409, the feud and castle of Issogne passed to his son Francis of Challant (French: François de Challant), who in 1424 received the title of Count of Challant from the Duke of Savoy. Francesco died in 1442, leaving no male heir. A long succession struggle between Francesco's daughter Catherine of Challant and her cousin James of Challant-Aymavilles (French: Jacques de Challant-Aymavilles) was won by James, who thus became the second Count of Challant and the new lord of Issogne.
Renaissance
From about 1480, further alterations were made to the Castle by James's son Luigi di Challant, and continued after his death in 1487 by his cousin, the prior George of Challant-Varey (French: Georges de Challant-Varey), to whom James's wife Marguerite de la Chambre had granted custody of his sons Philibert and Charles. George had new wings erected to connect the already existing buildings, unifying the complex into a single horseshoe shape surrounding a central courtyard. The decorations of the portico and the celebrated pomegranate fountain date to this period. The Castle hosted many illustrious guests, including the future emperor Sigismund of Luxemburg as he returned to Germany in 1414, and King Charles VIII of France in 1494.
Work on the Castle ended with the death of George of Challant in 1509. Philibert of Challant became the new lord of Issogne, and made the Castle a residence for himself, his wife Louise d'Aarberg and his son René of Challant, under whom the Castle reached its greatest splendour and hosted a rich and refined court.
Decline and rebirth
Renato di Challant left no male heir at his death in 1565. His possessions passed to Giovanni Federico Madruzzo, husband of René's daughter Isabelle, giving rise to an inheritance dispute between the Madruzzo family and Isabelle's cousins of the Challant family that lasted for more than a century. The lordship of Issogne and its Castle passed from the Madruzzo family to the Lenoncourt family, then in 1693 to Cristina Maurizia Del Carretto di Balestrina, and was finally returned to the Challant family in 1696.
In 1802, the last count of Challant, Giulio Giacinto, died, and the Challant family was extinguished. The Castle, already abandoned for some years, fell into decay and its furniture was removed. In 1872 the owner of the Castle, Baron Marius de Vautheleret, was forced to sell it at auction. It was acquired by the Turin painter Vittorio Avondo, who restored it, furnishing it with some of its original furniture bought back from the antique market, and with copies of furniture of the period. Avondo donated the Castle to the Italian state in 1907; in 1948 it passed to the Aosta Valley region.
The Castle may be visited by guided tour.
Interior of the Castle
From the exterior, the Castle looks like a fortified residence of fairly unprepossessing appearance, without any particular decoration, with angular turrets a little higher than the rest of the building. The Castle is situated at the centre of the inhabited area of Issogne.
The Castle was built to a quadrangular plan, three sides of which are occupied by the building and the fourth, oriented towards the south, comprises an Italian Garden, enclosed within a surrounding wall.
The courtyard and portico
The internal courtyard, enclosed within the three sides of the building, and the garden form one of the most interesting spaces of the Castle. At one time, one reached this space by passing from the countryside through principal gate and under a portico. Today, for practical reasons, the secondary entrance on the west side is used. This entrance faces an expansive field.
On the facades that face the courtyard, one finds the so-called "Miroir pour les infants de Challant", a series of frescoed heraldic arms that show the diverse branches of the Challant family and the principal matrimonial alliances of the house. The "miroir" was created in order to preserve a record of the family history and to transmit it to future generations. The surrounding wall of the garden, on the other hand, was decorated with monochromatic images of legends and heroes of antiquity, now unfortunately almost entirely obliterated.
At the centre of the courtyard, one finds the celebrated 'pomegranate fountain'. From the octagonal stone bowl of the fountain emerges a pomegranate tree made of wrought iron from which jets of water are sprayed. Strangely, although the fruit of the tree is clearly to be understood as that of the pomegranate the leaves, perhaps for symbolic reasons intended by the artist, are those of another tree - the oak. George of Challant probably had the fountain constructed as a wedding gift for the wedding of his favourite, Philibert of Challant, when Philibert married Louise d'Aarberg in 1502. It appears that the tree is to be read symbolically as the expression of the desire to unite the fertility and unity of the family represented by the pomegranate, with its seed-filled fruit, with the strength and antiquity signified by the oak. Amongst the branches of the pomegranate-oak, and somewhat difficult to discern, tiny dragons have been inserted.
The east side of the courtyard is occupied by the portico with its round arches and cross-vaults. The principal entrance of the Castle opens onto this portico and the interior of the building is nowadays also reached from this portico. The geometric decoration of the ribbing of the cross-vaults is typical of the rate of the fifteenth century.
The lunettes of the portico are decorated with frescoes giving realistic and humorous depictions of scenes daily life and the trades of the period. They represent an important iconographic testament to life between the fifteenth and sixteenth centuries. The 'lunette of the guard house' shows some soldiers, accompanied by some prostitutes, seated at a table and intent on playing cards or tric-trac. Their weapons and armour (including cuirasses, crossbows and halberds) are hung up on a rack attached to the wall. In the 'lunette of the bakery', recently kneaded bread is being pushed into an oven; a butcher turns meat on a spit while a cat tries to steal it from him. In the 'lunette of the tailor's shop', pieces of cloth are measured and cut, while on the shelves of the rear of the apothecary's shop, numerous jars of herbs and other medicines are shown. The 'lunette of the market' shows a fruit and vegetable market busy with numerous customers and vendors dressed in costumes of the period. Lastly, in the 'lunette of the small goods seller's shop', some forms of the typical Fontina cheese are shown; these are considered to the oldest representations of this cheese.
Besides their æsthetic function, these frescoes probably have a celebratory function, and are probably intended to show the abundance and peace obtained in the region thanks to the leadership of the lord of the Castle. The entire cycle has been attributed to an artist known as 'maître Colin' due to a graffito in the 'lunette of the guard house' that identifies 'Magister Collinus' as the author of the work. The same artist is known as the author of some paintings in the chapel on the first floor of the Castle.
The ground floor
The Castle comprises a total of about fifty rooms, although only about ten of them may visited with the guided tour. A door in the portico leads to the dining room, roofed by a vault and furnished with nineteenth-century furniture that Vittorio Avondo had made on the basis of Renaissance models. The dining room was joined to the kitchen by means of a service-hatch. The kitchen is divided into two parts by a wooden grate, creating two distinct spaces probably originally intended for the preparation of different types of food. The larger space, adjacent to the dining room, is provided with a large fireplace and an oven, while the smaller part includes a fireplace of smaller dimensions and a sink.
On the northern side, next to the staircase that leads to the second floor, one finds the so-called 'hall of justice' or 'lower halls', the principal presentation space of the Castle. It is a large hall on a rectangular plan, with the walls completely covered in a fresco of a fictive loggia with columns of marble, alabaster and transparent crystal. Scenes of the hunt, courtly life and northern landscapes are represented. The cycle of decoration culminates with the judgement of Paris, in which the commissioner of the work, George of Challant, is actually represented as Paris. The frescoes of this hall, probably completed before the death of George of Challant in 1509, have been attributed to the Master of Wuillerine, an artist thought to have been of the Franco-Flemish school, as may be deduced from the presence in the landscapes of houses with sharply-pitched roofs and windmills of the type typical in northern Europe. The Master of Wuillerine is also the author of an "ex voto" for the collegiate church of Saint Ursus at Aosta. The ceiling is of wood with the trusses left exposed. Placed along the walls on the long sides of the hall are placed carved wooden stalls, nineteenth-century recreations of the late-Gothic originals conserved in the Turin City Museum of Ancient Art. The rear wall of the hall is pierced by a large stone fireplace decorated by a griffin and a lion that hold the arms of the Challant family aloft.
The other rooms of the ground floor, which may not be visited, house the dispensary of the Castle, service rooms for the use of the kitchen (including a small goods store), the prisoner, the room reserved for the use of pilgrims, and rooms for the falconer, the guards, as well as other service rooms.
The first floor
The first floor of the Castle contains the rooms of the lords of the manor. They were also adapted by Vittorio Avondo when he acquired the Castle in the 19th century to his own personal use. One reaches this floor by means of a stone spiral staircase adjoining the 'hall of justice'. The same spiral staircase also provides access to the rooms of the ground floor as well as directly to the courtyard. The staircase if formed from a series of stone steps of trapezoidal shape. The wider part of the step is immured into the wall and the narrower part finished with a cylindrical element. Overlapping vertically in a series of steps, these cylindrical elements form a central column that give the staircase a significant static strength. The ceiling of the ramp is created by leaving the lower surface of the upper steps exposed, thus giving the appearance of a continuous ribbon that draws one on as one ascends the staircase.
One of the first rooms that one encounters as one climbs the staircase is the so-called 'chamber of Marguerite de la Chambre'. This was the private room first of Marguerite de la Chambre, wife of Luigi of Challant, and then of Mencia de Bragança, the wife of René of Challant. The room is covered by a wooden ceiling with exposed trusses. At the top of the wall, and located in the spaces between the exposed trusses, a frieze showing Marguerite's arms can be found. The furnishings of the room include a large stone fireplace and a canopied bed, a nineteenth-century copy of an original to be found in the Ussel Castle.
Next to the bedchamber can be found the private oratory of Marguerite de la Chambre, a small square room covered by a cross vault. This oratory is entirely covered in fresco, with scenes showing the Assumption of the Virgin, the martyrdom of St Catherine and St Margaret. One of these frescoes shows Marguerite herself praying in the company of her two daughters-in-law and her three sons. The entire cycle was repainted in 1936.
Next to Marguerite's room, and accessible either through it or by means of the staircase, is the large rectangular hall covered with a wooden ceiling called the 'chambre de Savoie' (the Savoy Chamber) in the inventory compiled at the death of Renato di Challant in 1565. At the back of this hall there is a large stone fireplace upon which are depicted the arms of the Savoy family, after which the room was originally named, and the united arms of the Challand and La Palud families, brought together by virtue of the wedding of Amadeus of Challant-Varey and Anne de La Palud, parents of the Prior George of Challant. The furnishings of this room reflect its organisation in the nineteenth century by Vittorio Avondo, who displayed his collection of antique arms and armour him; for this reason, the room has been called the 'hall of arms'. Completing the furnishing of the room is a series of pieces of furniture that are nineteenth-century copies of Late Gothic originals.
The last space that may be visited on the first floor is the chapel, situated in the eastern wing of the Castle, above the portico of the courtyard. This is a long and narrow room, covered by a series of cross-vaults that divide the space into five bays. A wooden railing divides the room into two spaces, thus probably separating the lords of the manner from their services. The wooden stalls in this room, placed against the wall, are nineteenth-century copies that Vittorio Avondo had made, while the winged altar is original to the Castle, having been made at the start of the sixteenth century. Avondo bought this altar back on the antique market after it had been sold by the previous proprietors of the manor. The wings of the polyptych and the frescoes of the chapel, showing scenes of the Nativity, the Prophets, the Apostles and the Doctors of the Church, have been attributed to Maître Colin, the same artist who created the lunettes of the portico in the courtyard and who had worked on the decoration of the collegiate church of Saint Ursus in Aosta, of which George of Challant was prior.
Among the spaces that cannot be visited on the guided tour there are the private rooms of René of Challant, of his daughters Philiberte and Isabelle, of Cardinal Cristoforo Madruzzo (uncle of Giovanni Federico Madruzzo, the husband of Isabella di Challant) and their antechambers and access spaces.
The second floor
The second floor is reached by continuing to ascend the stone spiral staircase. Corresponding to the rooms of Marguerite de la Chambre we find those spaces reserved to George of Challant. One of George's rooms, also known as the 'Chambre de Saint Maurice' because of the coffered ceiling, the coffers of which contain the cross of the Order of Cavaliers of Saint Maurice, is furnished in a way corresponding to the furnishings of Marguerite's room underneath it. The room features a canopied bed of the sixteenth century and a credenza and a commode made in the nineteenth century at the direction of Avondo but in the late Gothic style. The room is warmed by a large stone fireplace decorated with the arms of George of Challant upheld by a griffin and a lion.
From the room of George of Challant, one enters his private oratory, located again in correspondence to that of Marguerite. This, too, is a small space on a quadrangular plan, covered with a cross vault and completely frescoed. The frescoes, the work of the same anonymous Northern artist who decorated Marguerite's chapel, show the scene of the crucifixion, a pietà, and the entombment of Christ. George, the commissioner of the work, is depicted kneeling at the foot of the cross. As with many other paintings in the manor, the frescoes of George's oratory were repainted during a restoration in 1936.
From the principal staircase, one reaches the so-called 'Hall of the King of France', situated next to the rooms of George of Challant and over the 'hall of arms'. Its name would seem to have derived from probably having been the room in which Charles VIII of France stayed during his passage through Italy in 1494. In the sixteenth century, this was the wedding chamber of René of Challant and his wife Mencia.
The room is covered by a coffered ceiling and is warmed by a fireplace decorated with the lilies of the royal arms of France. The room is furnished with furniture in part bought back by Avondo, as for example the canopied bed with the arms of the Challant-Aymavilles branch acquired from a peasant in Ussel, and in part by nineteenth-century reconstructions.
Passing through the room of the King of France and through a series of access rooms, one reaches the 'Chamber of the Tower', situated in the north-west corner of the manor in the most ancient part of the Castle. The different windows of the room permitted a view of the Castles of Arnad and Verrès as well as of the Villa Castle in Challand. This space was probably used as a signalling tower. In case of danger, the lords of manor would have been able to take securer refuge in the more easily defended Verrès Castle.
To reach the last room that can be visited on this floor, it is necessary to pass through a loggia covered with a cross vault. This last room is located at the south-west extremity of the Castle. In an inventory of 1565, it is called the 'Chamber of the Emperor', probably in honour of the stay of the Emperor Sigismond of Luxemburg in 1414. The room is now called the 'Chamber of the Little Countess' in honour of the countess Isabelle of Challant, the daughter of René of Challant and Mencia de Bragança. It is furnished with a sixteenth-century bed of Tyrolese origin, reconstructed furniture commissioned by Avondo in the nineteenth century and a stone fireplace decorated with the arms of George of Challant.
In the eastern wing of the Castle, which may not be visited, one finds a loggia roofed with a cross vault and positioned in a location corresponding to the chapel, some rooms and access spaces, and the stairs that lead to the roof of the castle. According to a legend, the ghost of Bianca Maria Gaspardone would appear on the roof on moonlit nights. Gaspardone was the first wife of René of Challant. Gaspardone abandoned her marriage René after only some months, having become tired of the long absences of her husband. She was subsequently condemned to death for procuring the assassination of her former lover Ardizzino Valperga by Don Pietro di Cardona, her then current lover; she was executed at Milan in 1526.
The graffiti
One of the characteristic features of the Issogne Castle, apart from the famous frescoes and the pomegranate fountain, is the numerous graffiti that have been left in the course of centuries by visitors to and guests of the Castle, the servants and lords of the manor themselves. These graffiti have been preserved because the Castle has never undergone major change, and they provide valuable evidence about daily life in the Castle. These graffiti, usually incised on the walls, are present throughout the Castle but in particular are visible in the portico of the courtyard, in the corridors, and in the embrasures of the doors and windows.
The graffiti are mostly in French or Latin, and amongst them one finds visitors' reflections on how sad or happy they are to be leaving the Castle, a great number about life or money, confessions of being in love, and mocking jibes. The frescoed lunettes of the portico show, in addition to the signature of the painter Master Colin, comments on one or other of the professions depicted, while in the gallery that leads from the 'Chamber of the Little Countess', one may read an epitaph for the death of Count René de Challant ('XI julii 1565/obiit Renatus/comes de Challant', i.e. 'On the 11th of July 1565, René, count of Challant, died') and expressions of sadness on the occasion of the anniversary of that date.
References
Internal links
George of Challant
External links
Issogne Castle - Aosta Valley Tourism Office official website
Houses completed in 1509
Castles in Aosta Valley
Museums in Aosta Valley
Historic house museums in Italy
|
Mademoiselle Béatrice is a 1943 French comedy film directed by Max de Vaucorbeil and starring Gaby Morlay, André Luguet and Louise Carletti. The film's sets were designed by the art director Raymond Druart.
Synopsis
A student in Paris is in love with Jeanette, but her family seem to present an obstacle to marriage. Fortunately Aunt Béatrice steps in to assist and all eventually turns out happily.
Cast
Gaby Morlay as Béatrice
André Luguet as Hubert de Sainte-Croix
Louise Carletti as Jeanette
Jacques Baumer as Maître Bergas
Germaine Charley as Madame de Malempré
Marguerite Deval as La vieille dame du banc
Louis Salou as Maurin-Gautier
Jean Périer as Le vieux monsieur du banc
Sinoël as Dagobert
Gabrielle Fontan as Angèle
Noëlle Norman as Virginie de Malempré
Génia Vaury as Madame Philippon
Jimmy Gaillard as Christian Bergas
Pierre Bertin as Archange
References
Bibliography
Bertin-Maghit, Jean Pierre. Le cinéma français sous Vichy: les films français de 1940 à 1944. Revue du Cinéma Albatros, 1980.
Rège, Philippe. Encyclopedia of French Film Directors, Volume 1. Scarecrow Press, 2009.
External links
1943 films
1940s French-language films
1943 comedy films
French comedy films
Films directed by Max de Vaucorbeil
Gaumont Film Company films
Films set in Paris
1940s French films
|
```go
package docker
import (
"context"
"encoding/json"
"net/http"
)
// VolumeUsageData represents usage data from the docker system api
// More Info Here path_to_url
type VolumeUsageData struct {
// The number of containers referencing this volume. This field
// is set to `-1` if the reference-count is not available.
//
// Required: true
RefCount int64 `json:"RefCount"`
// Amount of disk space used by the volume (in bytes). This information
// is only available for volumes created with the `"local"` volume
// driver. For volumes created with other volume drivers, this field
// is set to `-1` ("not available")
//
// Required: true
Size int64 `json:"Size"`
}
// ImageSummary represents data about what images are
// currently known to docker
// More Info Here path_to_url
type ImageSummary struct {
Containers int64 `json:"Containers"`
Created int64 `json:"Created"`
ID string `json:"Id"`
Labels map[string]string `json:"Labels"`
ParentID string `json:"ParentId"`
RepoDigests []string `json:"RepoDigests"`
RepoTags []string `json:"RepoTags"`
SharedSize int64 `json:"SharedSize"`
Size int64 `json:"Size"`
VirtualSize int64 `json:"VirtualSize"`
}
// DiskUsage holds information about what docker is using disk space on.
// More Info Here path_to_url
type DiskUsage struct {
LayersSize int64
Images []*ImageSummary
Containers []*APIContainers
Volumes []*Volume
}
// DiskUsageOptions only contains a context for canceling.
type DiskUsageOptions struct {
Context context.Context
}
// DiskUsage returns a *DiskUsage describing what docker is using disk on.
//
// More Info Here path_to_url
func (c *Client) DiskUsage(opts DiskUsageOptions) (*DiskUsage, error) {
path := "/system/df"
resp, err := c.do(http.MethodGet, path, doOptions{context: opts.Context})
if err != nil {
return nil, err
}
defer resp.Body.Close()
var du *DiskUsage
if err := json.NewDecoder(resp.Body).Decode(&du); err != nil {
return nil, err
}
return du, nil
}
```
|
```go
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package util
import (
"os"
"os/user"
"syscall"
"testing"
"github.com/blang/semver/v4"
"github.com/google/go-cmp/cmp"
)
func TestGetBinaryDownloadURL(t *testing.T) {
testData := []struct {
version string
platform string
expectedURL string
}{
{"v0.0.1", "linux", "path_to_url"},
{"v0.0.1", "darwin", "path_to_url"},
{"v0.0.1", "windows", "path_to_url"},
}
for _, tt := range testData {
url := GetBinaryDownloadURL(tt.version, tt.platform, "amd64")
if url != tt.expectedURL {
t.Fatalf("Expected '%s' but got '%s'", tt.expectedURL, url)
}
}
}
func TestCalculateSizeInMB(t *testing.T) {
testData := []struct {
size string
expectedNumber int
}{
{"1024kb", 1},
{"1024KB", 1},
{"1024mb", 1024},
{"1024b", 0},
{"1g", 1024},
}
for _, tt := range testData {
number, err := CalculateSizeInMB(tt.size)
if err != nil {
t.Fatalf("unexpected err: %v", err)
}
if number != tt.expectedNumber {
t.Fatalf("Expected '%d' but got '%d' from size '%s'", tt.expectedNumber, number, tt.size)
}
}
}
func TestParseKubernetesVersion(t *testing.T) {
version, err := ParseKubernetesVersion("v1.8.0-alpha.5")
if err != nil {
t.Fatalf("Error parsing version: %v", err)
}
if version.NE(semver.MustParse("1.8.0-alpha.5")) {
t.Errorf("Expected: %s, Actual:%s", "1.8.0-alpha.5", version)
}
}
func TestChownR(t *testing.T) {
testDir := t.TempDir()
if _, err := os.Create(testDir + "/TestChownR"); err != nil {
return
}
cases := []struct {
name string
uid int
gid int
expectedError bool
}{
{
name: "normal",
uid: os.Getuid(),
gid: os.Getgid(),
expectedError: false,
},
{
name: "invalid uid",
uid: 2147483647,
gid: os.Getgid(),
expectedError: true,
},
{
name: "invalid gid",
uid: os.Getuid(),
gid: 2147483647,
expectedError: true,
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
err := ChownR(testDir+"/TestChownR", c.uid, c.gid)
fileInfo, _ := os.Stat(testDir + "/TestChownR")
fileSys := fileInfo.Sys()
if (nil != err) != c.expectedError || ((false == c.expectedError) && (fileSys.(*syscall.Stat_t).Gid != uint32(c.gid) || fileSys.(*syscall.Stat_t).Uid != uint32(c.uid))) {
t.Errorf("expectedError: %v, got: %v", c.expectedError, err)
}
})
}
}
func TestMaybeChownDirRecursiveToMinikubeUser(t *testing.T) {
testDir := t.TempDir()
if _, err := os.Create(testDir + "/TestChownR"); nil != err {
return
}
if os.Getenv("CHANGE_MINIKUBE_NONE_USER") == "" {
t.Setenv("CHANGE_MINIKUBE_NONE_USER", "1")
}
if os.Getenv("SUDO_USER") == "" {
user, err := user.Current()
if nil != err {
t.Error("fail to get user")
}
t.Setenv("SUDO_USER", user.Username)
}
cases := []struct {
name string
dir string
expectedError bool
}{
{
name: "normal",
dir: testDir,
expectedError: false,
},
{
name: "invalid dir",
dir: "./utils_test",
expectedError: true,
},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
err := MaybeChownDirRecursiveToMinikubeUser(c.dir)
if (nil != err) != c.expectedError {
t.Errorf("expectedError: %v, got: %v", c.expectedError, err)
}
})
}
}
func TestRemoveDuplicateStrings(t *testing.T) {
testCases := []struct {
desc string
slice []string
want []string
}{
{
desc: "NoDuplicates",
slice: []string{"alpha", "bravo", "charlie"},
want: []string{"alpha", "bravo", "charlie"},
},
{
desc: "AdjacentDuplicates",
slice: []string{"alpha", "bravo", "bravo", "charlie"},
want: []string{"alpha", "bravo", "charlie"},
},
{
desc: "NonAdjacentDuplicates",
slice: []string{"alpha", "bravo", "alpha", "charlie"},
want: []string{"alpha", "bravo", "charlie"},
},
{
desc: "MultipleDuplicates",
slice: []string{"alpha", "bravo", "alpha", "alpha", "charlie", "charlie", "alpha", "bravo"},
want: []string{"alpha", "bravo", "charlie"},
},
{
desc: "UnsortedDuplicates",
slice: []string{"charlie", "bravo", "alpha", "bravo"},
want: []string{"charlie", "bravo", "alpha"},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
got := RemoveDuplicateStrings(tc.slice)
if diff := cmp.Diff(got, tc.want); diff != "" {
t.Errorf("RemoveDuplicateStrings(%v) = %v, want: %v", tc.slice, got, tc.want)
}
})
}
}
func TestMaskProxyPassword(t *testing.T) {
type dockerOptTest struct {
input string
output string
}
var tests = []dockerOptTest{
{
input: "cats",
output: "cats",
},
{
input: "myDockerOption=value",
output: "myDockerOption=value",
},
{
input: "path_to_url",
output: "path_to_url",
},
{
input: "path_to_url",
output: "path_to_url",
},
{
input: "path_to_url",
output: "path_to_url",
},
{
input: "path_to_url",
output: "path_to_url",
},
{
input: "path_to_url",
output: "path_to_url",
},
{
input: "path_to_url",
output: "path_to_url",
},
{
input: "path_to_url",
output: "path_to_url",
},
}
for _, test := range tests {
got := MaskProxyPassword(test.input)
if got != test.output {
t.Errorf("MaskProxyPassword(\"%v\"): got %v, expected %v", test.input, got, test.output)
}
}
}
func TestMaskProxyPasswordWithKey(t *testing.T) {
type dockerOptTest struct {
input string
output string
}
var tests = []dockerOptTest{
{
input: "cats",
output: "cats",
},
{
input: "myDockerOption=value",
output: "myDockerOption=value",
},
{
input: "http_proxy=path_to_url",
output: "HTTP_PROXY=path_to_url",
},
{
input: "https_proxy=path_to_url",
output: "HTTPS_PROXY=path_to_url",
},
{
input: "https_proxy=path_to_url",
output: "HTTPS_PROXY=path_to_url",
},
{
input: "http_proxy=path_to_url",
output: "HTTP_PROXY=path_to_url",
},
{
input: "http_proxy=path_to_url",
output: "HTTP_PROXY=path_to_url",
},
{
input: "http_proxy=path_to_url",
output: "HTTP_PROXY=path_to_url",
},
{
input: "https_proxy=path_to_url",
output: "HTTPS_PROXY=path_to_url",
},
}
for _, test := range tests {
got := MaskProxyPasswordWithKey(test.input)
if got != test.output {
t.Errorf("MaskProxyPasswordWithKey(\"%v\"): got %v, expected %v", test.input, got, test.output)
}
}
}
```
|
```java
/*
*
*
* path_to_url
*
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
*/
package com.haulmont.cuba.web.widgets.client.addons.popupbutton;
import com.vaadin.shared.communication.ServerRpc;
public interface PopupButtonServerRpc extends ServerRpc {
void setPopupVisible(boolean visible);
}
```
|
Twardowski (feminine: Twardowska, plural: Twardowscy) is a Polish surname. Tvardovsky, feminine: Tvardovskaya, are English transliterations from Russian. Notable people with the surname include:
Jan Twardowski (1915–2006), Polish priest and poet
Julia Twardowska (born 1995), Polish female volleyball player
Kasper Twardowski, (1592-ca. 1641), Polish poet
Kazimierz Twardowski (1866–1938), Polish philosopher and logician
Romuald Twardowski (b. 1930), Polish composer
Aleksandr Tvardovsky (1910–1971), Russian poet
Fictional characters
Pan Twardowski, a fictional character from Polish folklore and literature, who sold his soul in exchange for special powers
Pani Twardowska from the humorous ballad by Adam Mickiewicz
See also
Polish-language surnames
|
These are the official results of the Men's High Jump event at the 1995 IAAF World Championships in Gothenburg, Sweden. There were a total number of 35 participating athletes, with two qualifying groups and the final held on Tuesday August 8, 1995.
Schedule
All times are Central European Time (UTC+1)
Results
Qualifying round
Held on Sunday 1995-08-06
Qualification: Qualifying Performance 2.29 (Q) or at least 12 best performers (q) advance to the final.
Final
See also
1993 Men's World Championships High Jump
1994 Men's European Championships High Jump
1996 Men's Olympic High Jump
1997 Men's World Championships High Jump
1998 Men's European Championships High Jump
References
Results
Detailed results
H
High jump at the World Athletics Championships
|
Tall Armeni (, also Romanized as Tall Ārmenī and Tall Ārmanī) is a village in Vardasht Rural District, in the Central District of Semirom County, Isfahan Province, Iran. At the 2006 census, its population was 27, in 8 families.
References
Populated places in Semirom County
|
Ingoldsby is a rural locality in the Lockyer Valley Region, Queensland, Australia. In the , Ingoldsby had a population of 70 people.
History
Hessenburg Provisional School opened on 11 June 1894. On 1 January 1909, it became Hessenburg State School. Due to anti-German sentiment during World War I, the district was renamed Ingoldsby and in 1916 the school was renamed Ingoldsby State School. It closed on 9 August 1974. It was at 1128-1130 Ingoldsby Road ().
In the , Ingoldsby had a population of 70 people.
References
Further reading
Lockyer Valley Region
Localities in Queensland
|
Haratbar or Harat Bar () may refer to:
Harat Bar, Chaboksar, Rudsar County, Gilan Province
Harat Bar, Rahimabad, Rudsar County, Gilan Province
Haratbar, Mazandaran
|
```xml
import { Meta, StoryObj, moduleMetadata } from "@storybook/angular";
import { ButtonModule } from "../../button";
import { DialogTitleContainerDirective } from "../directives/dialog-title-container.directive";
import { IconDirective, SimpleDialogComponent } from "./simple-dialog.component";
export default {
title: "Component Library/Dialogs/Simple Dialog",
component: SimpleDialogComponent,
decorators: [
moduleMetadata({
imports: [ButtonModule],
declarations: [IconDirective, DialogTitleContainerDirective],
}),
],
parameters: {
design: {
type: "figma",
url: "path_to_url",
},
},
} as Meta;
type Story = StoryObj<SimpleDialogComponent & { useDefaultIcon: boolean }>;
export const Default: Story = {
render: (args) => ({
props: args,
template: `
<bit-simple-dialog>
<span bitDialogTitle>Alert Dialog</span>
<span bitDialogContent>Message Content</span>
<ng-container bitDialogFooter>
<button bitButton buttonType="primary">Yes</button>
<button bitButton buttonType="secondary">No</button>
</ng-container>
</bit-simple-dialog>
`,
}),
};
export const CustomIcon: Story = {
render: (args) => ({
props: args,
template: `
<bit-simple-dialog>
<i bitDialogIcon class="bwi bwi-star tw-text-3xl tw-text-success" aria-hidden="true"></i>
<span bitDialogTitle>Premium Subscription Available</span>
<span bitDialogContent> Message Content</span>
<ng-container bitDialogFooter>
<button bitButton buttonType="primary">Yes</button>
<button bitButton buttonType="secondary">No</button>
</ng-container>
</bit-simple-dialog>
`,
}),
};
export const ScrollingContent: Story = {
render: (args: SimpleDialogComponent) => ({
props: args,
template: `
<bit-simple-dialog>
<span bitDialogTitle>Alert Dialog</span>
<span bitDialogContent>
Message Content Message text goes here.<br />
<ng-container *ngFor="let _ of [].constructor(100)">
repeating lines of characters <br />
</ng-container>
end of sequence!
</span>
<ng-container bitDialogFooter>
<button bitButton buttonType="primary">Yes</button>
<button bitButton buttonType="secondary">No</button>
</ng-container>
</bit-simple-dialog>
`,
}),
args: {
useDefaultIcon: true,
},
};
export const TextOverflow: Story = {
render: (args) => ({
props: args,
template: `
<bit-simple-dialog>
<span bitDialogTitle>Alert your_sha256_hashogdialogdialog</span>
<span bitDialogContent>Message your_sha256_hashontentcontent</span>
<ng-container bitDialogFooter>
<button bitButton buttonType="primary">Yes</button>
<button bitButton buttonType="secondary">No</button>
</ng-container>
</bit-simple-dialog>
`,
}),
};
```
|
The Konawaruk River is a river in Potaro-Siparuni, Guyana. About 60 miles long, it is a tributary of the Essequibo River, joining it just south of the Potaro River mouth at .
About two miles from the juncture at the Essequibo, is Temple Bar falls.
Mining, especially for gold, was the primary industry along the river as early as 1900, and being mined by British Guiana Consolidated Enterprise Limited in the 1950s. In 2003, an assessment by United Development International "verified reserves of over 400,000 ounces of gold" in the claim encompassing the Konawaruk.
Pollution from extraction processes, including the use of missile dredges, has had a severe effect on the ecology of the river and environmentalists have considered it "dead" for its inability to support wildlife. Illegal dredging operations are a constant threat.
References
Rivers of Guyana
|
```smalltalk
using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
namespace NPBehave
{
public class DebuggerWindow : EditorWindow
{
private const int nestedPadding = 10;
public static Transform selectedObject;
public static Debugger selectedDebugger;
private Vector2 scrollPosition = Vector2.zero;
private GUIStyle smallTextStyle, nodeCapsuleGray, nodeCapsuleFailed, nodeCapsuleStopRequested;
private GUIStyle nestedBoxStyle;
private Color defaultColor;
Dictionary<string, string> nameToTagString;
Dictionary<Operator, string> operatorToString;
[MenuItem("Window/NPBehave Debugger")]
public static void ShowWindow()
{
DebuggerWindow window = (DebuggerWindow)EditorWindow.GetWindow(typeof(DebuggerWindow), false, "NPBehave Debugger");
window.Show();
}
public void Init()
{
// Debug.Log("AWAKE !!");
operatorToString = new Dictionary<Operator, string>();
operatorToString[Operator.IS_SET] = "?=";
operatorToString[Operator.IS_NOT_SET] = "?!=";
operatorToString[Operator.IS_EQUAL] = "==";
operatorToString[Operator.IS_NOT_EQUAL] = "!=";
operatorToString[Operator.IS_GREATER_OR_EQUAL] = ">=";
operatorToString[Operator.IS_GREATER] = ">";
operatorToString[Operator.IS_SMALLER_OR_EQUAL] = "<=";
operatorToString[Operator.IS_SMALLER] = "<";
operatorToString[Operator.ALWAYS_TRUE] = "ALWAYS_TRUE";
nameToTagString = new Dictionary<string, string>();
nameToTagString["Selector"] = "?";
nameToTagString["Sequence"] = "->";
// To do add more
nestedBoxStyle = new GUIStyle();
nestedBoxStyle.margin = new RectOffset(nestedPadding, 0, 0, 0);
smallTextStyle = new GUIStyle();
smallTextStyle.font = EditorStyles.miniFont;
// nodeTextStyle = new GUIStyle(EditorStyles.label);
nodeCapsuleGray = (GUIStyle)"helpbox";
nodeCapsuleGray.normal.textColor = Color.black;
nodeCapsuleFailed = new GUIStyle(nodeCapsuleGray);
nodeCapsuleFailed.normal.textColor = Color.red;
nodeCapsuleStopRequested = new GUIStyle(nodeCapsuleGray);
nodeCapsuleStopRequested.normal.textColor = new Color(0.7f, 0.7f, 0.0f);
defaultColor = EditorGUIUtility.isProSkin ? Color.white : Color.black;
}
public void OnSelectionChange()
{
selectedObject = Selection.activeTransform;
if (selectedObject != null) selectedDebugger = selectedObject.GetComponentInChildren<Debugger>();
Repaint();
}
public void OnGUI()
{
if (nameToTagString == null) Init(); // Weird recompile bug fix
GUI.color = defaultColor;
GUILayout.Toggle(false, "NPBehave Debugger", GUI.skin.FindStyle("LODLevelNotifyText"));
GUI.color = Color.white;
if (!Application.isPlaying)
{
EditorGUILayout.HelpBox("Cannot use this utility in Editor Mode", MessageType.Info);
return;
}
var newDebugger = (Debugger)EditorGUILayout.ObjectField("Selected Debugger:", selectedDebugger, typeof(Debugger), true);
if (newDebugger != selectedDebugger)
{
selectedDebugger = newDebugger;
if (newDebugger != null) selectedObject = selectedDebugger.transform;
}
if (selectedObject == null)
{
EditorGUILayout.HelpBox("Please select an object", MessageType.Info);
return;
}
if (selectedDebugger == null)
{
EditorGUILayout.HelpBox("This object does not contain a debugger component", MessageType.Info);
return;
}
else if (selectedDebugger.BehaviorTree == null)
{
EditorGUILayout.HelpBox("BehavorTree is null", MessageType.Info);
return;
}
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
GUILayout.BeginHorizontal();
DrawBlackboardKeyAndValues("Blackboard:", selectedDebugger.BehaviorTree.Blackboard);
if (selectedDebugger.CustomStats.Keys.Count > 0)
{
DrawBlackboardKeyAndValues("Custom Stats:", selectedDebugger.CustomStats);
}
DrawStats(selectedDebugger);
GUILayout.EndHorizontal();
GUILayout.Space(10);
if (Time.timeScale <= 2.0f)
{
GUILayout.BeginHorizontal();
GUILayout.Label("TimeScale: ");
Time.timeScale = EditorGUILayout.Slider(Time.timeScale, 0.0f, 2.0f);
GUILayout.EndHorizontal();
}
DrawBehaviourTree(selectedDebugger);
GUILayout.Space(10);
EditorGUILayout.EndScrollView();
Repaint();
}
private void DrawStats(Debugger debugger)
{
EditorGUILayout.BeginVertical();
{
GUILayout.Label("Stats:", EditorStyles.boldLabel);
Root behaviorTree = debugger.BehaviorTree;
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
{
DrawKeyValue("Total Starts:", behaviorTree.TotalNumStartCalls.ToString());
DrawKeyValue("Total Stops:", behaviorTree.TotalNumStopCalls.ToString());
DrawKeyValue("Total Stopped:", behaviorTree.TotalNumStoppedCalls.ToString());
DrawKeyValue("Active Timers: ", behaviorTree.Clock.NumTimers.ToString());
DrawKeyValue("Timer Pool Size: ", behaviorTree.Clock.DebugPoolSize.ToString());
DrawKeyValue("Active Update Observers: ", behaviorTree.Clock.NumUpdateObservers.ToString());
DrawKeyValue("Active Blackboard Observers: ", behaviorTree.Blackboard.NumObservers.ToString());
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndVertical();
}
private void DrawBlackboardKeyAndValues(string label, Blackboard blackboard)
{
EditorGUILayout.BeginVertical();
{
GUILayout.Label(label, EditorStyles.boldLabel);
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
{
List<string> keys = blackboard.Keys;
foreach (string key in keys)
{
DrawKeyValue(key, blackboard.Get(key).ToString());
}
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndVertical();
}
private void DrawKeyValue(string key, string value)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label(key, smallTextStyle);
GUILayout.FlexibleSpace();
GUILayout.Label(value, smallTextStyle);
EditorGUILayout.EndHorizontal();
}
private void DrawBehaviourTree(Debugger debugger)
{
EditorGUILayout.BeginVertical();
{
GUILayout.Label("Behaviour Tree:", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical(nestedBoxStyle);
DrawNodeTree(debugger.BehaviorTree, 0);
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndVertical();
}
private void DrawNodeTree(Node node, int depth = 0, bool firstNode = true, float lastYPos = 0f)
{
bool decorator = node is Decorator && !(node is Root);
bool parentIsDecorator = (node.ParentNode is Decorator);
GUI.color = (node.CurrentState == Node.State.ACTIVE) ? new Color(1f, 1f, 1f, 1f) : new Color(1f, 1f, 1f, 0.3f);
if (!parentIsDecorator)
{
DrawSpacing();
}
bool drawConnected = !decorator || (decorator && ((Container)node).Collapse);
DrawNode(node, depth, drawConnected);
Rect rect = GUILayoutUtility.GetLastRect();
// Set intial line position
if (firstNode)
{
lastYPos = rect.yMin;
}
// Draw the lines
Handles.BeginGUI();
// Container collapsing
Container container = node as Container;
Rect interactionRect = new Rect(rect);
interactionRect.width = 100;
interactionRect.y += 8;
if (container != null && Event.current.type == EventType.MouseUp && Event.current.button == 0 && interactionRect.Contains(Event.current.mousePosition))
{
container.Collapse = !container.Collapse;
Event.current.Use();
}
Handles.color = new Color(0f, 0f, 0f, 1f);
if (!decorator)
{
Handles.DrawLine(new Vector2(rect.xMin - 5, lastYPos + 4), new Vector2(rect.xMin - 5, rect.yMax - 4));
}
else
{
Handles.DrawLine(new Vector2(rect.xMin - 5, lastYPos + 4), new Vector2(rect.xMin - 5, rect.yMax + 6));
}
Handles.EndGUI();
if(decorator) depth++;
if (node is Container && !((Container)node).Collapse)
{
if(!decorator) EditorGUILayout.BeginVertical(nestedBoxStyle);
Node[] children = (node as Container).DebugChildren;
if (children == null)
{
GUILayout.Label("CHILDREN ARE NULL");
}
else
{
lastYPos = rect.yMin + 16; // Set new Line position
for (int i = 0; i < children.Length; i++)
{
DrawNodeTree(children[i], depth, i == 0, lastYPos);
}
}
if(!decorator) EditorGUILayout.EndVertical();
}
}
private void DrawSpacing()
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Space();
EditorGUILayout.EndHorizontal();
}
private void DrawNode(Node node, int depth, bool connected)
{
float tStopRequested = Mathf.Lerp(0.85f, 0.25f, 2.0f * (Time.time - node.DebugLastStopRequestAt));
float tStopped = Mathf.Lerp(0.85f, 0.25f, 2.0f * (Time.time - node.DebugLastStoppedAt));
bool inactive = node.CurrentState != Node.State.ACTIVE;
float alpha = inactive ? Mathf.Max(0.35f, Mathf.Pow(tStopped, 1.5f)) : 1.0f;
bool failed = (tStopped > 0.25f && tStopped < 1.0f && !node.DebugLastResult && inactive);
bool stopRequested = (tStopRequested > 0.25f && tStopRequested < 1.0f && inactive);
EditorGUILayout.BeginHorizontal();
{
GUI.color = new Color(1f, 1f, 1f, alpha);
string tagName;
GUIStyle tagStyle = stopRequested ? nodeCapsuleStopRequested : (failed ? nodeCapsuleFailed : nodeCapsuleGray);
bool drawLabel = !string.IsNullOrEmpty(node.Label);
string label = node.Label;
if (node is BlackboardCondition)
{
BlackboardCondition nodeBlackboardCond = node as BlackboardCondition;
tagName = nodeBlackboardCond.Key + " " + operatorToString[nodeBlackboardCond.Operator] + " " + nodeBlackboardCond.Value;
GUI.backgroundColor = new Color(0.9f, 0.9f, 0.6f);
}
else
{
if (node is Composite) GUI.backgroundColor = new Color(0.3f, 1f, 0.1f);
if (node is Decorator) GUI.backgroundColor = new Color(0.3f, 1f, 1f);
if (node is Task) GUI.backgroundColor = new Color(0.5f, 0.1f, 0.5f);
if (node is ObservingDecorator) GUI.backgroundColor = new Color(0.9f, 0.9f, 0.6f);
nameToTagString.TryGetValue(node.Name, out tagName);
}
if ((node is Container) && ((Container)node).Collapse)
{
if (!drawLabel)
{
drawLabel = true;
label = tagName;
}
tagName = "...";
GUI.backgroundColor = new Color(0.4f, 0.4f, 0.4f);
}
if (string.IsNullOrEmpty(tagName)) tagName = node.Name;
if (!drawLabel) {
GUILayout.Label(tagName, tagStyle);
} else {
GUILayout.Label("("+tagName+") " + label, tagStyle);
// Reset background color
GUI.backgroundColor = Color.white;
}
GUILayout.FlexibleSpace();
// Draw Buttons
if (node.CurrentState == Node.State.ACTIVE)
{
if (GUILayout.Button("stop", EditorStyles.miniButton))
{
node.Stop();
}
}
else if (node is Root)
{
GUI.color = new Color(1f, 1f, 1f, 1f);
if (GUILayout.Button("start", EditorStyles.miniButton))
{
node.Start();
}
GUI.color = new Color(1f, 1f, 1f, 0.3f);
}
// Draw Stats
GUILayout.Label((node.DebugNumStoppedCalls > 0 ? node.DebugLastResult.ToString() : "") + " | " + node.DebugNumStartCalls + " , " + node.DebugNumStopCalls + " , " + node.DebugNumStoppedCalls, smallTextStyle);
}
EditorGUILayout.EndHorizontal();
// Draw the lines
if (connected)
{
Rect rect = GUILayoutUtility.GetLastRect();
Handles.color = new Color(0f, 0f, 0f, 1f);
Handles.BeginGUI();
float midY = 4 + (rect.yMin + rect.yMax) / 2f;
Handles.DrawLine(new Vector2(rect.xMin - 5, midY), new Vector2(rect.xMin, midY));
Handles.EndGUI();
}
}
}
}
```
|
The Architectural Conservation Award () is given by the in recognition of architectural conservation efforts by both the public and private sectors in Thailand. The awards, first given in 1982 and held annually since 2004, are presented to multiple winners in three categories, namely: buildings, people/organizations, and vernacular communities.
List of recipients
Buildings
Vernacular communities
Buildings worthy of conservation
See also
Architecture of Thailand
Cultural heritage conservation in Thailand
References
Heritage registers in Thailand
Architecture awards
Architecture in Thailand
|
An acceptability judgment task, also called acceptability rating task, is a common method in empirical linguistics to gather information about the internal grammar of speakers of a language.
Acceptability and grammaticality
The goal of acceptability rating studies is to gather insights into the mental grammars of participants. As the grammaticality of a linguistic construction is an abstract construct that cannot be accessed directly, this type of tasks is usually not called grammaticality, but acceptability judgment. This can be compared to intelligence. Intelligence is an abstract construct that cannot be measured directly. What can be measured are the outcomes of specific test items. The result of one item, however, is not very telling. Instead, IQ tests consist of several items building a score. Similarly, in acceptability rating studies, grammatical constructions are measured through several items, i.e., sentences to be rated. This is also done to ensure that participants do not rate the meaning of a particular sentence.
The difference between acceptability and grammaticality is linked to the distinction between performance and competence in generative grammar.
Types
Several different types of acceptability rating tasks are used in linguistics. The most common tasks use Likert scales. Forced choice and yes-no rating tasks are also common. Besides these classical test types, there are other, methods like thermometer judgments or magnitude estimation which have been argued to be more difficult to process for participants, however.
Further reading
Bross, F. (2019): Acceptability Ratings in Linguistics: A Practical Guide to Grammaticality Judgments, Data Collection, and Statistical Analysis. Version 1.0. Mimeo.
Myers, J. (2009): Syntactic Judgment Experiments. In: Language and Linguistics Compass, 3(1), 406-423.
Podesva, R. J. & Sharma, D. (eds.) (2013): Research Methods in Linguistics. Cambridge: Cambridge University Press.
Schütze, C. T. (2016): The Empirical Base of Linguistics. Grammaticality Judgments and Linguistic Methodology. Berlin: Language Science Press.
Sprouse, J. & Almeida, D. (2017): Design sensitivity and statistical power in acceptability judgment experiments. In: Glossa. A Journal of General Linguistics, 2(1), 1-32.
Sprouse, J., Schütze, C. T. & Almeida, D. (2013): A comparison of informal and formal acceptability judgments using a random sample from Linguistic Inquiry 2001-2010. In: Lingua, 134, 219-248.
References
Psycholinguistics
Quantitative linguistics
Linguistic research
|
```xml
import * as React from 'react';
import { Dropdown } from '@fluentui/react-northstar';
const inputItems = [
'Robert Tolbert',
'Wanda Howard',
'Tim Deboer',
'Amanda Brady',
'Ashley McCarthy',
'Cameron Evans',
'Carlos Slattery',
'Carole Poland',
'Robin Counts',
];
const DropdownExampleSearchMultipleFluid = () => (
<Dropdown
multiple
search
fluid
items={inputItems}
placeholder="Start typing a name"
getA11ySelectionMessage={getA11ySelectionMessage}
noResultsMessage="We couldn't find any matches."
a11ySelectedItemsMessage="Press Delete or Backspace to remove"
/>
);
const getA11ySelectionMessage = {
onAdd: item => `${item} selected. Press left or right arrow keys to navigate selected items.`,
onRemove: item => `${item} has been removed.`,
};
export default DropdownExampleSearchMultipleFluid;
```
|
```c
/*
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <sys/param.h>
#include "esp_heap_caps.h"
#include "esp_rom_sys.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "unity.h"
#include "ccomp_timer.h"
#include "esp_async_memcpy.h"
#include "soc/soc_caps.h"
#include "hal/dma_types.h"
#define IDF_LOG_PERFORMANCE(item, value_fmt, value, ...) \
printf("[Performance][%s]: " value_fmt "\n", item, value, ##__VA_ARGS__)
#define ALIGN_UP(addr, align) (((addr) + (align)-1) & ~((align)-1))
#define ALIGN_DOWN(size, align) ((size) & ~((align) - 1))
#if CONFIG_IDF_TARGET_ESP32P4
#define TEST_MEMCPY_BUFFER_SIZE_MUST_ALIGN_CACHE 1
#endif
typedef struct {
uint32_t seed;
size_t buffer_size;
size_t copy_size;
uint8_t *src_buf;
uint8_t *dst_buf;
uint8_t *from_addr;
uint8_t *to_addr;
uint32_t align;
uint32_t offset;
bool src_in_psram;
bool dst_in_psram;
} memcpy_testbench_context_t;
static void async_memcpy_setup_testbench(memcpy_testbench_context_t *test_context)
{
srand(test_context->seed);
printf("allocating memory buffer...\r\n");
size_t buffer_size = test_context->buffer_size;
size_t copy_size = buffer_size;
uint8_t *src_buf = NULL;
uint8_t *dst_buf = NULL;
uint8_t *from_addr = NULL;
uint8_t *to_addr = NULL;
uint32_t mem_caps = test_context->src_in_psram ? MALLOC_CAP_SPIRAM | MALLOC_CAP_DMA | MALLOC_CAP_8BIT : MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA | MALLOC_CAP_8BIT ;
src_buf = heap_caps_aligned_calloc(test_context->align, 1, buffer_size, mem_caps);
TEST_ASSERT_NOT_NULL(src_buf);
mem_caps = test_context->dst_in_psram ? MALLOC_CAP_SPIRAM | MALLOC_CAP_DMA | MALLOC_CAP_8BIT : MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA | MALLOC_CAP_8BIT ;
dst_buf = heap_caps_aligned_calloc(test_context->align, 1, buffer_size, mem_caps);
TEST_ASSERT_NOT_NULL(dst_buf);
// adding extra offset
from_addr = src_buf + test_context->offset;
to_addr = dst_buf;
copy_size -= test_context->offset;
copy_size &= ~(test_context->align - 1);
printf("...to copy size %zu Bytes, from @%p, to @%p\r\n", copy_size, from_addr, to_addr);
printf("fill src buffer with random data\r\n");
for (int i = 0; i < copy_size; i++) {
from_addr[i] = rand() % 256;
}
// save context
test_context->copy_size = copy_size;
test_context->src_buf = src_buf;
test_context->dst_buf = dst_buf;
test_context->from_addr = from_addr;
test_context->to_addr = to_addr;
}
static void async_memcpy_verify_and_clear_testbench(uint32_t seed, uint32_t copy_size, uint8_t *src_buf, uint8_t *dst_buf, uint8_t *from_addr, uint8_t *to_addr)
{
srand(seed);
// check if source date has been copied to destination and source data not broken
for (int i = 0; i < copy_size; i++) {
TEST_ASSERT_EQUAL_MESSAGE(rand() % 256, from_addr[i], "source data doesn't match generator data");
}
srand(seed);
for (int i = 0; i < copy_size; i++) {
TEST_ASSERT_EQUAL_MESSAGE(rand() % 256, to_addr[i], "destination data doesn't match source data");
}
free(src_buf);
free(dst_buf);
}
TEST_CASE("memory copy the same buffer with different content", "[async mcp]")
{
async_memcpy_config_t config = ASYNC_MEMCPY_DEFAULT_CONFIG();
async_memcpy_handle_t driver = NULL;
TEST_ESP_OK(esp_async_memcpy_install(&config, &driver));
uint8_t *sbuf = heap_caps_aligned_calloc(4, 1, 256, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
uint8_t *dbuf = heap_caps_aligned_calloc(4, 1, 256, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
TEST_ASSERT_NOT_NULL(sbuf);
TEST_ASSERT_NOT_NULL(dbuf);
for (int j = 0; j < 20; j++) {
TEST_ESP_OK(esp_async_memcpy(driver, dbuf, sbuf, 256, NULL, NULL));
vTaskDelay(pdMS_TO_TICKS(10));
for (int i = 0; i < 256; i++) {
if (sbuf[i] != dbuf[i]) {
printf("location[%d]:s=%d,d=%d\r\n", i, sbuf[i], dbuf[i]);
TEST_FAIL_MESSAGE("destination data doesn't match source data");
} else {
sbuf[i] += 1;
}
}
}
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
free(sbuf);
free(dbuf);
}
static void test_memory_copy_one_by_one(async_memcpy_handle_t driver)
{
uint32_t aligned_test_buffer_size[] = {256, 512, 1024, 2048, 4096};
memcpy_testbench_context_t test_context = {
.align = 4,
};
for (int i = 0; i < sizeof(aligned_test_buffer_size) / sizeof(aligned_test_buffer_size[0]); i++) {
test_context.buffer_size = aligned_test_buffer_size[i];
test_context.seed = i;
test_context.offset = 0;
async_memcpy_setup_testbench(&test_context);
TEST_ESP_OK(esp_async_memcpy(driver, test_context.to_addr, test_context.from_addr, test_context.copy_size, NULL, NULL));
vTaskDelay(pdMS_TO_TICKS(10));
async_memcpy_verify_and_clear_testbench(test_context.seed, test_context.copy_size, test_context.src_buf,
test_context.dst_buf, test_context.from_addr, test_context.to_addr);
}
#if !TEST_MEMCPY_BUFFER_SIZE_MUST_ALIGN_CACHE
uint32_t unaligned_test_buffer_size[] = {255, 511, 1023, 2047, 4095, 5011};
for (int i = 0; i < sizeof(unaligned_test_buffer_size) / sizeof(unaligned_test_buffer_size[0]); i++) {
// Test different align edge
for (int off = 0; off < 4; off++) {
test_context.buffer_size = unaligned_test_buffer_size[i];
test_context.seed = i;
test_context.offset = off;
async_memcpy_setup_testbench(&test_context);
TEST_ESP_OK(esp_async_memcpy(driver, test_context.to_addr, test_context.from_addr, test_context.copy_size, NULL, NULL));
vTaskDelay(pdMS_TO_TICKS(10));
async_memcpy_verify_and_clear_testbench(test_context.seed, test_context.copy_size, test_context.src_buf,
test_context.dst_buf, test_context.from_addr, test_context.to_addr);
}
}
#endif
}
TEST_CASE("memory copy by DMA one by one", "[async mcp]")
{
async_memcpy_config_t config = {
.backlog = 4,
};
async_memcpy_handle_t driver = NULL;
#if SOC_AHB_GDMA_SUPPORTED
printf("Testing memory by AHB GDMA\r\n");
TEST_ESP_OK(esp_async_memcpy_install_gdma_ahb(&config, &driver));
test_memory_copy_one_by_one(driver);
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
#endif // SOC_AHB_GDMA_SUPPORTED
#if SOC_AXI_GDMA_SUPPORTED
printf("Testing memory by AXI GDMA\r\n");
TEST_ESP_OK(esp_async_memcpy_install_gdma_axi(&config, &driver));
test_memory_copy_one_by_one(driver);
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
#endif // SOC_AXI_GDMA_SUPPORTED
#if SOC_CP_DMA_SUPPORTED
printf("Testing memory by CP DMA\r\n");
TEST_ESP_OK(esp_async_memcpy_install_cpdma(&config, &driver));
test_memory_copy_one_by_one(driver);
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
#endif // SOC_CP_DMA_SUPPORTED
}
static bool test_async_memcpy_cb_v1(async_memcpy_handle_t mcp_hdl, async_memcpy_event_t *event, void *cb_args)
{
SemaphoreHandle_t sem = (SemaphoreHandle_t)cb_args;
BaseType_t high_task_wakeup = pdFALSE;
xSemaphoreGiveFromISR(sem, &high_task_wakeup);
return high_task_wakeup == pdTRUE;
}
TEST_CASE("memory copy done callback", "[async mcp]")
{
async_memcpy_config_t config = {
// all default
};
async_memcpy_handle_t driver = NULL;
TEST_ESP_OK(esp_async_memcpy_install(&config, &driver));
uint8_t *src_buf = heap_caps_aligned_calloc(4, 1, 256, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
uint8_t *dst_buf = heap_caps_aligned_calloc(4, 1, 256, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
TEST_ASSERT_NOT_NULL(src_buf);
TEST_ASSERT_NOT_NULL(dst_buf);
SemaphoreHandle_t sem = xSemaphoreCreateBinary();
TEST_ESP_OK(esp_async_memcpy(driver, dst_buf, src_buf, 256, test_async_memcpy_cb_v1, sem));
TEST_ASSERT_EQUAL(pdTRUE, xSemaphoreTake(sem, pdMS_TO_TICKS(1000)));
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
free(src_buf);
free(dst_buf);
vSemaphoreDelete(sem);
}
TEST_CASE("memory copy by DMA on the fly", "[async mcp]")
{
async_memcpy_config_t config = ASYNC_MEMCPY_DEFAULT_CONFIG();
async_memcpy_handle_t driver = NULL;
TEST_ESP_OK(esp_async_memcpy_install(&config, &driver));
uint32_t aligned_test_buffer_size[] = {512, 1024, 2048, 4096, 4608};
memcpy_testbench_context_t test_context[5] = {
[0 ... 4] = {
.align = 4,
}
};
// Aligned case
for (int i = 0; i < sizeof(aligned_test_buffer_size) / sizeof(aligned_test_buffer_size[0]); i++) {
test_context[i].seed = i;
test_context[i].buffer_size = aligned_test_buffer_size[i];
async_memcpy_setup_testbench(&test_context[i]);
}
for (int i = 0; i < sizeof(aligned_test_buffer_size) / sizeof(aligned_test_buffer_size[0]); i++) {
TEST_ESP_OK(esp_async_memcpy(driver, test_context[i].to_addr, test_context[i].from_addr, test_context[i].copy_size, NULL, NULL));
}
for (int i = 0; i < sizeof(aligned_test_buffer_size) / sizeof(aligned_test_buffer_size[0]); i++) {
async_memcpy_verify_and_clear_testbench(i, test_context[i].copy_size, test_context[i].src_buf, test_context[i].dst_buf, test_context[i].from_addr, test_context[i].to_addr);
}
#if !TEST_MEMCPY_BUFFER_SIZE_MUST_ALIGN_CACHE
uint32_t unaligned_test_buffer_size[] = {511, 1023, 2047, 4095, 5011};
// Non-aligned case
for (int i = 0; i < sizeof(unaligned_test_buffer_size) / sizeof(unaligned_test_buffer_size[0]); i++) {
test_context[i].seed = i;
test_context[i].buffer_size = unaligned_test_buffer_size[i];
test_context[i].offset = 3;
async_memcpy_setup_testbench(&test_context[i]);
}
for (int i = 0; i < sizeof(unaligned_test_buffer_size) / sizeof(unaligned_test_buffer_size[0]); i++) {
TEST_ESP_OK(esp_async_memcpy(driver, test_context[i].to_addr, test_context[i].from_addr, test_context[i].copy_size, NULL, NULL));
}
for (int i = 0; i < sizeof(unaligned_test_buffer_size) / sizeof(unaligned_test_buffer_size[0]); i++) {
async_memcpy_verify_and_clear_testbench(i, test_context[i].copy_size, test_context[i].src_buf, test_context[i].dst_buf, test_context[i].from_addr, test_context[i].to_addr);
}
#endif
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
}
#define TEST_ASYNC_MEMCPY_BENCH_COUNTS (8)
static int s_count = 0;
static IRAM_ATTR bool test_async_memcpy_isr_cb(async_memcpy_handle_t mcp_hdl, async_memcpy_event_t *event, void *cb_args)
{
SemaphoreHandle_t sem = (SemaphoreHandle_t)cb_args;
BaseType_t high_task_wakeup = pdFALSE;
s_count++;
if (s_count == TEST_ASYNC_MEMCPY_BENCH_COUNTS) {
xSemaphoreGiveFromISR(sem, &high_task_wakeup);
}
return high_task_wakeup == pdTRUE;
}
static void memcpy_performance_test(uint32_t buffer_size)
{
SemaphoreHandle_t sem = xSemaphoreCreateBinary();
async_memcpy_config_t config = ASYNC_MEMCPY_DEFAULT_CONFIG();
config.backlog = (buffer_size / DMA_DESCRIPTOR_BUFFER_MAX_SIZE + 1) * TEST_ASYNC_MEMCPY_BENCH_COUNTS;
config.dma_burst_size = 64; // set a big burst size for performance
async_memcpy_handle_t driver = NULL;
int64_t elapse_us = 0;
float throughput = 0.0;
TEST_ESP_OK(esp_async_memcpy_install(&config, &driver));
// 1. SRAM->SRAM
memcpy_testbench_context_t test_context = {
.align = config.dma_burst_size,
.buffer_size = buffer_size,
.src_in_psram = false,
.dst_in_psram = false,
};
async_memcpy_setup_testbench(&test_context);
s_count = 0;
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
TEST_ESP_OK(esp_async_memcpy(driver, test_context.to_addr, test_context.from_addr, test_context.copy_size, test_async_memcpy_isr_cb, sem));
}
// wait for done semaphore
TEST_ASSERT_EQUAL(pdTRUE, xSemaphoreTake(sem, pdMS_TO_TICKS(1000)));
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("DMA_COPY", "%.2f MB/s, dir: SRAM->SRAM, size: %zu Bytes", throughput, test_context.buffer_size);
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
memcpy(test_context.to_addr, test_context.from_addr, test_context.buffer_size);
}
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("CPU_COPY", "%.2f MB/s, dir: SRAM->SRAM, size: %zu Bytes", throughput, test_context.buffer_size);
async_memcpy_verify_and_clear_testbench(test_context.seed, test_context.copy_size, test_context.src_buf, test_context.dst_buf, test_context.from_addr, test_context.to_addr);
#if SOC_AHB_GDMA_SUPPORT_PSRAM
// 2. PSRAM->PSRAM
test_context.src_in_psram = true;
test_context.dst_in_psram = true;
async_memcpy_setup_testbench(&test_context);
s_count = 0;
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
TEST_ESP_OK(esp_async_memcpy(driver, test_context.to_addr, test_context.from_addr, test_context.copy_size, test_async_memcpy_isr_cb, sem));
}
// wait for done semaphore
TEST_ASSERT_EQUAL(pdTRUE, xSemaphoreTake(sem, pdMS_TO_TICKS(1000)));
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("DMA_COPY", "%.2f MB/s, dir: PSRAM->PSRAM, size: %zu Bytes", throughput, test_context.buffer_size);
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
memcpy(test_context.to_addr, test_context.from_addr, test_context.buffer_size);
}
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("CPU_COPY", "%.2f MB/s, dir: PSRAM->PSRAM, size: %zu Bytes", throughput, test_context.buffer_size);
async_memcpy_verify_and_clear_testbench(test_context.seed, test_context.copy_size, test_context.src_buf, test_context.dst_buf, test_context.from_addr, test_context.to_addr);
// 3. PSRAM->SRAM
test_context.src_in_psram = true;
test_context.dst_in_psram = false;
async_memcpy_setup_testbench(&test_context);
s_count = 0;
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
TEST_ESP_OK(esp_async_memcpy(driver, test_context.to_addr, test_context.from_addr, test_context.copy_size, test_async_memcpy_isr_cb, sem));
}
// wait for done semaphore
TEST_ASSERT_EQUAL(pdTRUE, xSemaphoreTake(sem, pdMS_TO_TICKS(1000)));
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("DMA_COPY", "%.2f MB/s, dir: PSRAM->SRAM, size: %zu Bytes", throughput, test_context.buffer_size);
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
memcpy(test_context.to_addr, test_context.from_addr, test_context.buffer_size);
}
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("CPU_COPY", "%.2f MB/s, dir: PSRAM->SRAM, size: %zu Bytes", throughput, test_context.buffer_size);
async_memcpy_verify_and_clear_testbench(test_context.seed, test_context.copy_size, test_context.src_buf, test_context.dst_buf, test_context.from_addr, test_context.to_addr);
// 4. SRAM->PSRAM
test_context.src_in_psram = false;
test_context.dst_in_psram = true;
async_memcpy_setup_testbench(&test_context);
s_count = 0;
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
TEST_ESP_OK(esp_async_memcpy(driver, test_context.to_addr, test_context.from_addr, test_context.copy_size, test_async_memcpy_isr_cb, sem));
}
// wait for done semaphore
TEST_ASSERT_EQUAL(pdTRUE, xSemaphoreTake(sem, pdMS_TO_TICKS(1000)));
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("DMA_COPY", "%.2f MB/s, dir: SRAM->PSRAM, size: %zu Bytes", throughput, test_context.buffer_size);
ccomp_timer_start();
for (int i = 0; i < TEST_ASYNC_MEMCPY_BENCH_COUNTS; i++) {
memcpy(test_context.to_addr, test_context.from_addr, test_context.buffer_size);
}
elapse_us = ccomp_timer_stop();
throughput = (float)test_context.buffer_size * 1e6 * TEST_ASYNC_MEMCPY_BENCH_COUNTS / 1024 / 1024 / elapse_us;
IDF_LOG_PERFORMANCE("CPU_COPY", "%.2f MB/s, dir: SRAM->PSRAM, size: %zu Bytes", throughput, test_context.buffer_size);
async_memcpy_verify_and_clear_testbench(test_context.seed, test_context.copy_size, test_context.src_buf, test_context.dst_buf, test_context.from_addr, test_context.to_addr);
#endif
TEST_ESP_OK(esp_async_memcpy_uninstall(driver));
vSemaphoreDelete(sem);
}
TEST_CASE("memory copy performance test 40KB", "[async mcp]")
{
memcpy_performance_test(40 * 1024);
}
TEST_CASE("memory copy performance test 4KB", "[async mcp]")
{
memcpy_performance_test(4 * 1024);
}
```
|
```php
<?php
/*
* This file is part of Psy Shell.
*
* (c) 2012-2015 Justin Hileman
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Psy\TabCompletion\Matcher;
/**
* Abstract tab completion Matcher.
*
* @author Marc Garcia <markcial@gmail.com>
*/
abstract class AbstractMatcher
{
/** Syntax types */
const CONSTANT_SYNTAX = '^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$';
const VAR_SYNTAX = '^\$[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$';
const MISC_OPERATORS = '+-*/^|&';
/** Token values */
const T_OPEN_TAG = 'T_OPEN_TAG';
const T_VARIABLE = 'T_VARIABLE';
const T_OBJECT_OPERATOR = 'T_OBJECT_OPERATOR';
const T_DOUBLE_COLON = 'T_DOUBLE_COLON';
const T_NEW = 'T_NEW';
const T_CLONE = 'T_CLONE';
const T_NS_SEPARATOR = 'T_NS_SEPARATOR';
const T_STRING = 'T_STRING';
const T_WHITESPACE = 'T_WHITESPACE';
const T_AND_EQUAL = 'T_AND_EQUAL';
const T_BOOLEAN_AND = 'T_BOOLEAN_AND';
const T_BOOLEAN_OR = 'T_BOOLEAN_OR';
const T_ENCAPSED_AND_WHITESPACE = 'T_ENCAPSED_AND_WHITESPACE';
const T_REQUIRE = 'T_REQUIRE';
const T_REQUIRE_ONCE = 'T_REQUIRE_ONCE';
const T_INCLUDE = 'T_INCLUDE';
const T_INCLUDE_ONCE = 'T_INCLUDE_ONCE';
/**
* Check whether this matcher can provide completions for $tokens.
*
* @param array $tokens Tokenized readline input.
*
* @return bool
*/
public function hasMatched(array $tokens)
{
return false;
}
/**
* Get current readline input word.
*
* @param array $tokens Tokenized readline input (see token_get_all)
*
* @return string
*/
protected function getInput(array $tokens)
{
$var = '';
$firstToken = array_pop($tokens);
if (self::tokenIs($firstToken, self::T_STRING)) {
$var = $firstToken[1];
}
return $var;
}
/**
* Get current namespace and class (if any) from readline input.
*
* @param array $tokens Tokenized readline input (see token_get_all)
*
* @return string
*/
protected function getNamespaceAndClass($tokens)
{
$class = '';
while (self::hasToken(
array(self::T_NS_SEPARATOR, self::T_STRING),
$token = array_pop($tokens)
)) {
$class = $token[1] . $class;
}
return $class;
}
/**
* Provide tab completion matches for readline input.
*
* @param array $tokens information substracted with get_token_all
* @param array $info readline_info object
*
* @return array The matches resulting from the query
*/
abstract public function getMatches(array $tokens, array $info = array());
/**
* Check whether $word starts with $prefix.
*
* @param string $prefix
* @param string $word
*
* @return bool
*/
public static function startsWith($prefix, $word)
{
return preg_match(sprintf('#^%s#', $prefix), $word);
}
/**
* Check whether $token matches a given syntax pattern.
*
* @param mixed $token A PHP token (see token_get_all)
* @param string $syntax A syntax pattern (default: variable pattern)
*
* @return bool
*/
public static function hasSyntax($token, $syntax = self::VAR_SYNTAX)
{
if (!is_array($token)) {
return false;
}
$regexp = sprintf('#%s#', $syntax);
return (bool) preg_match($regexp, $token[1]);
}
/**
* Check whether $token type is $which.
*
* @param string $which A PHP token type
* @param mixed $token A PHP token (see token_get_all)
*
* @return bool
*/
public static function tokenIs($token, $which)
{
if (!is_array($token)) {
return false;
}
return token_name($token[0]) === $which;
}
/**
* Check whether $token is an operator.
*
* @param mixed $token A PHP token (see token_get_all)
*
* @return bool
*/
public static function isOperator($token)
{
if (!is_string($token)) {
return false;
}
return strpos(self::MISC_OPERATORS, $token) !== false;
}
/**
* Check whether $token type is present in $coll.
*
* @param array $coll A list of token types
* @param mixed $token A PHP token (see token_get_all)
*
* @return bool
*/
public static function hasToken(array $coll, $token)
{
if (!is_array($token)) {
return false;
}
return in_array(token_name($token[0]), $coll);
}
}
```
|
```c
/*++
version 3. Alternative licensing terms are available. Contact
info@minocacorp.com for details. See the LICENSE file at the root of this
project for complete licensing information.
Module Name:
dispatch.c
Abstract:
This module implements interrupt dispatch functionality for AMD64
processors.
Author:
Evan Green 11-Jun-2017
Environment:
Kernel
--*/
//
// your_sha256_hash--- Includes
//
#include <minoca/kernel/kernel.h>
#include <minoca/kernel/kdebug.h>
#include <minoca/kernel/x64.h>
//
// your_sha256_hash Definitions
//
//
// ----------------------------------------------- Internal Function Prototypes
//
//
// ------------------------------------------------------ Data Type Definitions
//
//
// your_sha256_hash---- Globals
//
//
// your_sha256_hash-- Functions
//
VOID
KeDispatchSingleStepTrap (
PTRAP_FRAME TrapFrame
)
/*++
Routine Description:
This routine dispatches a single step trap.
Arguments:
TrapFrame - Supplies a pointer to the machine state immediately before the
trap.
Return Value:
None.
--*/
{
CYCLE_ACCOUNT PreviousPeriod;
PKTHREAD Thread;
ASSERT(ArAreInterruptsEnabled() == FALSE);
if (IS_TRAP_FRAME_FROM_PRIVILEGED_MODE(TrapFrame) == FALSE) {
PreviousPeriod = KeBeginCycleAccounting(CycleAccountKernel);
ArEnableInterrupts();
Thread = KeGetCurrentThread();
PsSignalThread(Thread, SIGNAL_TRAP, NULL, FALSE);
PsCheckRuntimeTimers(Thread);
PsDispatchPendingSignals(Thread, TrapFrame);
ArDisableInterrupts();
//
// If there is no handler or debugger yet, go into the kernel debugger.
//
if ((Thread->OwningProcess->SignalHandlerRoutine == NULL) &&
(Thread->OwningProcess->DebugData == NULL)) {
KdDebugExceptionHandler(EXCEPTION_SINGLE_STEP, NULL, TrapFrame);
}
KeBeginCycleAccounting(PreviousPeriod);
} else {
KdDebugExceptionHandler(EXCEPTION_SINGLE_STEP, NULL, TrapFrame);
}
return;
}
VOID
KeDispatchNmiTrap (
PTRAP_FRAME TrapFrame
)
/*++
Routine Description:
This routine dispatches an NMI interrupt. NMIs are task switches (to avoid
a race with the sysret instruction), so the previous context is saved in a
task structure.
Arguments:
TrapFrame - Supplies a pointer to the machine state immediately before the
trap.
Return Value:
None.
--*/
{
CYCLE_ACCOUNT PreviousPeriod;
PPROCESSOR_BLOCK Processor;
ASSERT(ArAreInterruptsEnabled() == FALSE);
//
// Do a little detection of nested NMIs, which are currently not supported.
//
Processor = KeGetCurrentProcessorBlock();
Processor->NmiCount += 1;
if (Processor->NmiCount == 2) {
RtlDebugBreak();
}
PreviousPeriod = CycleAccountInvalid;
if (IS_TRAP_FRAME_FROM_PRIVILEGED_MODE(TrapFrame) == FALSE) {
PreviousPeriod = KeBeginCycleAccounting(CycleAccountKernel);
}
KdNmiHandler(TrapFrame);
if (PreviousPeriod != CycleAccountInvalid) {
KeBeginCycleAccounting(PreviousPeriod);
}
Processor->NmiCount -= 1;
return;
}
VOID
KeDispatchDebugServiceTrap (
PTRAP_FRAME TrapFrame
)
/*++
Routine Description:
This routine dispatches a debug service trap.
Arguments:
TrapFrame - Supplies a pointer to the machine state immediately before the
trap.
Return Value:
None.
--*/
{
CYCLE_ACCOUNT PreviousPeriod;
PKTHREAD Thread;
ASSERT(ArAreInterruptsEnabled() == FALSE);
if (IS_TRAP_FRAME_FROM_PRIVILEGED_MODE(TrapFrame) == FALSE) {
PreviousPeriod = KeBeginCycleAccounting(CycleAccountKernel);
ArEnableInterrupts();
Thread = KeGetCurrentThread();
PsSignalThread(Thread, SIGNAL_TRAP, NULL, FALSE);
PsCheckRuntimeTimers(Thread);
PsDispatchPendingSignals(Thread, TrapFrame);
ArDisableInterrupts();
KeBeginCycleAccounting(PreviousPeriod);
} else {
KdDebugExceptionHandler(TrapFrame->Rdi,
(PVOID)(TrapFrame->Rsi),
TrapFrame);
}
return;
}
//
// --------------------------------------------------------- Internal Functions
//
```
|
Barbara Lahr (born 25 September 1957 in Kaiserslautern) is a German singer, composer, bassist, guitarist, and producer best known for her collaboration with German
Nu Jazz group De-Phazz.
Career
In 1980, Barbara Lahr started her career as singer with the band The Spunks. From 1984 till 1988 and again in 1993, she was singer and guitarist of the German band Guru Guru.
Awards
1989 Deutscher Rockpreis (German Rock Award)
1990 Studiopreis des WDR
Filmography
Raven - Black Magic Rock (1996) ( for Arte TV)
Discography
Solo
Lyrical Amusement (1998)
Rainbow Line (2002)
Undo Undo (2007)
Six String Call (2012)
with de Phazz
Detunized Gravity (1997)
Death by Chocolate (2001)
Daily Lama (2002)
Natural Fake (2005)
Days of Twang (2007)
Big (2009) feat. Radio Bigband Frankfurt
Lala 2.0 (2010)
with others
New Flowers (1987) with Sanfte Liebe
Passport Rmx Vol.1 /2001) with Klaus Doldinger
References
[ De-Phazz], AMG allmusic, allmusic.com
External links
Barbara Lahr website
German women singers
20th-century German composers
21st-century German composers
German women guitarists
Women jazz guitarists
Living people
1957 births
|
```java
package com.polidea.rxandroidble2.internal.connection;
import android.bluetooth.BluetoothGattCharacteristic;
import androidx.annotation.NonNull;
import com.polidea.rxandroidble2.RxBleConnection;
import com.polidea.rxandroidble2.RxBleDeviceServices;
import com.polidea.rxandroidble2.internal.operations.OperationsProvider;
import com.polidea.rxandroidble2.internal.serialization.ConnectionOperationQueue;
import java.util.UUID;
import bleshadow.javax.inject.Inject;
import io.reactivex.Observable;
import io.reactivex.Single;
import io.reactivex.SingleSource;
import io.reactivex.functions.Function;
public final class LongWriteOperationBuilderImpl implements RxBleConnection.LongWriteOperationBuilder {
final ConnectionOperationQueue operationQueue;
private final RxBleConnection rxBleConnection;
final OperationsProvider operationsProvider;
private Single<BluetoothGattCharacteristic> writtenCharacteristicObservable;
PayloadSizeLimitProvider maxBatchSizeProvider;
RxBleConnection.WriteOperationAckStrategy writeOperationAckStrategy = new ImmediateSerializedBatchAckStrategy();
RxBleConnection.WriteOperationRetryStrategy writeOperationRetryStrategy = new NoRetryStrategy();
byte[] bytes;
@Inject
LongWriteOperationBuilderImpl(
ConnectionOperationQueue operationQueue,
MtuBasedPayloadSizeLimit defaultMaxBatchSizeProvider,
RxBleConnection rxBleConnection,
OperationsProvider operationsProvider
) {
this.operationQueue = operationQueue;
this.maxBatchSizeProvider = defaultMaxBatchSizeProvider;
this.rxBleConnection = rxBleConnection;
this.operationsProvider = operationsProvider;
}
@Override
public RxBleConnection.LongWriteOperationBuilder setBytes(@NonNull byte[] bytes) {
this.bytes = bytes;
return this;
}
@Override
public RxBleConnection.LongWriteOperationBuilder setCharacteristicUuid(@NonNull final UUID uuid) {
this.writtenCharacteristicObservable = rxBleConnection.discoverServices().flatMap(new Function<RxBleDeviceServices, SingleSource<
? extends BluetoothGattCharacteristic>>() {
@Override
public SingleSource<? extends BluetoothGattCharacteristic> apply(RxBleDeviceServices rxBleDeviceServices) throws Exception {
return rxBleDeviceServices.getCharacteristic(uuid);
}
});
return this;
}
@Override
public RxBleConnection.LongWriteOperationBuilder setCharacteristic(@NonNull BluetoothGattCharacteristic bluetoothGattCharacteristic) {
this.writtenCharacteristicObservable = Single.just(bluetoothGattCharacteristic);
return this;
}
@Override
public RxBleConnection.LongWriteOperationBuilder setMaxBatchSize(final int maxBatchSize) {
this.maxBatchSizeProvider = new ConstantPayloadSizeLimit(maxBatchSize);
return this;
}
@Override
public RxBleConnection.LongWriteOperationBuilder setWriteOperationRetryStrategy(
@NonNull RxBleConnection.WriteOperationRetryStrategy writeOperationRetryStrategy) {
this.writeOperationRetryStrategy = writeOperationRetryStrategy;
return this;
}
@Override
public RxBleConnection.LongWriteOperationBuilder setWriteOperationAckStrategy(
@NonNull RxBleConnection.WriteOperationAckStrategy writeOperationAckStrategy) {
this.writeOperationAckStrategy = writeOperationAckStrategy;
return this;
}
@Override
public Observable<byte[]> build() {
if (writtenCharacteristicObservable == null) {
throw new IllegalArgumentException("setCharacteristicUuid() or setCharacteristic() needs to be called before build()");
}
if (bytes == null) {
throw new IllegalArgumentException("setBytes() needs to be called before build()");
}
// TODO: [DS 24.05.2017] Think about a warning if specified maxBatchSize is greater than MTU
return writtenCharacteristicObservable.flatMapObservable(new Function<BluetoothGattCharacteristic, Observable<byte[]>>() {
@Override
public Observable<byte[]> apply(BluetoothGattCharacteristic bluetoothGattCharacteristic) {
return operationQueue.queue(
operationsProvider.provideLongWriteOperation(bluetoothGattCharacteristic,
writeOperationAckStrategy, writeOperationRetryStrategy, maxBatchSizeProvider, bytes)
);
}
});
}
}
```
|
```java
package com.example.filters;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import com.nineoldandroids.view.ViewHelper;
import java.util.List;
/**
* @author Varun on 01/07/15.
*/
public class ThumbnailsAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private static final String TAG = "THUMBNAILS_ADAPTER";
private static int lastPosition = -1;
private ThumbnailCallback thumbnailCallback;
private List<ThumbnailItem> dataSet;
public ThumbnailsAdapter(List<ThumbnailItem> dataSet, ThumbnailCallback thumbnailCallback) {
Log.v(TAG, "Thumbnails Adapter has " + dataSet.size() + " items");
this.dataSet = dataSet;
this.thumbnailCallback = thumbnailCallback;
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
Log.v(TAG, "On Create View Holder Called");
View itemView = LayoutInflater.
from(viewGroup.getContext()).
inflate(R.layout.list_thumbnail_item, viewGroup, false);
return new ThumbnailsViewHolder(itemView);
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, final int i) {
final ThumbnailItem thumbnailItem = dataSet.get(i);
Log.v(TAG, "On Bind View Called");
ThumbnailsViewHolder thumbnailsViewHolder = (ThumbnailsViewHolder) holder;
thumbnailsViewHolder.thumbnail.setImageBitmap(thumbnailItem.image);
thumbnailsViewHolder.thumbnail.setScaleType(ImageView.ScaleType.FIT_START);
setAnimation(thumbnailsViewHolder.thumbnail, i);
thumbnailsViewHolder.thumbnail.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (lastPosition != i) {
thumbnailCallback.onThumbnailClick(thumbnailItem.filter);
lastPosition = i;
}
}
});
}
private void setAnimation(View viewToAnimate, int position) {
{
ViewHelper.setAlpha(viewToAnimate, .0f);
com.nineoldandroids.view.ViewPropertyAnimator.animate(viewToAnimate).alpha(1).setDuration(250).start();
lastPosition = position;
}
}
@Override
public int getItemCount() {
return dataSet.size();
}
public static class ThumbnailsViewHolder extends RecyclerView.ViewHolder {
public ImageView thumbnail;
public ThumbnailsViewHolder(View v) {
super(v);
this.thumbnail = (ImageView) v.findViewById(R.id.thumbnail);
}
}
}
```
|
```c++
///////////////////////////////////////////////////////////////////////////////
/// \file expr.hpp
/// Contains definition of expr\<\> class template.
//
// LICENSE_1_0.txt or copy at path_to_url
template<typename Tag, typename Arg0>
struct expr<Tag, term<Arg0>, 0>
{
typedef Tag proto_tag;
static const long proto_arity_c = 0;
typedef mpl::long_<0 > proto_arity;
typedef expr proto_base_expr;
typedef term<Arg0> proto_args;
typedef basic_expr<Tag, proto_args, 0 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0;
typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0>
BOOST_FORCEINLINE
static expr const make(A0 &a0)
{
return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
}
template<typename A0>
BOOST_FORCEINLINE
static expr const make(A0 const &a0)
{
return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a)
{
proto::expr<
proto::tag::subscript
, list2<expr &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a)
{
proto::expr<
proto::tag::subscript
, list2<expr &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr &>, 1> const
operator ()()
{
proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr
, default_domain , const A0
>::type const
operator ()(A0 const &a0)
{
return result_of::funop1<
expr
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1)
{
return result_of::funop2<
expr
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2)
{
return result_of::funop3<
expr
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
{
return result_of::funop4<
expr
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
{
return result_of::funop5<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
{
return result_of::funop6<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
{
return result_of::funop7<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
{
return result_of::funop8<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
{
return result_of::funop9<
expr
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0>
struct expr<Tag, list1<Arg0>, 1 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 1;
typedef mpl::long_<1 > proto_arity;
typedef expr proto_base_expr;
typedef list1<Arg0> proto_args;
typedef basic_expr<Tag, proto_args, 1 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0;
typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0>
BOOST_FORCEINLINE
static expr const make(A0 const &a0)
{
expr that = {a0};
return that;
}
typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
BOOST_FORCEINLINE
operator address_of_hack_type_() const
{
return boost::addressof(this->child0);
}
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1>
struct expr<Tag, list2<Arg0 , Arg1>, 2 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 2;
typedef mpl::long_<2 > proto_arity;
typedef expr proto_base_expr;
typedef list2<Arg0 , Arg1> proto_args;
typedef basic_expr<Tag, proto_args, 2 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1)
{
expr that = {a0 , a1};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 3;
typedef mpl::long_<3 > proto_arity;
typedef expr proto_base_expr;
typedef list3<Arg0 , Arg1 , Arg2> proto_args;
typedef basic_expr<Tag, proto_args, 3 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
{
expr that = {a0 , a1 , a2};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 4;
typedef mpl::long_<4 > proto_arity;
typedef expr proto_base_expr;
typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
typedef basic_expr<Tag, proto_args, 4 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
{
expr that = {a0 , a1 , a2 , a3};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 5;
typedef mpl::long_<5 > proto_arity;
typedef expr proto_base_expr;
typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
typedef basic_expr<Tag, proto_args, 5 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
{
expr that = {a0 , a1 , a2 , a3 , a4};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 6;
typedef mpl::long_<6 > proto_arity;
typedef expr proto_base_expr;
typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
{
expr that = {a0 , a1 , a2 , a3 , a4 , a5};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 7;
typedef mpl::long_<7 > proto_arity;
typedef expr proto_base_expr;
typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
{
expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 8;
typedef mpl::long_<8 > proto_arity;
typedef expr proto_base_expr;
typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
typedef void proto_child8; typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
{
expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 9;
typedef mpl::long_<9 > proto_arity;
typedef expr proto_base_expr;
typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
typedef void proto_child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
{
expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
{
typedef Tag proto_tag;
static const long proto_arity_c = 10;
typedef mpl::long_<10 > proto_arity;
typedef expr proto_base_expr;
typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
typedef default_domain proto_domain;
typedef default_generator proto_generator;
typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_;
typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
BOOST_FORCEINLINE
expr const &proto_base() const
{
return *this;
}
BOOST_FORCEINLINE
expr &proto_base()
{
return *this;
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
BOOST_FORCEINLINE
static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
{
expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
return that;
}
typedef detail::not_a_valid_type address_of_hack_type_;
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> const
operator =(expr const &a)
{
proto::expr<
proto::tag::assign
, list2<expr &, expr const &>
, 2
> that = {*this, a};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator =(A &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator =(A const &a) const
{
proto::expr<
proto::tag::assign
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> const
operator [](A &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename A>
BOOST_FORCEINLINE
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> const
operator [](A const &a) const
{
proto::expr<
proto::tag::subscript
, list2<expr const &, typename result_of::as_child<A const>::type>
, 2
> that = {*this, proto::as_child(a)};
return that;
}
template<typename Sig>
struct result
{
typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
};
BOOST_FORCEINLINE
proto::expr<proto::tag::function, list1<expr const &>, 1> const
operator ()() const
{
proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
return that;
}
template<typename A0>
BOOST_FORCEINLINE
typename result_of::funop1<
expr const
, default_domain , const A0
>::type const
operator ()(A0 const &a0) const
{
return result_of::funop1<
expr const
, default_domain , const A0
>::call(*this , a0);
}
template<typename A0 , typename A1>
BOOST_FORCEINLINE
typename result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::type const
operator ()(A0 const &a0 , A1 const &a1) const
{
return result_of::funop2<
expr const
, default_domain , const A0 , const A1
>::call(*this , a0 , a1);
}
template<typename A0 , typename A1 , typename A2>
BOOST_FORCEINLINE
typename result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
{
return result_of::funop3<
expr const
, default_domain , const A0 , const A1 , const A2
>::call(*this , a0 , a1 , a2);
}
template<typename A0 , typename A1 , typename A2 , typename A3>
BOOST_FORCEINLINE
typename result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
{
return result_of::funop4<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
BOOST_FORCEINLINE
typename result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
{
return result_of::funop5<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4
>::call(*this , a0 , a1 , a2 , a3 , a4);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
BOOST_FORCEINLINE
typename result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
{
return result_of::funop6<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
BOOST_FORCEINLINE
typename result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
{
return result_of::funop7<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
BOOST_FORCEINLINE
typename result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
{
return result_of::funop8<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
}
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
BOOST_FORCEINLINE
typename result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::type const
operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
{
return result_of::funop9<
expr const
, default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
>::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
}
};
```
|
On the death of Mohammed Adil Shah, Sultan of Bijapur on 4 November 1656, Ali Adil Shah II, a youth of eighteen, succeeded to the throne of Bijapur through the efforts of the Prime Minister Khan Muhammad and the Queen, Badi Sahiba, sister of Qutb Shah of Golkonda.
His accession signaled disasters to the Kingdom and his reign marked the decline of the Bijapur Kingdom.
Reign
Shah Jahan, anxious to annex Bijapur to his empire, found a pretext in the legitimacy of Alis parents. On Aurangzeb’s plea, Shah Jahan sanctioned the invasion of Bijapur and gave him a free hand to deal with the situation. This sanction of such a war was wholly unrighteous. Bijapur was not a vassal state of the Mughals; but an independent and equal ally of the Mughal Emperor, and the latter had no lawful right to confirm or question the succession to the Bijapur Sultanate. However, Aurangzeb, had to raise the siege and rush to the north for the war of succession to the Mughal throne.
With Muhammad’s death and Ali’s accession disorder had begun in the Karnataka. The Nayaks tried to recover their former lands. (Bangalore the capital of Karnataka was Bijapur’s administrative headquarters for controlling these feudatories by Kempegouda). On the other hand, Shivaji increased the momentum of acquiring more and more Bijapur territory and carved an independent Maratha state, while his diplomacy prevented any Mughal-Bijapur coalition against him.
At the court things were even worse. With the coming of a young and weak ruler, the party factions and struggle for supremacy was at its zenith. To aggravate the, Aurangzeb intrigued with Bijapur nobles and succeeded in winning over most of them.
Throughout his reign of 16 years, Ali struggled desperately both against the Mughals and the Marathas. He thrice repulsed Mughal invasions. But when he died in 1672 the Bijapur kingdom was deprived of most of its important territorial possessions. With the expansion of Shivaji’s kingdom there was a corresponding shrinkage in the Bijapur territory.
Death
Ali’s reign is marked by developments in Persian and Deccani literature and fine arts, and some good works of history were also produced under his patronage. Nusrati served as his poet-laureate. He was buried in Ali Ka Rouza the world-famous Bara Kaman in Bijapur.
References
Bibliography
Dehlavi, Basheeruddin: Wāqīyāt-i mamlakat-i Bījāpūr, Bangalore (Karnatak Urdu Academy) 2003.
Firishta, Muḥammad Qāsim Hindū-Shāh Astarābādī: History of the Rise of the Mahomedan Power in India, till the Year 1612, translated by John Briggs, Calcutta (Editions Indian) 1829, rep. 1966.
Nayeem, Muhammad: External Relations of the Bijapur Kingdom, Hyderabad A.P. (Bright Publishers) 1974.
Verma, Dinesh Chandra: Social, economic, and cultural history of Bijapur, Delhi (Idarah-i Adabiyat-i Delli) 1990.
1672 deaths
17th-century Indian Muslims
17th-century Indian monarchs
Sultans of Bijapur
Adil Shahi dynasty
1656 in India
1672 in India
Year of birth unknown
|
The Azad () was a Bengali-language daily newspaper published from 1936 to 1992. The Azad became Dhaka's first daily newspaper. The newspaper, while based in Dhaka, played an important role during the Bengali Language Movement for its advocacy of Bengali.
History
The newspaper was founded in Kolkata on 31 October 1936. The first editor of the daily was Maulana Mohammad Akram Khan. In its early days, the daily supported the Muslim League in both Bengal and Assam languages. In the 1940s, the editor was Mohammad Modabber; he published The Azad with his son. Mohammed Sadrul Anam Khan and Nazir Ahmed were also associated during that time. The daily regularly published Dhaka-based and regional news from reporter Khairul Kabir.
After the partition of India, The Azad was transferred to Dhaka on 19 October 1948. It became the first newspaper to move to Dhaka. Abul Kalam Shamsuddin was nominated editor at that time. Khairul Kabir acted as news editor. Mujibur Rahman Khan and Abu Jafar Shamsuddin worked in the editorial section. Soon afterward, the daily became the leading newspaper in East Pakistan.
Bengali Language Movement
The publication of The Azad was prohibited in 1949 when editorial content turned against the government, which responded by prohibiting advertisements in the paper. The Azad supported the Bengali Language Movement and defied the government's threats. When the killing of February 21 took place, The Azad released a special edition on 22 February. The editor of the newspaper, Abul Kalam Shamsuddin, who was also member of the Legislative Assembly, resigned from the assembly in protest.
Despite being a right wing newspaper which previously supported the Muslim League, it published week-long investigative reports on the incidents of February 21. However, after 1 March 1952 they succumbed to government pressure and could not remain impartial. During the autocratic regime of General Ayub Khan, the daily again stood up under the leadership of Akram Khan's youngest son, Mohammed Quamrul Anam Khan to protest against corruption and unjust rule. It also played an important role in the toppling of the Ayub Khan government and the Agartala Conspiracy Case.
Decline
The daily quickly lost its appeal after Maulana Mohammad Akram Khan died and ownership controversies arose. It lost readership from competition with Ittefaq which became increasingly popular. After the independence of Bangladesh, the daily lost government financial aid. Later, the daily was given to its legal owner and managing director, Mohammad Quamrul Anam Khan to be run under private administration. Due to lack of financial support and government policies, The Azad was shut down in 1990.
See also
List of newspapers in Bangladesh
References
1936 establishments in India
Defunct newspapers published in Bangladesh
Defunct newspapers published in India
Newspapers published in Kolkata
Newspapers established in 1936
Publications disestablished in 1990
Newspapers published in Dhaka
Bengali-language newspapers published in Bangladesh
Daily newspapers published in Bangladesh
|
```xml
import { Input, InputProps, Popup } from '@fluentui/react-northstar';
import * as React from 'react';
import ComponentExampleColorPicker from './ComponentExampleColorPicker';
export type ComponentExampleVariableProps = {
componentName: string;
onChange: (componentName: string, variableName: string, variableValue: string) => void;
variableName: string;
variableType: 'color' | 'string';
variableValue: string;
};
const ComponentExampleVariable: React.FunctionComponent<ComponentExampleVariableProps> = props => {
const { componentName, onChange, variableName, variableType, variableValue } = props;
const handleInputChange = React.useCallback(
(e, data: InputProps) => {
onChange(componentName, variableName, data.value as string);
},
[componentName, onChange, variableName],
);
const handleColorChange = React.useCallback(
(colorValue: string) => {
onChange(componentName, variableName, colorValue);
},
[componentName, onChange, variableName],
);
return (
<div style={{ padding: '0.25rem' }}>
{variableType === 'string' && <div>{variableName}</div>}
{variableType === 'string' && <Input onChange={handleInputChange} value={variableValue} />}
{variableType === 'color' && (
<Popup
pointing
trigger={
<div style={{ display: 'inline-block', cursor: 'pointer' }}>
<span
style={{
display: 'inline-block',
width: '1rem',
height: '1rem',
marginRight: '0.5rem',
verticalAlign: 'middle',
background: variableValue,
boxShadow: '0 0 0 1px black, 0 0 0 2px white',
}}
/>
{variableName}
</div>
}
align="start"
position="below"
content={<ComponentExampleColorPicker onChange={handleColorChange} variableValue={variableValue} />}
/>
)}
</div>
);
};
export default React.memo(ComponentExampleVariable);
```
|
Anders Johan Ture Rangström (30 November 1884 – 11 May 1947) belonged to a new generation of Swedish composers who, in the first decade of the 20th century, introduced modernism to their compositions. In addition to composing, Rangström was also a musical critic and conductor.
Biography
Rangström was born in Stockholm, where in his late teens he started to write songs. His music teacher suggested that he should "vary the harmonies a bit more, make it a bit wilder!" He followed this advice and soon gained the nickname among his colleagues of "Sturm-und-Drangström". He travelled to Berlin where he studied under Hans Pfitzner for a while in 1905–6, and also studied singing with the Wagnerian Julius Hey, with whom he later went to Munich for further studies. His compositions at this time were chiefly for voice and piano.
Between 1907 and 1922 he taught singing and from 1922 to 1925 he was principal conductor of the Gothenburg Symphony Orchestra. He founded the Swedish Society of Composers in 1924, and he was employed to promote the works of the Royal Swedish Opera from 1931 to 1936. After this he worked freelance and spent the summers on the island of Törnsholmen which he had been given by the people of Sweden who raised the money to celebrate his fiftieth birthday.
Rangström died at his home in Stockholm after a long illness caused by a throat disease; his funeral was held at Stockholm's Maria Magdalena Church and he is buried in the churchyard at Gryt, Valdemarsvik Municipality, Östergötland County, southeast Sweden. He was grandfather of a playwright, also named Ture Rangström (born in 1944) the artistic director of Strindbergs Intima Teater (since its re-opening in 2003), and uncle of author Lars Gyllensten.
Works
Many of his early works took the form of symphonic poems, including Dityramb (Dithyramb) (1909), Ett midsommarstycke (A midsummer piece) and En höstsång (An autumn song). Following the success of these poems, Rangström began work on his symphonies, of which there are four. The first, produced in 1914, is dedicated to the memory of Strindberg – August Strindberg in memoriam; the second, from 1919, is entitled Mitt land (My country); the third from 1929, Sång under stjärnorna (Song under the stars), and the fourth from 1936, Invocatio, for orchestra and organ.
He composed three operas, entitled Kronbruden (The Crown Bride), based on a play by Strindberg, which was first performed in 1915, Medeltida (Medieval), published in 1921, and Gilgamesj, based on the Mesopotamian Epic of Gilgamesh, written during the last years of his life. The orchestration of Gilgamesj was completed by the composer John Fernström, and it was premièred in November 1952 at the Royal Swedish Opera with Erik Saedén in the title role and Herbert Sandberg conducting. Rangström also wrote almost 300 songs and orchestrated about 60 of them.
Orchestral
Dithyramb, symphonic poem, 1909 (revised by Kurt Atterberg, 1948)
Ett midsommarstycke, symphonic poem, 1910
En höstsång, symphonic poem, 1911
Havet sjunger, symphonic poem, 1913
Symphony no. 1 in C-sharp minor, August Strindberg in memoriam, 1914
Intermezzo drammatico, suite, 1916–18
Divertimento elegiaco, suite for string orchestra, 1918
Två melodier, clarinet and strings, 1919
Symphony no. 2 in D minor, Mitt land, 1919
Två svenska folkmelodier, 1928
Symphony no. 3 in D flat Sång under stjärnorna, 1929
Partita for violin and orchestra in B minor, 1933
Symphony no. 4 in D minor Invocatio, 1935
Ballade for piano and orchestra, 1937
Vauxhall, suite 1937
Staden spelar, divertissement, 1940
Chamber music
String quartet in G minor, Ein Nachtstück in ETA Hoffmanns Manier, 1909 (rev. Edvin Kallstenius and Kurt Atterberg 1948)
Suite in modo antico, violin and piano, 1912
Suite in modo barocco, violin and piano, 1920–22
Piano
Fyra preludier, 1910–13
Mälarlegender, 1919
Sommarskyar, 1916–20
Improvisata, 1927
Sonatin, 1937
Spelmansvår, suite, 1943
References
External links
1884 births
1947 deaths
20th-century Swedish male musicians
20th-century Swedish composers
Male opera composers
Modernist composers
Musicians from Stockholm
Swedish classical composers
Swedish male classical composers
Swedish opera composers
|
```html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>adjacent_filtered</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../../index.html" title="Chapter 1. Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="../reference.html" title="Reference">
<link rel="next" href="copied.html" title="copied">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="path_to_url">People</a></td>
<td align="center"><a href="path_to_url">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../reference.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="copied.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.adjacent_filtered"></a><a class="link" href="adjacent_filtered.html" title="adjacent_filtered">adjacent_filtered</a>
</h5></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="adjacent_filtered.html#range.reference.adaptors.reference.adjacent_filtered.adjacent_filtered_example">adjacent_filtered
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">adjacent_filtered</span><span class="special">(</span><span class="identifier">bi_pred</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">adjacent_filter</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">bi_pred</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is convertible
to both argument types of <code class="computeroutput"><span class="identifier">bi_pred</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all adjacent
elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code> in the returned range, <code class="computeroutput"><span class="identifier">bi_pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">)</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Throws:</strong></span> Whatever the copy constructor
of <code class="computeroutput"><span class="identifier">bi_pred</span></code> might
throw.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adjacent_filtered_range</span><span class="special"><</span><span class="keyword">decltype</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">bi_pred</span><span class="special">)></span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The minimum
of the range category of <code class="computeroutput"><span class="identifier">rng</span></code>
and <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.adjacent_filtered.adjacent_filtered_example"></a><a class="link" href="adjacent_filtered.html#range.reference.adaptors.reference.adjacent_filtered.adjacent_filtered_example" title="adjacent_filtered example">adjacent_filtered
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">adjacent_filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iterator</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">functional</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">iostream</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">vector</span><span class="special">></span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">adjacent_filtered</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">>()),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special"><</span><span class="keyword">int</span><span class="special">>(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span>
</pre>
<p>
</p>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
Neil Groves<p>
file LICENSE_1_0.txt or copy at <a href="path_to_url" target="_top">path_to_url
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../reference.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="copied.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
```xml
import { Providers } from 'expo-maps/build/Map.types';
import { createContext } from 'react';
const ProviderContext = createContext<Providers>('google');
export default ProviderContext;
```
|
is the railway station in Kawashimo-cho, Sasebo City, Nagasaki Prefecture. It is operated by Matsuura Railway and is on the Nishi-Kyūshū Line.
Lines
Matsuura Railway
Nishi-Kyūshū Line
Adjacent stations
Station layout
The station is on a bank with a single side platform.
Environs
Kyushu Bunka Gakuen High School
Sasebo Jitsugyo High School
Sasebo city synthesis ground
JGSDF Ainoura garrison
History
1991-03-16 - Opens for business as .
1994-10-03 - Renamed to present name.
References
Nagasaki statistical yearbook (Nagasaki prefectural office statistics section,Japanese)
External links
Matsuura Railway (Japanese)
Railway stations in Japan opened in 1991
Railway stations in Nagasaki Prefecture
Sasebo
|
```xml
<?xml version="1.0" encoding="UTF-8"?>
<document type="com.apple.InterfaceBuilder.AppleTV.XIB" version="3.0" toolsVersion="12120" systemVersion="16E195" targetRuntime="AppleTV" propertyAccessControl="none" useAutolayout="YES" colorMatched="YES">
<device id="appleTV" orientation="landscape">
<adaptation id="dark"/>
</device>
<dependencies>
<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="12088"/>
<capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
</dependencies>
<objects>
<placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner" customClass="TraktAuthenticationViewController" customModule="AKTrakt">
<connections>
<outlet property="codeLabel" destination="wek-Tb-zdS" id="SSZ-0v-g28"/>
<outlet property="view" destination="iN0-l3-epB" id="PGy-UJ-GOS"/>
</connections>
</placeholder>
<placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
<view contentMode="scaleToFill" id="iN0-l3-epB">
<rect key="frame" x="0.0" y="0.0" width="1920" height="1080"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<subviews>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Navigate to path_to_url and enter code shown below when asked." textAlignment="justified" lineBreakMode="tailTruncation" numberOfLines="0" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="DZd-Dx-iyv">
<rect key="frame" x="384" y="298" width="1152" height="40"/>
<fontDescription key="fontDescription" type="system" weight="medium" pointSize="33"/>
<color key="textColor" white="0.66666666666666663" alpha="1" colorSpace="calibratedWhite"/>
<nil key="highlightedColor"/>
</label>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Trakt Pairing Request" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="5Oy-eR-a2e">
<rect key="frame" x="731" y="220" width="458" height="58"/>
<fontDescription key="fontDescription" style="UICTFontTextStyleTitle3"/>
<color key="textColor" white="0.66666666666666663" alpha="1" colorSpace="calibratedWhite"/>
<nil key="highlightedColor"/>
</label>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="wek-Tb-zdS">
<rect key="frame" x="960" y="428" width="0.0" height="0.0"/>
<color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="calibratedWhite"/>
<fontDescription key="fontDescription" style="UICTFontTextStyleTitle1"/>
<nil key="textColor"/>
<nil key="highlightedColor"/>
</label>
</subviews>
<constraints>
<constraint firstItem="5Oy-eR-a2e" firstAttribute="centerX" secondItem="iN0-l3-epB" secondAttribute="centerX" id="22V-3C-VG0"/>
<constraint firstItem="DZd-Dx-iyv" firstAttribute="top" secondItem="5Oy-eR-a2e" secondAttribute="bottom" constant="20" id="Cq9-fp-pzj"/>
<constraint firstItem="wek-Tb-zdS" firstAttribute="top" secondItem="DZd-Dx-iyv" secondAttribute="bottom" constant="90" id="I32-cJ-zhu"/>
<constraint firstItem="5Oy-eR-a2e" firstAttribute="top" secondItem="iN0-l3-epB" secondAttribute="top" constant="220" id="OwE-0j-2d1"/>
<constraint firstItem="DZd-Dx-iyv" firstAttribute="centerX" secondItem="iN0-l3-epB" secondAttribute="centerX" id="ncW-BH-zLr"/>
<constraint firstItem="wek-Tb-zdS" firstAttribute="centerX" secondItem="iN0-l3-epB" secondAttribute="centerX" id="opx-a4-3Kx"/>
</constraints>
<simulatedNavigationBarMetrics key="simulatedTopBarMetrics" prompted="NO"/>
</view>
</objects>
<simulatedMetricsContainer key="defaultSimulatedMetrics">
<nil key="statusBar"/>
<simulatedOrientationMetrics key="orientation" orientation="landscapeRight"/>
<simulatedScreenMetrics key="destination" type="appleTV.dark"/>
</simulatedMetricsContainer>
</document>
```
|
```smalltalk
namespace Asp.Versioning;
using Microsoft.AspNetCore.Mvc.Controllers;
using System.Collections;
using System.Reflection;
internal sealed class FilteredControllerTypes : ControllerFeatureProvider, ICollection<Type>
{
private readonly HashSet<Type> controllerTypes = [];
protected override bool IsController( TypeInfo typeInfo ) => base.IsController( typeInfo ) && controllerTypes.Contains( typeInfo );
public int Count => controllerTypes.Count;
public bool IsReadOnly => false;
public void Add( Type item ) => controllerTypes.Add( item );
public void Clear() => controllerTypes.Clear();
public bool Contains( Type item ) => controllerTypes.Contains( item );
public void CopyTo( Type[] array, int arrayIndex ) => controllerTypes.CopyTo( array, arrayIndex );
public IEnumerator<Type> GetEnumerator() => controllerTypes.GetEnumerator();
public bool Remove( Type item ) => controllerTypes.Remove( item );
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
```
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\Books\Resource;
use Google\Service\Books\DownloadAccesses;
use Google\Service\Books\RequestAccessData;
use Google\Service\Books\Usersettings;
use Google\Service\Books\Volumes as VolumesModel;
/**
* The "myconfig" collection of methods.
* Typical usage is:
* <code>
* $booksService = new Google\Service\Books(...);
* $myconfig = $booksService->myconfig;
* </code>
*/
class Myconfig extends \Google\Service\Resource
{
/**
* Gets the current settings for the user. (myconfig.getUserSettings)
*
* @param array $optParams Optional parameters.
*
* @opt_param string country Unused. Added only to workaround TEX mandatory
* request template requirement
* @return Usersettings
* @throws \Google\Service\Exception
*/
public function getUserSettings($optParams = [])
{
$params = [];
$params = array_merge($params, $optParams);
return $this->call('getUserSettings', [$params], Usersettings::class);
}
/**
* Release downloaded content access restriction.
* (myconfig.releaseDownloadAccess)
*
* @param string $cpksver The device/version ID from which to release the
* restriction.
* @param string|array $volumeIds The volume(s) to release restrictions for.
* @param array $optParams Optional parameters.
*
* @opt_param string locale ISO-639-1, ISO-3166-1 codes for message
* localization, i.e. en_US.
* @opt_param string source String to identify the originator of this request.
* @return DownloadAccesses
* @throws \Google\Service\Exception
*/
public function releaseDownloadAccess($cpksver, $volumeIds, $optParams = [])
{
$params = ['cpksver' => $cpksver, 'volumeIds' => $volumeIds];
$params = array_merge($params, $optParams);
return $this->call('releaseDownloadAccess', [$params], DownloadAccesses::class);
}
/**
* Request concurrent and download access restrictions. (myconfig.requestAccess)
*
* @param string $cpksver The device/version ID from which to request the
* restrictions.
* @param string $nonce The client nonce value.
* @param string $source String to identify the originator of this request.
* @param string $volumeId The volume to request concurrent/download
* restrictions for.
* @param array $optParams Optional parameters.
*
* @opt_param string licenseTypes The type of access license to request. If not
* specified, the default is BOTH.
* @opt_param string locale ISO-639-1, ISO-3166-1 codes for message
* localization, i.e. en_US.
* @return RequestAccessData
* @throws \Google\Service\Exception
*/
public function requestAccess($cpksver, $nonce, $source, $volumeId, $optParams = [])
{
$params = ['cpksver' => $cpksver, 'nonce' => $nonce, 'source' => $source, 'volumeId' => $volumeId];
$params = array_merge($params, $optParams);
return $this->call('requestAccess', [$params], RequestAccessData::class);
}
/**
* Request downloaded content access for specified volumes on the My eBooks
*
* @param string $cpksver The device/version ID from which to release the
* restriction.
* @param string $nonce The client nonce value.
* @param string $source String to identify the originator of this request.
* @param array $optParams Optional parameters.
*
* @opt_param string features List of features supported by the client, i.e.,
* 'RENTALS'
* @opt_param bool includeNonComicsSeries Set to true to include non-comics
* series. Defaults to false.
* @opt_param string locale ISO-639-1, ISO-3166-1 codes for message
* localization, i.e. en_US.
* @opt_param bool showPreorders Set to true to show pre-ordered books. Defaults
* to false.
* @opt_param string volumeIds The volume(s) to request download restrictions
* for.
* @return VolumesModel
* @throws \Google\Service\Exception
*/
{
$params = ['cpksver' => $cpksver, 'nonce' => $nonce, 'source' => $source];
$params = array_merge($params, $optParams);
}
/**
* Sets the settings for the user. If a sub-object is specified, it will
* overwrite the existing sub-object stored in the server. Unspecified sub-
* objects will retain the existing value. (myconfig.updateUserSettings)
*
* @param Usersettings $postBody
* @param array $optParams Optional parameters.
* @return Usersettings
* @throws \Google\Service\Exception
*/
public function updateUserSettings(Usersettings $postBody, $optParams = [])
{
$params = ['postBody' => $postBody];
$params = array_merge($params, $optParams);
return $this->call('updateUserSettings', [$params], Usersettings::class);
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(Myconfig::class, 'Google_Service_Books_Resource_Myconfig');
```
|
```smalltalk
//
// Authors:
// Miguel de Icaza (miguel@xamarin.com)
//
//
// While the framework exists on both platforms, they share no common API
//
using System;
using System.ComponentModel;
using AudioUnit;
using CoreFoundation;
using Foundation;
using ObjCRuntime;
using CoreAnimation;
using CoreGraphics;
#if MONOMAC
using AppKit;
using AUViewControllerBase = AppKit.NSViewController;
using UIViewController = AppKit.NSViewController;
#else
using UIKit;
using AUViewControllerBase = UIKit.UIViewController;
using NSView = Foundation.NSObject;
using NSWindow = Foundation.NSObject;
using NSWindowController = Foundation.NSObject;
using NSViewController = Foundation.NSObject;
#endif
#if !NET
using NativeHandle = System.IntPtr;
#endif
namespace CoreAudioKit {
[NoiOS]
[NoMacCatalyst]
[Flags]
public enum AUGenericViewDisplayFlags : uint {
TitleDisplay = 1u << 0,
PropertiesDisplay = 1u << 1,
ParametersDisplay = 1u << 2,
}
/// <summary>
/// <see cref="T:UIKit.UIViewController" /> class that handles extension requests to support audio unit extensions that have a UI.</summary>
///
/// <related type="externalDocumentation" href="path_to_url">Apple documentation for <c>AUViewController</c></related>
[MacCatalyst (13, 1)]
[BaseType (typeof (AUViewControllerBase))]
interface AUViewController {
[Export ("initWithNibName:bundle:")]
[PostGet ("NibBundle")]
NativeHandle Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
}
[MacCatalyst (13, 1)]
[BaseType (typeof (NSObject))]
interface AUAudioUnitViewConfiguration : NSSecureCoding {
[Export ("initWithWidth:height:hostHasController:")]
NativeHandle Constructor (nfloat width, nfloat height, bool hostHasController);
[Export ("width")]
nfloat Width { get; }
[Export ("height")]
nfloat Height { get; }
[Export ("hostHasController")]
bool HostHasController { get; }
}
[Category]
[MacCatalyst (13, 1)]
[BaseType (typeof (AUAudioUnit))]
interface AUAudioUnitViewControllerExtensions {
[Export ("supportedViewConfigurations:")]
NSIndexSet GetSupportedViewConfigurations (AUAudioUnitViewConfiguration [] availableViewConfigurations);
[Export ("selectViewConfiguration:")]
void SelectViewConfiguration (AUAudioUnitViewConfiguration viewConfiguration);
}
[NoiOS]
[NoMacCatalyst]
[Protocol]
interface AUCustomViewPersistentData {
[Abstract]
[NullAllowed, Export ("customViewPersistentData", ArgumentSemantic.Assign)]
NSDictionary<NSString, NSObject> CustomViewPersistentData { get; set; }
}
[NoiOS]
[NoMacCatalyst]
[DisableDefaultCtor] // Crashes
[BaseType (typeof (NSView))]
interface AUGenericView : AUCustomViewPersistentData {
[Export ("audioUnit")]
AudioUnit.AudioUnit AudioUnit { get; }
[Export ("showsExpertParameters")]
bool ShowsExpertParameters { get; set; }
[Export ("initWithAudioUnit:")]
NativeHandle Constructor (AudioUnit.AudioUnit au);
[Export ("initWithAudioUnit:displayFlags:")]
NativeHandle Constructor (AudioUnit.AudioUnit au, AUGenericViewDisplayFlags inFlags);
}
[NoiOS]
[NoMacCatalyst]
[BaseType (typeof (NSView))]
[DisableDefaultCtor]
interface AUPannerView {
[Export ("audioUnit")]
AudioUnit.AudioUnit AudioUnit { get; }
[Static]
[Export ("AUPannerViewWithAudioUnit:")]
AUPannerView Create (AudioUnit.AudioUnit au);
}
[NoiOS]
[NoMacCatalyst]
[BaseType (typeof (NSWindowController), Name = "CABTLEMIDIWindowController")]
interface CABtleMidiWindowController {
[Export ("initWithWindow:")]
NativeHandle Constructor ([NullAllowed] NSWindow window);
}
[NoiOS]
[NoMacCatalyst]
[BaseType (typeof (NSViewController))]
interface CAInterDeviceAudioViewController {
[Export ("initWithNibName:bundle:")]
NativeHandle Constructor ([NullAllowed] string nibNameOrNull, [NullAllowed] NSBundle nibBundleOrNull);
}
[NoiOS]
[NoMacCatalyst]
[DesignatedDefaultCtor]
[BaseType (typeof (NSWindowController))]
interface CANetworkBrowserWindowController {
[Export ("initWithWindow:")]
NativeHandle Constructor ([NullAllowed] NSWindow window);
[Static]
[Export ("isAVBSupported")]
bool IsAvbSupported { get; }
}
#if !MONOMAC
/// <summary>A <see cref="T:UIKit.UIViewController" /> that allows discovery and connection to MIDI over Bluetooth peripherals.</summary>
///
/// <related type="externalDocumentation" href="path_to_url">Apple documentation for <c>CABTMIDICentralViewController</c></related>
[NoMac]
[MacCatalyst (13, 1)]
// in iOS 8.3 (Xcode 6.3 SDK) the base type was changed from UIViewController to UITableViewController
[BaseType (typeof (UITableViewController), Name = "CABTMIDICentralViewController")]
interface CABTMidiCentralViewController {
[Export ("initWithNibName:bundle:")]
[PostGet ("NibBundle")]
NativeHandle Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
[MacCatalyst (13, 1)]
[Export ("initWithStyle:")]
NativeHandle Constructor (UITableViewStyle withStyle);
}
/// <summary>A <see cref="T:UIKit.UIViewController" /> that allows the iOS device to serve as a Midi-over-Bluetooth peripheral.</summary>
///
/// <related type="externalDocumentation" href="path_to_url">Apple documentation for <c>CABTMIDILocalPeripheralViewController</c></related>
[NoMac]
[MacCatalyst (13, 1)]
[BaseType (typeof (UIViewController), Name = "CABTMIDILocalPeripheralViewController")]
interface CABTMidiLocalPeripheralViewController {
[Export ("initWithNibName:bundle:")]
[PostGet ("NibBundle")]
NativeHandle Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
}
/// <summary>A <see cref="T:UIKit.UIView" /> that defines the standard inter-app audio user interface.</summary>
///
/// <related type="externalDocumentation" href="path_to_url">Apple documentation for <c>CAInterAppAudioSwitcherView</c></related>
[NoMac]
[Deprecated (PlatformName.iOS, 13, 0, message: "Use 'AudioUnit' instead.")]
[NoMacCatalyst]
[Deprecated (PlatformName.MacCatalyst, 13, 1, message: "Use 'AudioUnit' instead.")]
[BaseType (typeof (UIView))]
interface CAInterAppAudioSwitcherView {
[Export ("initWithFrame:")]
NativeHandle Constructor (CGRect bounds);
[Export ("showingAppNames")]
bool ShowingAppNames { [Bind ("isShowingAppNames")] get; set; }
[Export ("setOutputAudioUnit:")]
void SetOutputAudioUnit ([NullAllowed] AudioUnit.AudioUnit audioUnit);
[Export ("contentWidth")]
nfloat ContentWidth ();
}
/// <summary>A <see cref="T:UIKit.UIView" /> that shows the standard inter-app audio transport view (rewind, play, record, time, etc.).</summary>
///
/// <related type="externalDocumentation" href="path_to_url">Apple documentation for <c>CAInterAppAudioTransportView</c></related>
[NoMac]
[Deprecated (PlatformName.iOS, 13, 0, message: "Use 'AudioUnit' instead.")]
[NoMacCatalyst]
[Deprecated (PlatformName.MacCatalyst, 13, 1, message: "Use 'AudioUnit' instead.")]
[BaseType (typeof (UIView))]
interface CAInterAppAudioTransportView {
[Export ("initWithFrame:")]
NativeHandle Constructor (CGRect bounds);
[Export ("enabled")]
bool Enabled { [Bind ("isEnabled")] get; set; }
[Export ("playing")]
bool Playing { [Bind ("isPlaying")] get; }
[Export ("recording")]
bool Recording { [Bind ("isRecording")] get; }
[Export ("connected")]
bool Connected { [Bind ("isConnected")] get; }
[Export ("labelColor", ArgumentSemantic.Retain)]
UIColor LabelColor { get; set; }
// [NullAllowed] // by default this property is null
// NSInvalidArgumentException *** -[__NSPlaceholderDictionary initWithObjects:forKeys:count:]: attempt to insert nil object from objects[0]
[Export ("currentTimeLabelFont", ArgumentSemantic.Retain)]
UIFont CurrentTimeLabelFont { get; set; }
[Export ("rewindButtonColor", ArgumentSemantic.Retain)]
UIColor RewindButtonColor { get; set; }
[Export ("playButtonColor", ArgumentSemantic.Retain)]
UIColor PlayButtonColor { get; set; }
[Export ("pauseButtonColor", ArgumentSemantic.Retain)]
UIColor PauseButtonColor { get; set; }
[Export ("recordButtonColor", ArgumentSemantic.Retain)]
UIColor RecordButtonColor { get; set; }
[Export ("setOutputAudioUnit:")]
void SetOutputAudioUnit (AudioUnit.AudioUnit audioUnit);
}
#endif
[Mac (13, 0), iOS (16, 0)]
[MacCatalyst (16, 0)]
[BaseType (typeof (UIViewController))]
interface AUGenericViewController {
[DesignatedInitializer]
[Export ("initWithNibName:bundle:")]
NativeHandle Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
[NullAllowed, Export ("auAudioUnit", ArgumentSemantic.Strong)]
AUAudioUnit AuAudioUnit { get; set; }
}
}
```
|
Lecanora loekoesii is a species of corticolous (bark-dwelling), crustose lichen in the family Lecanoraceae. Found in South Korea, it was formally described as a new species in 2011 by Lei Lü, Yogesh Joshi, and Jae-Seoun Hur. The type specimen was collected on Mount Taebaek (Taebaek, Gangwon Province) at an altitude of ; here it was found growing on oak bark. It is only known to occur at the type locality. The specific epithet loekoesii honours Hungarian lichenologist László Lőkös, who collected the type specimen.
Description
The lichen forms a thin, grey, crust-like thallus that lacks soredia, pruina, and a prothallus. Its asci contains from 12 to 16 ascospores, each of which are ellipsoid, hyaline, and typically measure 12.6–15.3 by 7.5–8.5 μm. It contains several secondary chemicals, including atranorin, usnic acid, zeorin, and norstictic acid.
See also
List of Lecanora species
References
loekoesii
Lichen species
Lichens described in 2011
Lichens of Asia
|
The 1998 Arab Cup is the seventh edition of the Arab Cup hosted by Qatar, in Doha. Saudi Arabia won their first title.
Qualifying
The 12 qualified teams are:
Venues
Squads
Overview
Algeria, Egypt and Morocco did not send their senior national teams but instead sent their Under-23 teams to the competition.
Group stage
Group A
Group B
Group C
Group D
Knockout stage
Semi-finals
Third place play-off
Final
Result
Awards
Top Scorer:
Obeid Al-Dosari (8 goals)
Most Valuable Player:
Badr Haji
Mubarak Mustafa
Best Keeper:
Mohammed Al-Deayea
References
External links
Details in RSSSF
More Details
Arab Cup, 1998
Arab
Arab
International association football competitions hosted by Qatar
September 1998 sports events in Asia
October 1998 sports events in Asia
|
Caldwell station was the fourth of six stations on the Erie Railroad Caldwell Branch, located in Caldwell, New Jersey. The station was located on Bloomfield Avenue (County Route 506) just north-east of Caldwell College (now Caldwell University). The station opened in 1891 as the terminus of the Caldwell Railroad, a branch of the New York and Greenwood Lake Railroad that forked off at Great Notch station in Little Falls, Passaic County.
Caldwell station was one of two stations in the borough, the other being located at the Monomonock Inn, a local hotel that closed in 1940. Service was extended in 1891 to nearby Essex Fells. The original station in Caldwell, built in June 1891, was moved by horse to nearby Verona station in 1905 after the latter burned down. The railroad used 12 horses to get the depot, which was serving as a freight depot, down to Verona.
Caldwell station existed through the end of service on the Caldwell Branch, when the Erie-Lackawanna Railroad discontinued service on September 30, 1966. The borough had the station demolished a year prior on August 6, 1965.
History
Caldwell station opened with the construction of the Caldwell Branch of the New York and Greenwood Lake Railroad (a subsidiary of the Erie Railroad system). The original proposed service through Caldwell was the Caldwell Railroad, a company founded in March 1869 for the construction of a railroad between Montclair and Caldwell. Construction began in 1872 of the railroad. However, work on this route was suspended in 1872 due to the inability to complete a tunnel through Montclair and nearby Verona. About of the tunnel was left uncompleted.
The railroad was built in 1891, with the route via Great Notch station in Little Falls. As part of the construction, a depot, measured at , was built for the terminal of the new railroad. Service on the railroad began on July 4, 1891. Service, one year later, was extended to nearby Essex Fells.
The station was replaced in 1904 as part of the construction of the Morristown and Caldwell Railroad. Construction of this new station cost the Erie Railroad $20,000 (1904 USD). The new station would do the work of the Erie Railroad and the Morristown and Caldwell Railroad. This new depot was measured at . On July 4, 1904, thirteen years after the commencement of service through Caldwell, the first train of the Morristown and Caldwell crossed through the borough. The old station, built in 1891, was moved across the tracks, serving as a freight house.
On January 9, 1905, the passenger station built at the nearby Verona station caught fire. The depot, along with its contents, were burned and lost. The Erie Railroad decided to take the old station at Caldwell, serving as a freight depot, to become the new passenger depot at Verona. In February 1905, the snow-covered ground served as an opportunity to move the depot. With 12 horses, the old freight depot was moved up Bloomfield Avenue on rafters to Depot Street and Personette Street. This depot burned down in the winter of 1962.
In July 1907, commuters were confused when they came to Caldwell station and found the doors locked. Henry Banta, the newly-appointed station agent, had left town and locked the station without telling anyone. When an employee from Pavonia Terminal came to Caldwell to open the station, they found everything in good condition with all books and details in place. Banta, like his predecessor, John I. Jacobus, is believed to have left due to the incredible amount of work it was taking with no assistant.
In 1902, the Monomonock Inn, a local hotel and resort, opened on the east side of Prospect St, between Bloomfield Ave and Academy Rd. This helped influence the growth of Caldwell, to the extent that by 1916, the inn itself had its own station on the Caldwell Branch. The Inn was closed and razed in 1940, to be replaced by local housing and an A&P grocery store. Local streetcar service, which ran next to the Caldwell station on Bloomfield Avenue ended in 1952.
The borough of Caldwell purchased the depot in 1965 from the cash-strapped Erie Lackawanna Railroad. (The Erie Railroad and the Delaware, Lackawanna and Western Railroad had merged on October 17, 1960, as they were both struggling financially.) The borough razed the depot on August 6, 1965. Service at Caldwell station ended on September 30, 1966, when multiple branch lines of the Erie Lackawanna were discontinued.
References
Bibliography
External links
Caldwell Photos - First Baptist Church of Bloomfield
Railway stations in the United States opened in 1891
Caldwell
Railway stations in Essex County, New Jersey
Infrastructure completed in 1891
1891 establishments in New Jersey
Caldwell, New Jersey
Former railway stations in New Jersey
1966 disestablishments in New Jersey
Railway stations in the United States closed in 1966
|
The q-Gaussian is a probability distribution arising from the maximization of the Tsallis entropy under appropriate constraints. It is one example of a Tsallis distribution. The q-Gaussian is a generalization of the Gaussian in the same way that Tsallis entropy is a generalization of standard Boltzmann–Gibbs entropy or Shannon entropy. The normal distribution is recovered as q → 1.
The q-Gaussian has been applied to problems in the fields of statistical mechanics, geology, anatomy, astronomy, economics, finance, and machine learning. The distribution is often favored for its heavy tails in comparison to the Gaussian for 1 < q < 3. For the q-Gaussian distribution is the PDF of a bounded random variable. This makes in biology and other domains the q-Gaussian distribution more suitable than Gaussian distribution to model the effect of external stochasticity. A generalized q-analog of the classical central limit theorem was proposed in 2008, in which the independence constraint for the i.i.d. variables is relaxed to an extent defined by the q parameter, with independence being recovered as q → 1. However, a proof of such a theorem is still lacking.
In the heavy tail regions, the distribution is equivalent to the Student's t-distribution with a direct mapping between q and the degrees of freedom. A practitioner using one of these distributions can therefore parameterize the same distribution in two different ways. The choice of the q-Gaussian form may arise if the system is non-extensive, or if there is lack of a connection to small samples sizes.
Characterization
Probability density function
The standard q-Gaussian has the probability density function
where
is the q-exponential and the normalization factor is given by
Note that for the q-Gaussian distribution is the PDF of a bounded random variable.
Cumulative density function
For cumulative density function is
where is the hypergeometric function. As the hypergeometric function is defined for but x is unbounded, Pfaff transformation could be used.
For ,
Entropy
Just as the normal distribution is the maximum information entropy distribution for fixed values of the first moment and second moment (with the fixed zeroth moment corresponding to the normalization condition), the q-Gaussian distribution is the maximum Tsallis entropy distribution for fixed values of these three moments.
Related distributions
Student's t-distribution
While it can be justified by an interesting alternative form of entropy, statistically it is a scaled reparametrization of the Student's t-distribution introduced by W. Gosset in 1908 to describe small-sample statistics. In Gosset's original presentation the degrees of freedom parameter ν was constrained to be a positive integer related to the sample size, but it is readily observed that Gosset's density function is valid for all real values of ν. The scaled reparametrization introduces the alternative parameters q and β which are related to ν.
Given a Student's t-distribution with ν degrees of freedom, the equivalent q-Gaussian has
with inverse
Whenever , the function is simply a scaled version of Student's t-distribution.
It is sometimes argued that the distribution is a generalization of Student's t-distribution to negative and or non-integer degrees of freedom. However, the theory of Student's t-distribution extends trivially to all real degrees of freedom, where the support of the distribution is now compact rather than infinite in the case of ν < 0.
Three-parameter version
As with many distributions centered on zero, the q-Gaussian can be trivially extended to include a location parameter μ. The density then becomes defined by
Generating random deviates
The Box–Muller transform has been generalized to allow random sampling from q-Gaussians. The standard Box–Muller technique generates pairs of independent normally distributed variables from equations of the following form.
The generalized Box–Muller technique can generates pairs of q-Gaussian deviates that are not independent. In practice, only a single deviate will be generated from a pair of uniformly distributed variables. The following formula will generate deviates from a q-Gaussian with specified parameter q and
where is the q-logarithm and
These deviates can be transformed to generate deviates from an arbitrary q-Gaussian by
Applications
Physics
It has been shown that the momentum distribution of cold atoms in dissipative optical lattices is a q-Gaussian.
The q-Gaussian distribution is also obtained as the asymptotic probability density function of the position of the unidimensional motion of a mass subject to two forces: a deterministic force of the type (determining an infinite potential well) and a stochastic white noise force , where is a white noise. Note that in the overdamped/small mass approximation the above-mentioned convergence fails for , as recently shown.
Finance
Financial return distributions in the New York Stock Exchange, NASDAQ and elsewhere have been interpreted as q-Gaussians.
See also
Constantino Tsallis
Tsallis statistics
Tsallis entropy
Tsallis distribution
q-exponential distribution
Q-Gaussian process
Notes
Further reading
Juniper, J. (2007) , Centre of Full Employment and Equity, The University of Newcastle, Australia
External links
Tsallis Statistics, Statistical Mechanics for Non-extensive Systems and Long-Range Interactions
Statistical mechanics
Continuous distributions
Probability distributions with non-finite variance
|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.beam.sdk.nexmark.model;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import org.apache.beam.sdk.coders.Coder;
import org.apache.beam.sdk.coders.CoderException;
import org.apache.beam.sdk.coders.CustomCoder;
import org.apache.beam.sdk.coders.StringUtf8Coder;
import org.apache.beam.sdk.nexmark.NexmarkUtils;
import org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.base.Objects;
import org.checkerframework.checker.nullness.qual.Nullable;
/** Result of query 10. */
@SuppressWarnings({
"nullness" // TODO(path_to_url
})
public class Done implements KnownSize, Serializable {
private static final Coder<String> STRING_CODER = StringUtf8Coder.of();
public static final Coder<Done> CODER =
new CustomCoder<Done>() {
@Override
public void encode(Done value, OutputStream outStream) throws CoderException, IOException {
STRING_CODER.encode(value.message, outStream);
}
@Override
public Done decode(InputStream inStream) throws CoderException, IOException {
String message = STRING_CODER.decode(inStream);
return new Done(message);
}
@Override
public void verifyDeterministic() throws NonDeterministicException {}
@Override
public Object structuralValue(Done v) {
return v;
}
};
@JsonProperty private final String message;
// For Avro only.
@SuppressWarnings("unused")
public Done() {
message = null;
}
public Done(String message) {
this.message = message;
}
@Override
public long sizeInBytes() {
return message.length();
}
@Override
public String toString() {
try {
return NexmarkUtils.MAPPER.writeValueAsString(this);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean equals(@Nullable Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Done done = (Done) o;
return Objects.equal(message, done.message);
}
@Override
public int hashCode() {
return Objects.hashCode(message);
}
}
```
|
Until the End of Time is the third studio album by New Zealand rock band, Opshop.
Background and release
Jason Kerrison, Opshop's lead singer, said of the title of Until the End of Time "it's more of a romantic notion than a cataclysmic one. Human society has found itself in a time where you've got an unprecedented number of cultures predicting an end time, and you know, is that a sheer fluke."
The album was released on the Rhythmethod label on 2 August 2010.
Critical reception
Russell Baillie from The New Zealand Herald gave the album five-out-of-five stars, saying that "its sonic sheen and sincerity is just going to reinforce their status as the era's band of the people".
Chart performance
Until the End of Time debuted on the New Zealand Albums Chart on 9 August 2010 at number one.
Track listing
"Pins and Needles" – 4:33
"Love Will Always Win" – 4:00
"Through" – 5:26
"Paradox" – 3:33
"Madness & Other Allergies" – 3:55
"Monsters Under the Bed" – 4:25
"A Fine Mess We're In" – 4:35
"Sunday's Best Clothes" – 4:13
"Everything to Someone" – 4:09
"Nowhere Fast" – 4:08
"All for You" – 4:06
"Clarity" – 4:32
"Prophecy" - 3:04
Source: iTunes Store
Personnel
Clint Harris – bass guitar, vocals
Bobby Kennedy – drums
Jason Kerrison – vocals, guitars, keyboards
Matt Treacy – guitars, vocals
Source: Marbecks
References
External links
2010 albums
Opshop albums
Albums produced by Greg Haver
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var constantFunction = require( '@stdlib/utils/constant-function' );
var isnan = require( '@stdlib/math/base/assert/is-nan' );
var exp = require( '@stdlib/math/base/special/exp' );
var pow = require( '@stdlib/math/base/special/pow' );
var ln = require( '@stdlib/math/base/special/ln' );
// MAIN //
/**
* Returns a function for evaluating the moment-generating function (MGF) of a negative binomial distribution.
*
* @param {PositiveNumber} r - number of successes until experiment is stopped
* @param {Probability} p - success probability
* @returns {Function} MGF
*
* @example
* var mgf = factory( 4.3, 0.4 );
* var y = mgf( 0.2 );
* // returns ~4.696
*/
function factory( r, p ) {
if (
isnan( r ) ||
isnan( p ) ||
r <= 0.0 ||
p < 0.0 ||
p > 1.0
) {
return constantFunction( NaN );
}
return mgf;
/**
* Evaluates the moment-generating function (MGF) for a negative binomial distribution.
*
* @private
* @param {number} t - input value
* @returns {number} evaluated MGF
*
* @example
* var y = mgf( 0.5 );
* // returns <number>
*/
function mgf( t ) {
if ( t >= -ln( p ) ) {
return NaN;
}
return pow( ( (1.0 - p) * exp( t ) ) / ( 1.0 - (p * exp( t )) ), r );
}
}
// EXPORTS //
module.exports = factory;
```
|
```python
# This file is part of h5py, a Python interface to the HDF5 library.
#
# path_to_url
#
#
# and contributor agreement.
from __future__ import absolute_import
from h5py import h5
from ..common import TestCase
def fixnames():
cfg = h5.get_config()
cfg.complex_names = ('r','i')
class TestH5(TestCase):
def test_config(self):
cfg = h5.get_config()
self.assertIsInstance(cfg, h5.H5PYConfig)
cfg2 = h5.get_config()
self.assertIs(cfg, cfg2)
def test_cnames_get(self):
cfg = h5.get_config()
self.assertEqual(cfg.complex_names, ('r','i'))
def test_cnames_set(self):
self.addCleanup(fixnames)
cfg = h5.get_config()
cfg.complex_names = ('q','x')
self.assertEqual(cfg.complex_names, ('q','x'))
def test_cnames_set_exc(self):
self.addCleanup(fixnames)
cfg = h5.get_config()
with self.assertRaises(TypeError):
cfg.complex_names = ('q','i','v')
self.assertEqual(cfg.complex_names, ('r','i'))
def test_repr(self):
cfg = h5.get_config()
repr(cfg)
```
|
```yaml
version: '3.8'
networks:
web:
services:
nginx:
image: nginx
ports:
- 80:80
networks:
- web
```
|
The 1982 San Miguel Beermen season was the eight season of the franchise in the Philippine Basketball Association (PBA)
Transactions
Awards
Marte Saldana was named the season's Rookie of the Year.
Norman Black was voted the Reinforced Filipino Conference Best Import.
Summary
San Miguel had signed up Norman Black, who played for the disbanded Tefilin ballclub in the previous conference from last season, as their import for all three conferences of the 1982 PBA season. The Beermen emerge with the best record in the elimination phase of the Reinforced Filipino Conference with 13 wins and five losses. San Miguel went on to play the U/tex Wranglers in the best-of-five semifinal series, winning three games to one, to enter the finals against the Toyota Super Corollas. The Beermen led the series by winning the first two games, but Toyota came back to win the championship that went to a full limit of seven games.
In the five-team Asian Invitational Championship that includes a visiting squad from South Korea, the Beermen were on their second straight finals appearance in the season, they played the Crispa Redmanizers in the best-of-three title series. San Miguel beat Crispa, 103-102, in the deciding third game to win the Invitational title and their second PBA crown.
Norman Black would teamed up with Terry Sykes in the Open Conference. Sykes was replaced by Marvin Johnson after the Beermen lost their first two games. Johnson played five games in the elimination phase until former import Aaron James was recalled back and played together with Norman Black for the rest of the conference. San Miguel finish the elimination phase with 10 wins and eight losses and advances to the semifinal round along with Toyota and early qualifiers N-Rich Coffee and Gilbey's by posting a 2-1 won-loss slate in the quarterfinal round and winning their do-or-die encounter with U/tex. In the semifinal round, the Beermen lost to Gilbey's Gin, 101-102, in their last assignment on December 7 and failed to create a four-way tie for the two finals berth.
Won-loss records vs Opponents
Roster
Trades
References
San Miguel Beermen seasons
San
|
```css
The `clip-path` property works only on absolutely positioned elements
`Border-radius` property can use `slash syntax(/)`
Manipulating shapes using CSS: `border`
Making shapes with `transform`
Use the `box-shadow` property to create shadow effects on an element
```
|
```css
.myClass {
display: block;
}
```
|
The Regional English Language Officer (RELO) is a position with the United States Department of State. The position serves under the Bureau of Educational and Cultural Affairs (ECA). RELOs are located throughout the world as career foreign service officers and participate in what can be considered soft power diplomacy by the United States.
Background
There are currently 25 RELOs located around the world. Each officer has a budget of several million dollars used to enact programs that further the English language globally. These programs include, but are not limited to, distribution of the American literature, providing support to English teachers around the world, English teacher training, material support to public and private institutions that teach English, teacher exchanges, student exchanges, English language summer camps abroad, and more. The program was started in the 1950s.
References
United States Department of State
Diplomacy
Bureau of Educational and Cultural Affairs
|
```php
<?php
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
require __DIR__ . '/../Header.php';
// Create temporary file that will be read
$sampleSpreadsheet = require __DIR__ . '/../templates/sampleSpreadsheet.php';
$filename = $helper->getTemporaryFilename();
$writer = new Xlsx($sampleSpreadsheet);
$writer->save($filename);
$callStartTime = microtime(true);
$spreadsheet = IOFactory::load($filename);
$helper->logRead('Xlsx', $filename, $callStartTime);
// Save
$helper->write($spreadsheet, __FILE__);
unlink($filename);
```
|
Abbey Junction railway station was the railway junction where the branch line to Silloth on the Solway Firth divided from the Solway Junction Railway in the English county of Cumberland (later Cumbria).
History
A station on the site was opened as Abbeyholme by the Carlisle and Silloth Bay Railway in 1856, and was then renamed Abbey Junction by the North British Railway in 1870. It closed in 1921.
A parallel station on the site was opened as Abbey Junction by the Maryport and Carlisle Railway. It closed briefly from 1917 to 1919 then permanently in 1921.
The closure of the stations was linked to the closure of the Solway viaduct.
References
Sources
External links
The station on a navigable Edwardian 6" OS map, via National Library of Scotland
Carlisle & Silloth Bay Railway
The line with period photographs, via Holme St Cuthbert History Group (archive copy)
The station via Rail Map Online
Disused railway stations in Cumbria
Former North British Railway stations
Railway stations in Great Britain opened in 1856
Railway stations in Great Britain closed in 1921
Former Caledonian Railway stations
Railway stations in Great Britain opened in 1870
Railway stations in Great Britain closed in 1917
Railway stations in Great Britain opened in 1919
1856 establishments in England
1921 disestablishments in England
|
Prilutskaya () is a rural locality (a village) in Ust-Velskoye Rural Settlement of Velsky District, Arkhangelsk Oblast, Russia. The population was 331 as of 2014. There are 4 streets.
Geography
Prilutskaya is located on the Vel River, 9 km west of Velsk (the district's administrative centre) by road. Silyutinsky is the nearest rural locality.
References
Rural localities in Velsky District
|
```go
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package utils
import (
"context"
"net"
"net/http"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/pingcap/kvproto/pkg/diagnosticspb"
"github.com/pingcap/log"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
"github.com/soheilhy/cmux"
"github.com/tikv/pd/pkg/errs"
"github.com/tikv/pd/pkg/mcs/discovery"
"github.com/tikv/pd/pkg/mcs/utils/constant"
"github.com/tikv/pd/pkg/utils/apiutil"
"github.com/tikv/pd/pkg/utils/apiutil/multiservicesapi"
"github.com/tikv/pd/pkg/utils/etcdutil"
"github.com/tikv/pd/pkg/utils/grpcutil"
"github.com/tikv/pd/pkg/utils/logutil"
"github.com/tikv/pd/pkg/versioninfo"
etcdtypes "go.etcd.io/etcd/client/pkg/v3/types"
clientv3 "go.etcd.io/etcd/client/v3"
"go.uber.org/zap"
"google.golang.org/grpc"
"google.golang.org/grpc/keepalive"
)
// InitClusterID initializes the cluster ID.
func InitClusterID(ctx context.Context, client *clientv3.Client) (id uint64, err error) {
ticker := time.NewTicker(constant.RetryInterval)
defer ticker.Stop()
retryTimes := 0
for {
if clusterID, err := etcdutil.GetClusterID(client, constant.ClusterIDPath); err == nil && clusterID != 0 {
return clusterID, nil
}
select {
case <-ctx.Done():
return 0, err
case <-ticker.C:
retryTimes++
if retryTimes/500 > 0 {
log.Warn("etcd is not ready, retrying", errs.ZapError(err))
retryTimes /= 500
}
}
}
}
// PromHandler is a handler to get prometheus metrics.
func PromHandler() gin.HandlerFunc {
return func(c *gin.Context) {
// register promhttp.HandlerOpts DisableCompression
promhttp.InstrumentMetricHandler(prometheus.DefaultRegisterer, promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{
DisableCompression: true,
})).ServeHTTP(c.Writer, c.Request)
}
}
// StatusHandler is a handler to get status info.
func StatusHandler(c *gin.Context) {
svr := c.MustGet(multiservicesapi.ServiceContextKey).(server)
version := versioninfo.Status{
BuildTS: versioninfo.PDBuildTS,
GitHash: versioninfo.PDGitHash,
Version: versioninfo.PDReleaseVersion,
StartTimestamp: svr.StartTimestamp(),
}
c.IndentedJSON(http.StatusOK, version)
}
type server interface {
GetAdvertiseListenAddr() string
GetBackendEndpoints() string
Context() context.Context
GetTLSConfig() *grpcutil.TLSConfig
GetClientConns() *sync.Map
GetDelegateClient(ctx context.Context, tlsCfg *grpcutil.TLSConfig, forwardedHost string) (*grpc.ClientConn, error)
ServerLoopWgDone()
ServerLoopWgAdd(int)
IsClosed() bool
GetHTTPServer() *http.Server
GetGRPCServer() *grpc.Server
SetGRPCServer(*grpc.Server)
SetHTTPServer(*http.Server)
GetEtcdClient() *clientv3.Client
SetEtcdClient(*clientv3.Client)
SetHTTPClient(*http.Client)
IsSecure() bool
RegisterGRPCService(*grpc.Server)
SetUpRestHandler() (http.Handler, apiutil.APIServiceGroup)
diagnosticspb.DiagnosticsServer
StartTimestamp() int64
Name() string
}
// InitClient initializes the etcd and http clients.
func InitClient(s server) error {
tlsConfig, err := s.GetTLSConfig().ToTLSConfig()
if err != nil {
return err
}
backendUrls, err := etcdtypes.NewURLs(strings.Split(s.GetBackendEndpoints(), ","))
if err != nil {
return err
}
etcdClient, err := etcdutil.CreateEtcdClient(tlsConfig, backendUrls, "mcs-etcd-client")
if err != nil {
return err
}
s.SetEtcdClient(etcdClient)
s.SetHTTPClient(etcdutil.CreateHTTPClient(tlsConfig))
return nil
}
func startGRPCServer(s server, l net.Listener) {
defer logutil.LogPanic()
defer s.ServerLoopWgDone()
log.Info("grpc server starts serving", zap.String("address", l.Addr().String()))
err := s.GetGRPCServer().Serve(l)
if s.IsClosed() {
log.Info("grpc server stopped")
} else {
log.Fatal("grpc server stopped unexpectedly", errs.ZapError(err))
}
}
func startHTTPServer(s server, l net.Listener) {
defer logutil.LogPanic()
defer s.ServerLoopWgDone()
log.Info("http server starts serving", zap.String("address", l.Addr().String()))
err := s.GetHTTPServer().Serve(l)
if s.IsClosed() {
log.Info("http server stopped")
} else {
log.Fatal("http server stopped unexpectedly", errs.ZapError(err))
}
}
// StartGRPCAndHTTPServers starts the grpc and http servers.
func StartGRPCAndHTTPServers(s server, serverReadyChan chan<- struct{}, l net.Listener) {
defer logutil.LogPanic()
defer s.ServerLoopWgDone()
mux := cmux.New(l)
// Don't hang on matcher after closing listener
mux.SetReadTimeout(3 * time.Second)
grpcL := mux.MatchWithWriters(cmux.HTTP2MatchHeaderFieldSendSettings("content-type", "application/grpc"))
var httpListener net.Listener
if s.IsSecure() {
httpListener = mux.Match(cmux.Any())
} else {
httpListener = mux.Match(cmux.HTTP1())
}
grpcServer := grpc.NewServer(
// Allow clients send consecutive pings in every 5 seconds.
// The default value of MinTime is 5 minutes,
// which is too long compared with 10 seconds of TiKV's pd client keepalive time.
grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
MinTime: 5 * time.Second,
}),
)
s.SetGRPCServer(grpcServer)
s.RegisterGRPCService(grpcServer)
diagnosticspb.RegisterDiagnosticsServer(grpcServer, s)
s.ServerLoopWgAdd(1)
go startGRPCServer(s, grpcL)
handler, _ := s.SetUpRestHandler()
s.SetHTTPServer(&http.Server{
Handler: handler,
ReadTimeout: 3 * time.Second,
})
s.ServerLoopWgAdd(1)
go startHTTPServer(s, httpListener)
serverReadyChan <- struct{}{}
if err := mux.Serve(); err != nil {
if s.IsClosed() {
log.Info("mux stopped serving", errs.ZapError(err))
} else {
log.Fatal("mux stopped serving unexpectedly", errs.ZapError(err))
}
}
}
// StopHTTPServer stops the http server.
func StopHTTPServer(s server) {
log.Info("stopping http server")
defer log.Info("http server stopped")
ctx, cancel := context.WithTimeout(context.Background(), constant.DefaultHTTPGracefulShutdownTimeout)
defer cancel()
// First, try to gracefully shutdown the http server
ch := make(chan struct{})
go func() {
defer close(ch)
if err := s.GetHTTPServer().Shutdown(ctx); err != nil {
log.Error("http server graceful shutdown failed", errs.ZapError(err))
}
}()
select {
case <-ch:
case <-ctx.Done():
// Took too long, manually close open transports
log.Warn("http server graceful shutdown timeout, forcing close")
if err := s.GetHTTPServer().Close(); err != nil {
log.Warn("http server close failed", errs.ZapError(err))
}
// concurrent Graceful Shutdown should be interrupted
<-ch
}
}
// StopGRPCServer stops the grpc server.
func StopGRPCServer(s server) {
log.Info("stopping grpc server")
defer log.Info("grpc server stopped")
// Do not grpc.Server.GracefulStop with TLS enabled etcd server
// See path_to_url#issuecomment-317124531
// and path_to_url
if s.IsSecure() {
s.GetGRPCServer().Stop()
return
}
ctx, cancel := context.WithTimeout(context.Background(), constant.DefaultGRPCGracefulStopTimeout)
defer cancel()
// First, try to gracefully shutdown the grpc server
ch := make(chan struct{})
go func() {
defer close(ch)
// Close listeners to stop accepting new connections,
// will block on any existing transports
s.GetGRPCServer().GracefulStop()
}()
// Wait until all pending RPCs are finished
select {
case <-ch:
case <-ctx.Done():
// Took too long, manually close open transports
// e.g. watch streams
log.Warn("grpc server graceful shutdown timeout, forcing close")
s.GetGRPCServer().Stop()
// concurrent GracefulStop should be interrupted
<-ch
}
}
// Register registers the service.
func Register(s server, serviceName string) (uint64, *discovery.ServiceRegistryEntry, *discovery.ServiceRegister, error) {
var (
clusterID uint64
err error
)
if clusterID, err = InitClusterID(s.Context(), s.GetEtcdClient()); err != nil {
return 0, nil, nil, err
}
log.Info("init cluster id", zap.Uint64("cluster-id", clusterID))
execPath, err := os.Executable()
deployPath := filepath.Dir(execPath)
if err != nil {
deployPath = ""
}
serviceID := &discovery.ServiceRegistryEntry{
ServiceAddr: s.GetAdvertiseListenAddr(),
Version: versioninfo.PDReleaseVersion,
GitHash: versioninfo.PDGitHash,
DeployPath: deployPath,
StartTimestamp: s.StartTimestamp(),
Name: s.Name(),
}
serializedEntry, err := serviceID.Serialize()
if err != nil {
return 0, nil, nil, err
}
serviceRegister := discovery.NewServiceRegister(s.Context(), s.GetEtcdClient(), strconv.FormatUint(clusterID, 10),
serviceName, s.GetAdvertiseListenAddr(), serializedEntry, discovery.DefaultLeaseInSeconds)
if err := serviceRegister.Register(); err != nil {
log.Error("failed to register the service", zap.String("service-name", serviceName), errs.ZapError(err))
return 0, nil, nil, err
}
return clusterID, serviceID, serviceRegister, nil
}
// Exit exits the program with the given code.
func Exit(code int) {
log.Sync()
os.Exit(code)
}
```
|
```objective-c
/* $OpenBSD: extern.h,v 1.7 2024/05/19 10:30:43 jsg Exp $*/
/*
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from: @(#)extern.h 8.1 (Berkeley) 6/4/93
*/
char *autobaud(void);
void gendefaults(void);
void gettable(char *, char *);
void makeenv(char *[]);
char *portselector(void);
void setchars(void);
void setdefaults(void);
void setflags(int);
```
|
```go
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"net/http"
)
var (
_ = http.Client
)
```
|
```java
/*
* All Rights Reserved.
*/
package me.zhanghai.android.douya.network.api.info.frodo;
import android.os.Parcel;
import com.google.gson.annotations.SerializedName;
import java.util.ArrayList;
public class Game extends SimpleGame {
@SerializedName("aliases")
public ArrayList<String> alternativeTitles = new ArrayList<>();
public ArrayList<String> developers = new ArrayList<>();
@SerializedName("info_url")
public String informationUrl;
public ArrayList<String> publishers = new ArrayList<>();
public static final Creator<Game> CREATOR = new Creator<Game>() {
@Override
public Game createFromParcel(Parcel source) {
return new Game(source);
}
@Override
public Game[] newArray(int size) {
return new Game[size];
}
};
public Game() {}
protected Game(Parcel in) {
super(in);
alternativeTitles = in.createStringArrayList();
developers = in.createStringArrayList();
informationUrl = in.readString();
publishers = in.createStringArrayList();
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeStringList(alternativeTitles);
dest.writeStringList(developers);
dest.writeString(informationUrl);
dest.writeStringList(publishers);
}
}
```
|
Four-Mations was a regular animation strand broadcast in the United Kingdom on Channel 4 in the 1990s. The series featured short animated films, tributes, and sometimes a documentary on animation. The series was notable for co-financing some films and broadcasting animated films from around the world. The series was first broadcast in 1990 and finished in 1998.
In 2008 a website made for people to upload, view and share animated films and games 4mations, borrowing the 4 Mation title.
Notable animations
Notable animations broadcast as part of 4 Mations:
George Pal - Puppetoons
Knick Knack in its uncut form
Red's Dream
Tin Toy
Luxo Jr.
Films by Candy Guard - Fatty Issues, Hair, Alternative Fringe etc.
Nick Park - Creature Comforts
Daddie's Little Piece of Dresden China
Films by David Anderson such as Deadsy and The Door
Ah Pook Is Here
The Springer and the SS by Jiří Trnka
Films by Dianne Jackson
Paul Driessen - Tip Top, Elbowing, The Killing of an Egg, Sunny Side Up, On Land, at Sea and in the Air etc.
Bob Godfrey - Do It Yourself Cartoon Kit, Henry 9 To 5, It's a square world, Alf, Bill and Fred
Paul Klee - Taking a Line for a walk
Bill Plympton - Push Comes to Shove
Phil Mulloy - Cowboys
Chage and Aska - On Your Mark
Yellow Submarine
The Blue Gum Boy (film) (Banned Fourmation)
References
External links
BFi Film & TV Database listing for four mations
1990 British television series debuts
1998 British television series endings
1990s British animated television series
Channel 4 original programming
1990s in animation
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.