text
stringlengths 1
22.8M
|
|---|
```php
<?php
#
#
#
# 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.
#
require('acrawriter.php');
$random_keypair=phpthemis_gen_ec_key_pair();
create_acrastruct("some data", $random_keypair['public_key'], null);
echo "work\n";
```
|
Naber is a surname. Notable people with the surname include:
Alice Naber-Lozeman (born 1971), Dutch Olympic eventing rider
Bob Naber (1929–1998), American basketball player
Brian Naber (born 1949), American football coach
Gijs Naber (born 1980), Dutch actor
Herman Naber (1826–1909), American farmer, politician, and jurist
Johanna Naber (1859–1941), Dutch feminist, historian and author
John Naber (born 1956), American swimmer
Omar Naber (born 1981), Slovenian singer, songwriter and guitar player
Stephanie Al-Naber (born 1988), Jordanian footballer
Yousef Al-Naber (born 1989), Jordanian footballer
See also
NABERS
Nabor (disambiguation)
References
|
Gaillard II de Durfort (died 1422), Lord of Duras, Blanquefort, and Villandraut, and Seneschal of Gascony, was a 13th-14th century Gascon nobleman of the Durfort family.
Life
Durfort was the eldest son of Gaillard I de Durfort (died 1356) and Marguerite de Caumont. Gaillard was taken prisoner with Thomas Felton, the Seneschal of Gascony during a skirmish in 1377, near Eymet. Durfort was himself appointed Seneschal of Gascony and served between 1399 and 1415. Durfort died in 1422.
Marriage and issue
Gaillard married Eléonore, daughter of Roger Bernard, Count of Périgord and Eléonore de Vendome and is known to have had the following issue:
Gaillard III de Durfort, married Juliette de La Lande, had issue.
Durfort married secondly Jeanne de Lomagne, it is not known whether they had any issue.
Citations
References
Year of birth unknown
1422 deaths
Gascons
Seneschals of Gascony
|
```python
import json
import pytest
from CommonServerPython import arg_to_datetime
def test_dedup_elements():
from CohesityHeliosEventCollector import adjust_and_dedup_elements, ALERT_TIME_FIELD, AUDIT_LOGS_TIME_FIELD
"""
Case 1:
Given a list of 3 elements where all IDs appear in the ID list.
We expect the result list to have no elements at all and that the final list length was not changed.
"""
new_elements = [{'id': '1', 'latestTimestampUsecs': 1704096000000000},
{'id': '2', 'latestTimestampUsecs': 1704182400000000},
{'id': '3', 'latestTimestampUsecs': 1704268800000000}]
existing_element_ids = ['1', '2', '3']
deduped_elements = adjust_and_dedup_elements(new_elements=new_elements, existing_element_ids=existing_element_ids,
time_field_name='')
assert deduped_elements == []
assert len(new_elements) == 3
"""
Case 2:
Given a list of 2 elements where all elements appear in the existing ID list
We expect the result list to have no elements at all and that the final list length was not changed.
"""
new_elements = [{'id': '2', 'latestTimestampUsecs': 1704182400000000},
{'id': '3', 'latestTimestampUsecs': 1704268800000000}]
existing_element_ids = ['1', '2', '3']
deduped_elements = adjust_and_dedup_elements(new_elements=new_elements, existing_element_ids=existing_element_ids,
time_field_name='')
assert deduped_elements == []
assert len(new_elements) == 2
"""
Case 3:
Given a list of 3 elements where the first element appear in the existing ID list.
We expect the result list to have the other two elements and that the final list length was not changed.
"""
new_elements = [{'id': '1', 'latestTimestampUsecs': 1704096000000000},
{'id': '2', 'latestTimestampUsecs': 1704182400000000},
{'id': '3', 'latestTimestampUsecs': 1704268800000000}]
existing_element_ids = ['1']
deduped_elements = adjust_and_dedup_elements(new_elements=new_elements, existing_element_ids=existing_element_ids,
time_field_name=ALERT_TIME_FIELD)
assert deduped_elements == [{'id': '2', 'latestTimestampUsecs': 1704182400000000, '_time': '2024-01-02T08:00:00.000Z'},
{'id': '3', 'latestTimestampUsecs': 1704268800000000, '_time': '2024-01-03T08:00:00.000Z'}]
assert len(new_elements) == 3
"""
Case 4:
Given a list of 3 elements while the existing ID list is empty.
We expect the result list to have all elements and that the final list length was not changed.
"""
new_elements = [{'id': '1', 'timestampUsecs': 1704096000000000}, {'id': '2', 'timestampUsecs': 1704182400000000},
{'id': '3', 'timestampUsecs': 1704268800000000}]
existing_element_ids = []
deduped_elements = adjust_and_dedup_elements(new_elements=new_elements, existing_element_ids=existing_element_ids,
time_field_name=AUDIT_LOGS_TIME_FIELD)
assert deduped_elements == [{'id': '1', 'timestampUsecs': 1704096000000000, '_time': '2024-01-01T08:00:00.000Z'},
{'id': '2', 'timestampUsecs': 1704182400000000, '_time': '2024-01-02T08:00:00.000Z'},
{'id': '3', 'timestampUsecs': 1704268800000000, '_time': '2024-01-03T08:00:00.000Z'}]
assert len(new_elements) == 3
"""
Case 5:
Given an empty list elements.
We expect the result list to have no elements at all and that the final list length was not changed.
"""
new_elements = []
existing_element_ids = ['1', '2', '3']
deduped_elements = adjust_and_dedup_elements(new_elements=new_elements, existing_element_ids=existing_element_ids,
time_field_name='')
assert deduped_elements == []
assert len(new_elements) == 0
def test_get_earliest_event_ids_with_the_same_time():
from CohesityHeliosEventCollector import get_earliest_event_ids_with_the_same_time, ALERT_TIME_FIELD, AUDIT_LOGS_TIME_FIELD
time_field = ALERT_TIME_FIELD
"""
Case 1:
Given a list of Alert events where there is only one event that has the earliest timestamp
Ensure only the ID of the earliest Alert is returned
"""
events = [
{'latestTimestampUsecs': '3', 'id': 'c'},
{'latestTimestampUsecs': '2', 'id': 'b'},
{'latestTimestampUsecs': '1', 'id': 'a'}
]
earliest_event_fetched_ids = get_earliest_event_ids_with_the_same_time(events=events, time_field=time_field)
assert earliest_event_fetched_ids == ['a']
"""
Case 2:
Given a list of Alert events where there are two "earliest" events
Ensure the ID of the TWO earliest Alerts is returned
"""
events = [
{'latestTimestampUsecs': '3', 'id': 'd'},
{'latestTimestampUsecs': '2', 'id': 'c'},
{'latestTimestampUsecs': '1', 'id': 'b'},
{'latestTimestampUsecs': '1', 'id': 'a'}
]
earliest_event_fetched_ids = get_earliest_event_ids_with_the_same_time(events=events, time_field=time_field)
assert earliest_event_fetched_ids == ['a', 'b']
time_field = AUDIT_LOGS_TIME_FIELD
"""
Case 3:
Given a list of Audit Log events where there is only one event that has the earliest timestamp
Ensure only the ID of the earliest event is returned
"""
events = [
{'timestampUsecs': '3', 'id': 'c'},
{'timestampUsecs': '2', 'id': 'b'},
{'timestampUsecs': '1', 'id': 'a'}
]
earliest_event_fetched_ids = get_earliest_event_ids_with_the_same_time(events=events, time_field=time_field)
assert earliest_event_fetched_ids == ['a']
"""
Case 4:
Given a list of Audit Log events where there are two "earliest" events
Ensure the ID of the TWO earliest Audit logs is returned
"""
events = [
{'timestampUsecs': '3', 'id': 'd'},
{'timestampUsecs': '2', 'id': 'c'},
{'timestampUsecs': '1', 'id': 'b'},
{'timestampUsecs': '1', 'id': 'a'}
]
earliest_event_fetched_ids = get_earliest_event_ids_with_the_same_time(events=events, time_field=time_field)
assert earliest_event_fetched_ids == ['a', 'b']
def test_hash_fields_to_create_id():
"""
Given dummy audit log event with the relevant fields
Ensure the id is created correctly
"""
from CohesityHeliosEventCollector import hash_fields_to_create_id
event = {
'details': 'dummy_details',
'username': 'dummy_username',
'domain': 'dummy_domain',
'sourceType': 'dummy_sourceType',
'entityName': 'dummy_entityName',
'entityType': 'dummy_entityType',
'action': 'dummy_action',
'timestampUsecs': 'dummy_timestampUsecs',
'ip': 'dummy_ip',
'isImpersonation': 'dummy_isImpersonation',
'tenantId': 'dummy_tenantId',
'originalTenantId': 'dummy_originalTenantId',
'serviceContext': 'dummy_serviceContext'
}
_id = hash_fields_to_create_id(event)
assert _id == your_sha256_hash
class TestFetchEventsCommand:
"""
Class to test the different Fetch events flow.
Fetch events has test 3 case:
1: There are fewer events than page_size on first request
2: There are more than page_size events but there are less than max_fetch events
3: There are more than max_fetch events
"""
base_url = 'path_to_url
audit_logs_endpoint = 'mcm/audit-logs'
alerts_endpoint = 'mcm/alerts'
mock_time = '2024-01-01 10:00:00'
mock_fixed_time_unix = int(arg_to_datetime(mock_time).timestamp() * 1000000)
@staticmethod
def load_response(event_type) -> dict:
from CohesityHeliosEventCollector import EventType
filename = 'test_data/CohesityHeliosEventCollector-AuditLogList.json' if event_type == EventType.audit_log else \
'test_data/CohesityHeliosEventCollector-AlertList.json'
with open(filename) as f:
return json.loads(f.read())
@pytest.fixture()
def audit_logs_mock_res(self):
import CohesityHeliosEventCollector
return self.load_response(CohesityHeliosEventCollector.EventType.audit_log)
@pytest.fixture()
def alerts_mock_res(self):
import CohesityHeliosEventCollector
return self.load_response(CohesityHeliosEventCollector.EventType.alert)
def test_fetch_events_command_case_1(self, requests_mock, mocker, audit_logs_mock_res, alerts_mock_res):
"""
Case 1 is when where are fewer events (4) than page_size (10,000) on the first request.
We expect:
- Each event type API call to be called once
- To have only 4 events returned
- Audit logs next start time for the next fetch to be set to the latest pulled event timestamp plus 1
(170691857331523)
- No list of ids_for_dedup and no latest_event_fetched_timestamp for audit logs
- Alerts next start time for the next fetch to be set to the latest pulled event timestamp plus 1 (1708175775539274)
- No list of ids_for_dedup and no latest_event_fetched_timestamp for alerts
"""
from CohesityHeliosEventCollector import Client, fetch_events_command
# mockers
mocker.patch("CohesityHeliosEventCollector.arg_to_datetime", return_value=arg_to_datetime(self.mock_time))
audit_logs_call = requests_mock.get(f'{self.base_url}/{self.audit_logs_endpoint}', json=audit_logs_mock_res[0])
alerts_call = requests_mock.get(f'{self.base_url}/{self.alerts_endpoint}', json=alerts_mock_res[0])
client = Client(base_url=self.base_url)
events, last_run = fetch_events_command(client=client, last_run={}, max_fetch=1000)
assert audit_logs_call.call_count == alerts_call.call_count == 1
assert len(events) == 4
assert last_run['audit_cache']['next_start_timestamp'] == 170691857331523
assert not last_run['audit_cache']['ids_for_dedup']
assert not last_run['audit_cache']['latest_event_fetched_timestamp']
assert last_run['alert_cache']['next_start_timestamp'] == 1708175775539274
assert not last_run['alert_cache']['ids_for_dedup']
assert not last_run['audit_cache']['latest_event_fetched_timestamp']
def test_fetch_events_command_case_2(self, requests_mock, mocker, audit_logs_mock_res, alerts_mock_res):
"""
Case 2 is when there are more events (3) from each type than the page_size (2), but there are not more than max_fetch
(1000).
We expect:
- Each event type API call to be called twice
- That the endtimeusecs in the 2dn API call for audit logs will be the same as the time of the earliest event fetched
timestamp
- That the enddateusecs in the 2dn API call for alerts will be the same as the time of the earliest event fetched
timestamp
- To have 6 events returned
- Audit logs next start time for the next fetch to be set to the latest pulled event timestamp plus 1
(170691857331523)
- No list of ids_for_dedup and no latest_event_fetched_timestamp for audit logs
- Alerts next start time for the next fetch to be set to the latest pulled event timestamp plus 1 (1708175775539274)
- No list of ids_for_dedup and no latest_event_fetched_timestamp for alerts
"""
import CohesityHeliosEventCollector
from CohesityHeliosEventCollector import Client, fetch_events_command
# mockers
mocker.patch.object(CohesityHeliosEventCollector, 'PAGE_SIZE', 2)
mocker.patch("CohesityHeliosEventCollector.arg_to_datetime", return_value=arg_to_datetime(self.mock_time))
audit_logs_call = requests_mock.get(f'{self.base_url}/{self.audit_logs_endpoint}',
[{'json': audit_logs_mock_res[0]}, {'json': audit_logs_mock_res[2]}])
alerts_call = requests_mock.get(f'{self.base_url}/{self.alerts_endpoint}',
[{'json': alerts_mock_res[0]}, {'json': alerts_mock_res[2]}])
audit_logs_expected_end_time = audit_logs_mock_res[0].get('auditLogs')[1].get('timestampUsecs')
alerts_expected_end_time = alerts_mock_res[0].get('alertsList')[1].get('latestTimestampUsecs')
client = Client(base_url=self.base_url)
events, last_run = fetch_events_command(client=client, last_run={}, max_fetch=1000)
assert audit_logs_call.call_count == alerts_call.call_count == 2
assert audit_logs_call.request_history[1].qs['endtimeusecs'][0] == str(audit_logs_expected_end_time)
assert alerts_call.request_history[1].qs['enddateusecs'][0] == str(alerts_expected_end_time)
assert len(events) == 6
assert last_run['audit_cache']['next_start_timestamp'] == 170691857331523
assert not last_run['audit_cache']['ids_for_dedup']
assert not last_run['audit_cache']['latest_event_fetched_timestamp']
assert last_run['alert_cache']['next_start_timestamp'] == 1708175775539274
assert not last_run['alert_cache']['ids_for_dedup']
assert not last_run['alert_cache']['latest_event_fetched_timestamp']
def test_fetch_events_command_case_3(self, requests_mock, mocker, audit_logs_mock_res, alerts_mock_res):
"""
Case 3 is when there are more events than max_fetch events.
We expect:
- Each event type API call to be called twice
- That the endtimeusecs in the 2dn API call for audit logs will be the same as the time of the earliest event fetched
timestamp
- That the enddateusecs in the 2dn API call for alerts will be the same as the time of the earliest event fetched
timestamp
- To have 8 events returned
- Audit logs next start time for the next fetch to be set to the same initial start time
- ids_for_dedup in the audit_log cache has the ID of the earliest audit log event
- latest_event_fetched_timestamp in the audit_log cache holds the latest audit log event timestamp plus 1 sec
- Alerts next start time for the next fetch to be set to the same initial start time
- No list of ids_for_dedup and no latest_event_fetched_timestamp for alerts
- ids_for_dedup in the alerts cache has the ID of the earliest alert event
- latest_event_fetched_timestamp in the alerts cache holds the latest alert event timestamp plus 1 sec
"""
import CohesityHeliosEventCollector
from CohesityHeliosEventCollector import Client, fetch_events_command
# mockers
mocker.patch.object(CohesityHeliosEventCollector, 'PAGE_SIZE', 2)
mocker.patch("CohesityHeliosEventCollector.arg_to_datetime", return_value=arg_to_datetime(self.mock_time))
audit_logs_call = requests_mock.get(f'{self.base_url}/{self.audit_logs_endpoint}',
[{'json': audit_logs_mock_res[0]},
{'json': audit_logs_mock_res[1]}])
alerts_call = requests_mock.get(f'{self.base_url}/{self.alerts_endpoint}',
[{'json': alerts_mock_res[0]},
{'json': alerts_mock_res[1]}])
audit_logs_expected_end_time = audit_logs_mock_res[0].get('auditLogs')[1].get('timestampUsecs')
alerts_expected_end_time = alerts_mock_res[0].get('alertsList')[1].get('latestTimestampUsecs')
client = Client(base_url=self.base_url)
events, last_run = fetch_events_command(client=client, last_run={}, max_fetch=3)
assert audit_logs_call.call_count == alerts_call.call_count == 2
assert audit_logs_call.request_history[1].qs['endtimeusecs'][0] == str(audit_logs_expected_end_time)
assert alerts_call.request_history[1].qs['enddateusecs'][0] == str(alerts_expected_end_time)
assert len(events) == 8
assert last_run['audit_cache']['next_start_timestamp'] == self.mock_fixed_time_unix
assert last_run['audit_cache']['ids_for_dedup'] == [your_sha256_hash]
assert last_run['audit_cache']['latest_event_fetched_timestamp'] == 170691857331523
assert last_run['alert_cache']['next_start_timestamp'] == self.mock_fixed_time_unix
assert last_run['alert_cache']['ids_for_dedup'] == ['66770']
assert last_run['alert_cache']['latest_event_fetched_timestamp'] == 1708175775539274
```
|
```c++
/*!
@file
Defines `boost::hana::drop_back`.
@copyright Louis Dionne 2013-2017
(See accompanying file LICENSE.md or copy at path_to_url
*/
#ifndef BOOST_HANA_DROP_BACK_HPP
#define BOOST_HANA_DROP_BACK_HPP
#include <boost/hana/fwd/drop_back.hpp>
#include <boost/hana/at.hpp>
#include <boost/hana/concept/integral_constant.hpp>
#include <boost/hana/concept/sequence.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/core/dispatch.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/length.hpp>
#include <cstddef>
#include <utility>
BOOST_HANA_NAMESPACE_BEGIN
//! @cond
template <typename Xs, typename N>
constexpr auto drop_back_t::operator()(Xs&& xs, N const& n) const {
using S = typename hana::tag_of<Xs>::type;
using DropBack = BOOST_HANA_DISPATCH_IF(drop_back_impl<S>,
hana::Sequence<S>::value &&
hana::IntegralConstant<N>::value
);
#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
static_assert(hana::Sequence<S>::value,
"hana::drop_back(xs, n) requires 'xs' to be a Sequence");
static_assert(hana::IntegralConstant<N>::value,
"hana::drop_back(xs, n) requires 'n' to be an IntegralConstant");
#endif
static_assert(N::value >= 0,
"hana::drop_back(xs, n) requires 'n' to be non-negative");
return DropBack::apply(static_cast<Xs&&>(xs), n);
}
template <typename Xs>
constexpr auto drop_back_t::operator()(Xs&& xs) const {
return (*this)(static_cast<Xs&&>(xs), hana::size_c<1>);
}
//! @endcond
template <typename S, bool condition>
struct drop_back_impl<S, when<condition>> : default_ {
template <typename Xs, std::size_t ...n>
static constexpr auto drop_back_helper(Xs&& xs, std::index_sequence<n...>) {
return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs))...);
}
template <typename Xs, typename N>
static constexpr auto apply(Xs&& xs, N const&) {
constexpr std::size_t n = N::value;
constexpr std::size_t len = decltype(hana::length(xs))::value;
return drop_back_helper(static_cast<Xs&&>(xs),
std::make_index_sequence<(n > len ? 0 : len - n)>{});
}
};
BOOST_HANA_NAMESPACE_END
#endif // !BOOST_HANA_DROP_BACK_HPP
```
|
```yaml
admin:
address:
socket_address:
protocol: TCP
address: 0.0.0.0
port_value: 9901
static_resources:
listeners:
- name: listener_0
address:
socket_address:
protocol: TCP
address: 0.0.0.0
port_value: 10000
filter_chains:
- filters:
- name: envoy.filters.network.http_connection_manager
typed_config:
"@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
stat_prefix: ingress_http
access_log:
- name: envoy.access_loggers.stdout
typed_config:
"@type": type.googleapis.com/envoy.extensions.access_loggers.stream.v3.StdoutAccessLog
route_config:
name: local_route
virtual_hosts:
- name: local_service
domains: ["*"]
routes:
- match:
prefix: "/"
route:
host_rewrite_literal: www.envoyproxy.io
cluster: service_envoyproxy_io
http_filters:
- name: envoy.filters.http.router
typed_config:
"@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
clusters:
- name: service_envoyproxy_io
type: LOGICAL_DNS
# Comment out the following line to test on v6 networks
dns_lookup_family: V4_ONLY
lb_policy: ROUND_ROBIN
load_assignment:
cluster_name: service_envoyproxy_io
endpoints:
- lb_endpoints:
- endpoint:
address:
socket_address:
address: www.envoyproxy.io
port_value: 443
typed_extension_protocol_options:
envoy.extensions.upstreams.http.v3.HttpProtocolOptions:
"@type": type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions
explicit_http_config:
http2_protocol_options:
{}
http_filters:
- name: buffer
typed_config:
"@type": type.googleapis.com/envoy.extensions.filters.http.buffer.v3.Buffer
max_request_bytes: 5242880
- name: envoy.filters.http.upstream_codec
typed_config:
"@type": type.googleapis.com/envoy.extensions.filters.http.upstream_codec.v3.UpstreamCodec
transport_socket:
name: envoy.transport_sockets.tls
typed_config:
"@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext
sni: www.envoyproxy.io
```
|
```python
# coding: utf-8
"""
Kubernetes
No description provided (generated by Openapi Generator path_to_url # noqa: E501
The version of the OpenAPI document: release-1.30
Generated by: path_to_url
"""
from __future__ import absolute_import
import re # noqa: F401
# python 2 and python 3 compatibility library
import six
from kubernetes.client.api_client import ApiClient
from kubernetes.client.exceptions import ( # noqa: F401
ApiTypeError,
ApiValueError
)
class NodeV1Api(object):
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: path_to_url
Do not edit the class manually.
"""
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def create_runtime_class(self, body, **kwargs): # noqa: E501
"""create_runtime_class # noqa: E501
create a RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_runtime_class(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param V1RuntimeClass body: (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by path_to_url#IsPrint.
:param str field_validation: fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1RuntimeClass
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.create_runtime_class_with_http_info(body, **kwargs) # noqa: E501
def create_runtime_class_with_http_info(self, body, **kwargs): # noqa: E501
"""create_runtime_class # noqa: E501
create a RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_runtime_class_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param V1RuntimeClass body: (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by path_to_url#IsPrint.
:param str field_validation: fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1RuntimeClass, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'body',
'pretty',
'dry_run',
'field_manager',
'field_validation'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method create_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'body' is set
if self.api_client.client_side_validation and ('body' not in local_var_params or # noqa: E501
local_var_params['body'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `body` when calling `create_runtime_class`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
if 'dry_run' in local_var_params and local_var_params['dry_run'] is not None: # noqa: E501
query_params.append(('dryRun', local_var_params['dry_run'])) # noqa: E501
if 'field_manager' in local_var_params and local_var_params['field_manager'] is not None: # noqa: E501
query_params.append(('fieldManager', local_var_params['field_manager'])) # noqa: E501
if 'field_validation' in local_var_params and local_var_params['field_validation'] is not None: # noqa: E501
query_params.append(('fieldValidation', local_var_params['field_validation'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1RuntimeClass', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def delete_collection_runtime_class(self, **kwargs): # noqa: E501
"""delete_collection_runtime_class # noqa: E501
delete collection of RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_collection_runtime_class(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything.
:param int grace_period_seconds: The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
:param str label_selector: A selector to restrict the list of returned objects by their labels. Defaults to everything.
:param int limit: limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
:param bool orphan_dependents: Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
:param str propagation_policy: Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
:param str resource_version: resourceVersion sets a constraint on what resource versions a request may be served from. See path_to_url#resource-versions for details. Defaults to unset
:param str resource_version_match: resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See path_to_url#resource-versions for details. Defaults to unset
:param bool send_initial_events: `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan is interpreted as \"data at least as new as the provided `resourceVersion`\" and the bookmark event is send when the state is synced to a `resourceVersion` at least as fresh as the one provided by the ListOptions. If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the bookmark event is send when the state is synced at least to the moment when request started being processed. - `resourceVersionMatch` set to any other value or unset Invalid error is returned. Defaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.
:param int timeout_seconds: Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
:param V1DeleteOptions body:
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1Status
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.delete_collection_runtime_class_with_http_info(**kwargs) # noqa: E501
def delete_collection_runtime_class_with_http_info(self, **kwargs): # noqa: E501
"""delete_collection_runtime_class # noqa: E501
delete collection of RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_collection_runtime_class_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything.
:param int grace_period_seconds: The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
:param str label_selector: A selector to restrict the list of returned objects by their labels. Defaults to everything.
:param int limit: limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
:param bool orphan_dependents: Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
:param str propagation_policy: Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
:param str resource_version: resourceVersion sets a constraint on what resource versions a request may be served from. See path_to_url#resource-versions for details. Defaults to unset
:param str resource_version_match: resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See path_to_url#resource-versions for details. Defaults to unset
:param bool send_initial_events: `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan is interpreted as \"data at least as new as the provided `resourceVersion`\" and the bookmark event is send when the state is synced to a `resourceVersion` at least as fresh as the one provided by the ListOptions. If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the bookmark event is send when the state is synced at least to the moment when request started being processed. - `resourceVersionMatch` set to any other value or unset Invalid error is returned. Defaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.
:param int timeout_seconds: Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
:param V1DeleteOptions body:
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1Status, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'pretty',
'_continue',
'dry_run',
'field_selector',
'grace_period_seconds',
'label_selector',
'limit',
'orphan_dependents',
'propagation_policy',
'resource_version',
'resource_version_match',
'send_initial_events',
'timeout_seconds',
'body'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_collection_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
if '_continue' in local_var_params and local_var_params['_continue'] is not None: # noqa: E501
query_params.append(('continue', local_var_params['_continue'])) # noqa: E501
if 'dry_run' in local_var_params and local_var_params['dry_run'] is not None: # noqa: E501
query_params.append(('dryRun', local_var_params['dry_run'])) # noqa: E501
if 'field_selector' in local_var_params and local_var_params['field_selector'] is not None: # noqa: E501
query_params.append(('fieldSelector', local_var_params['field_selector'])) # noqa: E501
if 'grace_period_seconds' in local_var_params and local_var_params['grace_period_seconds'] is not None: # noqa: E501
query_params.append(('gracePeriodSeconds', local_var_params['grace_period_seconds'])) # noqa: E501
if 'label_selector' in local_var_params and local_var_params['label_selector'] is not None: # noqa: E501
query_params.append(('labelSelector', local_var_params['label_selector'])) # noqa: E501
if 'limit' in local_var_params and local_var_params['limit'] is not None: # noqa: E501
query_params.append(('limit', local_var_params['limit'])) # noqa: E501
if 'orphan_dependents' in local_var_params and local_var_params['orphan_dependents'] is not None: # noqa: E501
query_params.append(('orphanDependents', local_var_params['orphan_dependents'])) # noqa: E501
if 'propagation_policy' in local_var_params and local_var_params['propagation_policy'] is not None: # noqa: E501
query_params.append(('propagationPolicy', local_var_params['propagation_policy'])) # noqa: E501
if 'resource_version' in local_var_params and local_var_params['resource_version'] is not None: # noqa: E501
query_params.append(('resourceVersion', local_var_params['resource_version'])) # noqa: E501
if 'resource_version_match' in local_var_params and local_var_params['resource_version_match'] is not None: # noqa: E501
query_params.append(('resourceVersionMatch', local_var_params['resource_version_match'])) # noqa: E501
if 'send_initial_events' in local_var_params and local_var_params['send_initial_events'] is not None: # noqa: E501
query_params.append(('sendInitialEvents', local_var_params['send_initial_events'])) # noqa: E501
if 'timeout_seconds' in local_var_params and local_var_params['timeout_seconds'] is not None: # noqa: E501
query_params.append(('timeoutSeconds', local_var_params['timeout_seconds'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1Status', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def delete_runtime_class(self, name, **kwargs): # noqa: E501
"""delete_runtime_class # noqa: E501
delete a RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_runtime_class(name, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param int grace_period_seconds: The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
:param bool orphan_dependents: Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
:param str propagation_policy: Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
:param V1DeleteOptions body:
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1Status
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.delete_runtime_class_with_http_info(name, **kwargs) # noqa: E501
def delete_runtime_class_with_http_info(self, name, **kwargs): # noqa: E501
"""delete_runtime_class # noqa: E501
delete a RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_runtime_class_with_http_info(name, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param int grace_period_seconds: The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
:param bool orphan_dependents: Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the \"orphan\" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
:param str propagation_policy: Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
:param V1DeleteOptions body:
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1Status, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'name',
'pretty',
'dry_run',
'grace_period_seconds',
'orphan_dependents',
'propagation_policy',
'body'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'name' is set
if self.api_client.client_side_validation and ('name' not in local_var_params or # noqa: E501
local_var_params['name'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `name` when calling `delete_runtime_class`") # noqa: E501
collection_formats = {}
path_params = {}
if 'name' in local_var_params:
path_params['name'] = local_var_params['name'] # noqa: E501
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
if 'dry_run' in local_var_params and local_var_params['dry_run'] is not None: # noqa: E501
query_params.append(('dryRun', local_var_params['dry_run'])) # noqa: E501
if 'grace_period_seconds' in local_var_params and local_var_params['grace_period_seconds'] is not None: # noqa: E501
query_params.append(('gracePeriodSeconds', local_var_params['grace_period_seconds'])) # noqa: E501
if 'orphan_dependents' in local_var_params and local_var_params['orphan_dependents'] is not None: # noqa: E501
query_params.append(('orphanDependents', local_var_params['orphan_dependents'])) # noqa: E501
if 'propagation_policy' in local_var_params and local_var_params['propagation_policy'] is not None: # noqa: E501
query_params.append(('propagationPolicy', local_var_params['propagation_policy'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses/{name}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1Status', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_api_resources(self, **kwargs): # noqa: E501
"""get_api_resources # noqa: E501
get available resources # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_api_resources(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1APIResourceList
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.get_api_resources_with_http_info(**kwargs) # noqa: E501
def get_api_resources_with_http_info(self, **kwargs): # noqa: E501
"""get_api_resources # noqa: E501
get available resources # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_api_resources_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1APIResourceList, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_api_resources" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1APIResourceList', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def list_runtime_class(self, **kwargs): # noqa: E501
"""list_runtime_class # noqa: E501
list or watch objects of kind RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_runtime_class(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
:param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
:param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything.
:param str label_selector: A selector to restrict the list of returned objects by their labels. Defaults to everything.
:param int limit: limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
:param str resource_version: resourceVersion sets a constraint on what resource versions a request may be served from. See path_to_url#resource-versions for details. Defaults to unset
:param str resource_version_match: resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See path_to_url#resource-versions for details. Defaults to unset
:param bool send_initial_events: `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan is interpreted as \"data at least as new as the provided `resourceVersion`\" and the bookmark event is send when the state is synced to a `resourceVersion` at least as fresh as the one provided by the ListOptions. If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the bookmark event is send when the state is synced at least to the moment when request started being processed. - `resourceVersionMatch` set to any other value or unset Invalid error is returned. Defaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.
:param int timeout_seconds: Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
:param bool watch: Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1RuntimeClassList
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.list_runtime_class_with_http_info(**kwargs) # noqa: E501
def list_runtime_class_with_http_info(self, **kwargs): # noqa: E501
"""list_runtime_class # noqa: E501
list or watch objects of kind RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_runtime_class_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
:param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
:param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything.
:param str label_selector: A selector to restrict the list of returned objects by their labels. Defaults to everything.
:param int limit: limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true. The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
:param str resource_version: resourceVersion sets a constraint on what resource versions a request may be served from. See path_to_url#resource-versions for details. Defaults to unset
:param str resource_version_match: resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See path_to_url#resource-versions for details. Defaults to unset
:param bool send_initial_events: `sendInitialEvents=true` may be set together with `watch=true`. In that case, the watch stream will begin with synthetic events to produce the current state of objects in the collection. Once all such events have been sent, a synthetic \"Bookmark\" event will be sent. The bookmark will report the ResourceVersion (RV) corresponding to the set of objects, and be marked with `\"k8s.io/initial-events-end\": \"true\"` annotation. Afterwards, the watch stream will proceed as usual, sending watch events corresponding to changes (subsequent to the RV) to objects watched. When `sendInitialEvents` option is set, we require `resourceVersionMatch` option to also be set. The semantic of the watch request is as following: - `resourceVersionMatch` = NotOlderThan is interpreted as \"data at least as new as the provided `resourceVersion`\" and the bookmark event is send when the state is synced to a `resourceVersion` at least as fresh as the one provided by the ListOptions. If `resourceVersion` is unset, this is interpreted as \"consistent read\" and the bookmark event is send when the state is synced at least to the moment when request started being processed. - `resourceVersionMatch` set to any other value or unset Invalid error is returned. Defaults to true if `resourceVersion=\"\"` or `resourceVersion=\"0\"` (for backward compatibility reasons) and to false otherwise.
:param int timeout_seconds: Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
:param bool watch: Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1RuntimeClassList, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'pretty',
'allow_watch_bookmarks',
'_continue',
'field_selector',
'label_selector',
'limit',
'resource_version',
'resource_version_match',
'send_initial_events',
'timeout_seconds',
'watch'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method list_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
if 'allow_watch_bookmarks' in local_var_params and local_var_params['allow_watch_bookmarks'] is not None: # noqa: E501
query_params.append(('allowWatchBookmarks', local_var_params['allow_watch_bookmarks'])) # noqa: E501
if '_continue' in local_var_params and local_var_params['_continue'] is not None: # noqa: E501
query_params.append(('continue', local_var_params['_continue'])) # noqa: E501
if 'field_selector' in local_var_params and local_var_params['field_selector'] is not None: # noqa: E501
query_params.append(('fieldSelector', local_var_params['field_selector'])) # noqa: E501
if 'label_selector' in local_var_params and local_var_params['label_selector'] is not None: # noqa: E501
query_params.append(('labelSelector', local_var_params['label_selector'])) # noqa: E501
if 'limit' in local_var_params and local_var_params['limit'] is not None: # noqa: E501
query_params.append(('limit', local_var_params['limit'])) # noqa: E501
if 'resource_version' in local_var_params and local_var_params['resource_version'] is not None: # noqa: E501
query_params.append(('resourceVersion', local_var_params['resource_version'])) # noqa: E501
if 'resource_version_match' in local_var_params and local_var_params['resource_version_match'] is not None: # noqa: E501
query_params.append(('resourceVersionMatch', local_var_params['resource_version_match'])) # noqa: E501
if 'send_initial_events' in local_var_params and local_var_params['send_initial_events'] is not None: # noqa: E501
query_params.append(('sendInitialEvents', local_var_params['send_initial_events'])) # noqa: E501
if 'timeout_seconds' in local_var_params and local_var_params['timeout_seconds'] is not None: # noqa: E501
query_params.append(('timeoutSeconds', local_var_params['timeout_seconds'])) # noqa: E501
if 'watch' in local_var_params and local_var_params['watch'] is not None: # noqa: E501
query_params.append(('watch', local_var_params['watch'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf', 'application/json;stream=watch', 'application/vnd.kubernetes.protobuf;stream=watch']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1RuntimeClassList', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def patch_runtime_class(self, name, body, **kwargs): # noqa: E501
"""patch_runtime_class # noqa: E501
partially update the specified RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_runtime_class(name, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param object body: (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by path_to_url#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
:param str field_validation: fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.
:param bool force: Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1RuntimeClass
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.patch_runtime_class_with_http_info(name, body, **kwargs) # noqa: E501
def patch_runtime_class_with_http_info(self, name, body, **kwargs): # noqa: E501
"""patch_runtime_class # noqa: E501
partially update the specified RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_runtime_class_with_http_info(name, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param object body: (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by path_to_url#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
:param str field_validation: fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.
:param bool force: Force is going to \"force\" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1RuntimeClass, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'name',
'body',
'pretty',
'dry_run',
'field_manager',
'field_validation',
'force'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method patch_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'name' is set
if self.api_client.client_side_validation and ('name' not in local_var_params or # noqa: E501
local_var_params['name'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `name` when calling `patch_runtime_class`") # noqa: E501
# verify the required parameter 'body' is set
if self.api_client.client_side_validation and ('body' not in local_var_params or # noqa: E501
local_var_params['body'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `body` when calling `patch_runtime_class`") # noqa: E501
collection_formats = {}
path_params = {}
if 'name' in local_var_params:
path_params['name'] = local_var_params['name'] # noqa: E501
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
if 'dry_run' in local_var_params and local_var_params['dry_run'] is not None: # noqa: E501
query_params.append(('dryRun', local_var_params['dry_run'])) # noqa: E501
if 'field_manager' in local_var_params and local_var_params['field_manager'] is not None: # noqa: E501
query_params.append(('fieldManager', local_var_params['field_manager'])) # noqa: E501
if 'field_validation' in local_var_params and local_var_params['field_validation'] is not None: # noqa: E501
query_params.append(('fieldValidation', local_var_params['field_validation'])) # noqa: E501
if 'force' in local_var_params and local_var_params['force'] is not None: # noqa: E501
query_params.append(('force', local_var_params['force'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json-patch+json', 'application/merge-patch+json', 'application/strategic-merge-patch+json', 'application/apply-patch+yaml']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses/{name}', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1RuntimeClass', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def read_runtime_class(self, name, **kwargs): # noqa: E501
"""read_runtime_class # noqa: E501
read the specified RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.read_runtime_class(name, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1RuntimeClass
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.read_runtime_class_with_http_info(name, **kwargs) # noqa: E501
def read_runtime_class_with_http_info(self, name, **kwargs): # noqa: E501
"""read_runtime_class # noqa: E501
read the specified RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.read_runtime_class_with_http_info(name, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1RuntimeClass, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'name',
'pretty'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method read_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'name' is set
if self.api_client.client_side_validation and ('name' not in local_var_params or # noqa: E501
local_var_params['name'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `name` when calling `read_runtime_class`") # noqa: E501
collection_formats = {}
path_params = {}
if 'name' in local_var_params:
path_params['name'] = local_var_params['name'] # noqa: E501
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses/{name}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1RuntimeClass', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def replace_runtime_class(self, name, body, **kwargs): # noqa: E501
"""replace_runtime_class # noqa: E501
replace the specified RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.replace_runtime_class(name, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param V1RuntimeClass body: (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by path_to_url#IsPrint.
:param str field_validation: fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: V1RuntimeClass
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.replace_runtime_class_with_http_info(name, body, **kwargs) # noqa: E501
def replace_runtime_class_with_http_info(self, name, body, **kwargs): # noqa: E501
"""replace_runtime_class # noqa: E501
replace the specified RuntimeClass # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.replace_runtime_class_with_http_info(name, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str name: name of the RuntimeClass (required)
:param V1RuntimeClass body: (required)
:param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).
:param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
:param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by path_to_url#IsPrint.
:param str field_validation: fieldValidation instructs the server on how to handle objects in the request (POST/PUT/PATCH) containing unknown or duplicate fields. Valid values are: - Ignore: This will ignore any unknown fields that are silently dropped from the object, and will ignore all but the last duplicate field that the decoder encounters. This is the default behavior prior to v1.23. - Warn: This will send a warning via the standard warning response header for each unknown field that is dropped from the object, and for each duplicate field that is encountered. The request will still succeed if there are no other errors, and will only persist the last of any duplicate fields. This is the default in v1.23+ - Strict: This will fail the request with a BadRequest error if any unknown fields would be dropped from the object, or if any duplicate fields are present. The error returned from the server will contain all unknown and duplicate fields encountered.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(V1RuntimeClass, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'name',
'body',
'pretty',
'dry_run',
'field_manager',
'field_validation'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method replace_runtime_class" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'name' is set
if self.api_client.client_side_validation and ('name' not in local_var_params or # noqa: E501
local_var_params['name'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `name` when calling `replace_runtime_class`") # noqa: E501
# verify the required parameter 'body' is set
if self.api_client.client_side_validation and ('body' not in local_var_params or # noqa: E501
local_var_params['body'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `body` when calling `replace_runtime_class`") # noqa: E501
collection_formats = {}
path_params = {}
if 'name' in local_var_params:
path_params['name'] = local_var_params['name'] # noqa: E501
query_params = []
if 'pretty' in local_var_params and local_var_params['pretty'] is not None: # noqa: E501
query_params.append(('pretty', local_var_params['pretty'])) # noqa: E501
if 'dry_run' in local_var_params and local_var_params['dry_run'] is not None: # noqa: E501
query_params.append(('dryRun', local_var_params['dry_run'])) # noqa: E501
if 'field_manager' in local_var_params and local_var_params['field_manager'] is not None: # noqa: E501
query_params.append(('fieldManager', local_var_params['field_manager'])) # noqa: E501
if 'field_validation' in local_var_params and local_var_params['field_validation'] is not None: # noqa: E501
query_params.append(('fieldValidation', local_var_params['field_validation'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'body' in local_var_params:
body_params = local_var_params['body']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'application/yaml', 'application/vnd.kubernetes.protobuf']) # noqa: E501
# Authentication setting
auth_settings = ['BearerToken'] # noqa: E501
return self.api_client.call_api(
'/apis/node.k8s.io/v1/runtimeclasses/{name}', 'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='V1RuntimeClass', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
```
|
```scala
package org.apache.spark
import org.apache.spark.deploy.SparkHadoopUtil
import org.apache.spark.mllib.linalg.Vector
import org.apache.spark.sql.DataFrame
import org.apache.spark.sql.types.BinaryType
/**
* 2019-08-16 WilliamZhu(allwefantasy@gmail.com)
*/
object MLSQLSparkUtils {
def rpcEnv() = {
SparkEnv.get.rpcEnv
}
def blockManager = {
SparkEnv.get.blockManager
}
def sparkHadoopUtil = {
SparkHadoopUtil.get
}
def transformDense(
idf: Vector,
values: Array[Double]): Array[Double] = {
val n = values.length
val newValues = new Array[Double](n)
var j = 0
while (j < n) {
newValues(j) = values(j) * idf(j)
j += 1
}
newValues
}
def transformSparse(
idf: Vector,
indices: Array[Int],
values: Array[Double]): (Array[Int], Array[Double]) = {
val nnz = indices.length
val newValues = new Array[Double](nnz)
var k = 0
while (k < nnz) {
newValues(k) = values(k) * idf(indices(k))
k += 1
}
(indices, newValues)
}
def isFileTypeTable(df: DataFrame): Boolean = {
if (df.schema.fields.length != 3) return false
val fields = df.schema.fields
fields(0).name == "start" && fields(1).name == "offset" && fields(2).name == "value" && fields(2).dataType == BinaryType
}
}
```
|
Tour of Azerbaijan 2009 is the 24th round of Tour of Iran (Azerbaijan), which took between 15 May and 21 May 2009 in Iranian Azerbaijan and in the Autonomous Republic of Nakhichivan. The tour had 6 stages in which Ahad Kazemi from Iran won in first place in over all classification of the tour.
Stages of the tour
General classification
References
Tour of Azerbaijan (Iran)
|
Stolen Picture is a British film production company founded by Simon Pegg and Nick Frost in 2016, with Miles Ketley joining in July 2017.
Overview
On 16 May 2017, it was announced that Simon Pegg and Nick Frost had launched a film and television production banner called Stolen Picture. The first production by the company was Slaughterhouse Rulez, a horror-comedy film. Crispian Mills directed the project, based on a script he co-wrote with Henry Fitzherbert. Sony Pictures backed the film, which Pegg and Frost executive-produced.
On 20 September 2017, it was announced that Sony Pictures Television had taken a minority stake in the production company. In addition, Stolen Picture entered into an exclusive television distribution deal with Sony. Concurrently with the Sony Pictures Television announcement, it was announced that Miles Ketley has been appointed CEO of Stolen Picture, joining from Bad Wolf. Wayne Garvie, president of international production for Sony Pictures Television, was subsequently hired as the company's chief creative officer.
On 19 January 2018, it was announced that Stolen Picture was developing their first television project Truth Seekers, a half-hour comedy-horror series about a three-person paranormal investigation team. On 1 May 2019, it was announced that Stolen Picture would develop a television adaptation of Ben Aaronovitch's Rivers of London novel series. On 19 October 2020, it was announced that Miles Ketley died unexpectedly, only days before the premiere of the TV comedy Truth Seekers, debuting 30 October.
Simon Pegg and Nick Frost were set to adapt Ben Aaronovitch’s Rivers of London into a series, but the project never came to fruition. The Guardian reports that Pure Fiction Television and Unnecessary Logo—a production company Aaronovitch himself has created—is set to adapt the series.
Feature films
Television series
References
External links
Official Website
UK Companies Website Profile
British companies established in 2016
British subsidiaries of foreign companies
Sony Pictures Entertainment
Sony Pictures Television production companies
Sony Pictures Television
Mass media companies established in 2016
Film production companies of the United Kingdom
2017 mergers and acquisitions
|
Soloy is a corregimiento in Ngäbe-Buglé Comarca in the Republic of Panama.
References
Populated places in Ngöbe-Buglé Comarca
|
```java
/*
* FindBugs - Find Bugs in Java programs
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* This library 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 GNU
*
* You should have received a copy of the GNU Lesser General Public
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.umd.cs.findbugs.gui2;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* @author pugh
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface SwingThread {
}
```
|
The Vistula–Oder offensive () was a Red Army operation on the Eastern Front in the European theatre of World War II in January 1945. The army made a major advance into German-held territory, capturing Kraków, Warsaw and Poznań. The Red Army had built up their strength around a number of key bridgeheads, with two fronts commanded by Marshal Georgy Zhukov and Marshal Ivan Konev. Against them, the German Army Group A, led by Colonel-General Josef Harpe (soon replaced by Colonel-General Ferdinand Schörner), was outnumbered five to one. Within days, German commandants evacuated the concentration camps, sending the prisoners on their death marches to the west, where ethnic Germans also started fleeing. In a little over two weeks, the Red Army had advanced from the Vistula to the Oder, only from Berlin, which was undefended. However, Zhukov called a halt, owing to continued German resistance on his northern flank (Pomerania), and the advance on Berlin had to be delayed until April.
Background
In the wake of the successful Operation Bagration, the 1st Belorussian Front managed to secure two bridgeheads west of the Vistula river between 27 July and 4 August 1944. The Soviet forces remained inactive during the failed Warsaw uprising that started on 1 August, though their frontline was not far from the insurgents. The 1st Ukrainian Front captured an additional large bridgehead at Sandomierz (known as the Baranow bridgehead in German accounts), some 200 km south of Warsaw, during the Lvov–Sandomierz offensive.
Preceding the offensive, the Red Army had built up large amounts of materiel and manpower in the three bridgeheads. The Red Army greatly outnumbered the opposing Wehrmacht in infantry, artillery, and armour. All this was known to German intelligence. General Reinhard Gehlen, head of Fremde Heere Ost, passed his assessment to Heinz Guderian. Guderian in turn presented the intelligence results to Adolf Hitler, who refused to believe them, dismissing the apparent Soviet strength as "the greatest imposture since Genghis Khan". Guderian had proposed to evacuate the divisions of Army Group North trapped in the Courland Pocket to the Reich via the Baltic Sea to get the necessary manpower for the defence, but Hitler forbade it. In addition, Hitler commanded that one major operational reserve, the troops of Sepp Dietrich's 6th Panzer Army, be moved to Hungary to support Operation Frühlingserwachen.
The offensive was brought forward from 20 to 12 January because meteorological reports warned of a thaw later in the month, and the tanks needed hard ground for the offensive. It was not done to assist American and British forces during the Battle of the Bulge, as Stalin chose to claim at Yalta.
Forces involved
Red Army
Two Fronts of the Red Army were directly involved. The 1st Belorussian Front, holding the sector around Warsaw and southward in the Magnuszew and Puławy bridgeheads, was led by Marshal Georgy Zhukov; the 1st Ukrainian Front, occupying the Sandomierz bridgehead, was led by Marshal Ivan Konev.
Zhukov and Konev had 163 divisions for the operation with a total of: 2,203,000 infantry, 4,529 tanks, 2,513 assault guns, 13,763 pieces of field artillery (76 mm or more), 14,812 mortars, 4,936 anti-tank guns, 2,198 Katyusha multiple rocket launchers, and 5,000 aircraft.
Deployments
1st Belorussian Front (Marshal Georgy Zhukov)
47th Army (Franz Perkhorovich)
1st Polish Army (General Stanislav Poplavsky)
3rd Shock Army (Nikolai Simoniak)
61st Army (Pavel Alexeyevich Belov)
1st Guards Tank Army (Mikhail Katukov)
2nd Guards Tank Army (Semyon Bogdanov)
5th Shock Army (in Magnuszew bridgehead) (Nikolai Berzarin)
8th Guards Army (in Magnuszew bridgehead) (General Vasily Chuikov)
69th Army (in Puławy bridgehead) (Vladimir Kolpakchi)
33rd Army (in Puławy bridgehead) (Vyacheslav Tsvetayev)
1st Ukrainian Front (Marshal Ivan Konev)
21st Army (Dmitry Gusev )
6th Army (Vladimir Gluzdovsky)
3rd Guards Army (Vasily Gordov)
13th Army (Nikolai Pukhov)
4th Tank Army (Dmitry Lelyushenko)
3rd Guards Tank Army (Pavel Rybalko)
1st Guards Cavalry Corps (Viktor Kirillovich Baranov)
52nd Army (Konstantin Koroteyev)
5th Guards Army (Aleksey Semenovich Zhadov)
59th Army (Ivan Korovnikov)
60th Army (Pavel Kurochkin)
Wehrmacht
Soviet forces in this sector were opposed by Army Group A, defending a front which stretched from positions east of Warsaw southwards along the Vistula, almost to the confluence of the San. At that point there was a large Soviet bridgehead over the Vistula in the area of Baranów before the front continued south to Jasło.
There were three Armies in the Group; the 9th Army deployed around Warsaw, the 4th Panzer Army opposite the Baranow salient in the Vistula Bend, and the 17th Army to their south. The force had a total complement of 450,000 soldiers, 4,100 artillery pieces, and 1,150 tanks. Army Group A was led by Colonel-General Josef Harpe (who was replaced, after the offensive had begun, by Colonel-General Ferdinand Schörner on 20 January).
Order of battle
Army Group A (Colonel-General Josef Harpe to 20 January; then Ferdinand Schörner)
9th Army (General Smilo Freiherr von Lüttwitz to 20 January; then General Theodor Busse)
LVI Panzer Corps (General Johannes Block)
XXXXVI Panzer Corps (General Walter Fries)
VIII Corps (General Walter Hartmann)
4th Panzer Army (General Fritz-Hubert Gräser)
XLII Corps (General Hermann Recknagel)
XXIV Panzer Corps (General Walther Nehring)
XLVIII Panzer Corps (General Maximilian Reichsfreiherr von Edelsheim)
17th Army (General Friedrich Schulz)
LIX Corps (General Edgar Rohricht)
XI Corps (General Rudolf von Bünau)
XI SS Panzer Corps (SS-Obergruppenfuhrer Matthias Kleinheisterkamp)
German intelligence had estimated that the Soviet forces had a 3:1 numerical superiority to the German forces; there was in fact a 5:1 superiority. In the large Baranow/Sandomierz bridgehead, the Fourth Panzer Army was required to defend from 'strongpoints' in some areas, as it lacked the infantry to man a continuous front line. In addition, on Hitler's express orders, the two German defence lines (the Grosskampflinie and Hauptkampflinie) were positioned very close to each other, placing the main defences well within striking range of Soviet artillery.
Offensive
The offensive commenced in the Baranow bridgehead at 04:35 on 12 January with an intense bombardment by the guns of the 1st Ukrainian Front against the positions of the 4th Panzer Army. Concentrated against the divisions of XLVIII Panzer Corps, which had been deployed across the face of the bridgehead, the bombardment effectively destroyed their capacity to respond; a battalion commander in the 68th Infantry Division stated that "I began the operation with an understrength battalion [...] after the smoke of the Soviet preparation cleared [...] I had only a platoon of combat effective soldiers left".
The initial barrage was followed by probing attacks and a further heavy bombardment at 10:00. By the time the main armored exploitation force of the 3rd Guards and 4th Tank Armies moved forward four hours later, the Fourth Panzer Army had already lost up to ⅔ of its artillery and ¼ of its troops.
The Soviet units made rapid progress, moving to cut off the defenders at Kielce. The armored reserves of the 4th Panzer Army's central corps, the XXIV Panzer Corps, were committed but had suffered serious damage by the time they reached Kielce, and were already being outflanked. The XLVIII Panzer Corps, on the Fourth Panzer Army's southern flank, had by this time been completely destroyed, along with much of Recknagel's XLII Corps in the north. Recknagel himself would be killed by Polish partisans on 23 January. By 14 January, the 1st Ukrainian Front had forced crossings of the Nida river, and began to exploit towards Radomsko and the Warthe. The 4th Panzer Army's last cohesive formation, the XXIV Panzer Corps held on around Kielce until the night of 16 January, before its commander made the decision to withdraw.
The 1st Belorussian Front, to Konev's north, opened its attack on the German 9th Army from the Magnuszew and Puławy bridgeheads at 08:30, again commencing with a heavy bombardment. The 33rd and 69th Armies broke out of the Puławy bridgehead to a depth of , while the 5th Shock and 8th Guards Armies broke out of the Magnuszew bridgehead. The 2nd and 1st Guards Tank Armies were committed after them to exploit the breach. The 69th Army's progress from the Puławy bridgehead was especially successful, with the defending LVI Panzer Corps disintegrating after its line of retreat was cut off. Though the 9th Army conducted many local counter-attacks, they were all brushed aside; the 69th Army ruptured the last lines of defence and took Radom, while the 2nd Guards Tank Army moved on Sochaczew and the 1st Guards Tank Army was ordered to seize bridgeheads over the Pilica and attack towards Łódź. In the meantime, the 47th Army had crossed the Vistula and moved towards Warsaw from the north, while the 61st and 1st Polish Armies encircled the city from the south.
The only major German response came on 15 January, when Hitler (against the advice of Guderian) ordered the Panzerkorps Großdeutschland of Dietrich von Saucken from East Prussia to cover the breach made in the sector of the 4th Panzer Army, but the advance of Zhukov's forces forced it to detrain at Łódź without even reaching its objective. After covering the 9th Army's retreat, it was forced to withdraw southwest toward the Warthe.
Taking of Kraków; escape of the XXIV Panzer Corps
On 17 January, Konev was given new objectives: to advance towards Breslau using his mechanised forces, and to use the combined-arms forces of the 60th and 59th Armies to open an attack on the southern flank towards the industrial heartland of Upper Silesia through Kraków. Kraków was secured undamaged on 19 January after an encirclement by the 59th and 60th Armies, in conjunction with the 4th Guards Tank Corps, forced the German defenders to withdraw hurriedly.
The second stage of the 1st Ukrainian Front's objective was far more complex, as they were required to encircle and secure the entire industrial region of Upper Silesia, where they were faced by Schulz's 17th Army. Konev ordered that the 59th and 60th Armies advance frontally, while the 21st Army encircled the area from the north. He then ordered Rybalko's 3rd Guards Tank Army, moving on Breslau, to swing southwards along the upper Oder from 20 January, cutting off 17th Army's withdrawal.
In the meantime, the shattered remnants of the 4th Panzer Army were still attempting to reach German lines. By 18 January, Nehring and the XXIV Panzer Corps found that their intended route northwards had been blocked, so pulled back to the west, absorbing the remnants of XLII Corps that had escaped encirclement. Much of the remainder of XLII Corps was destroyed after being trapped around Przysucha. Screened by heavy fog, the lead elements of XXIV Panzer Corps reached the Warthe on 22 January, and having linked up with Grossdeutschland Panzer Corps of von Saucken, were finally able to cross the Oder, some from their positions at the start of the Soviet offensive.
Withdrawal of 17th Army from Upper Silesia
On 25 January, Schulz requested that he be allowed to withdraw his 100,000 troops from the developing salient around Katowice/Kattowitz. This was refused, and he repeated the request on 26 January. Schoerner eventually permitted Schulz to pull his forces back on the night of 27 January, while Konev – who had allowed just enough room for the 17th Army to withdraw without putting up serious resistance – secured the area undamaged.
On Konev's northern flank, the 4th Tank Army had spearheaded an advance to the Oder, where it secured a major bridgehead at Steinau. Troops of the 5th Guards Army established a second bridgehead upstream at Ohlau.
Advance of 1st Belorussian Front
In the northern sector of the offensive, Zhukov's 1st Belorussian Front also made rapid progress, as the 9th Army was no longer able to offer coherent resistance. Its XXXVI Panzer Corps, which was positioned behind Warsaw, was pushed over the Vistula into the neighbouring Second Army sector. Warsaw was taken on 17 January, as Army Group A's headquarters issued orders for the city to be abandoned; units of the 2nd Guards and 3rd Shock Armies entering the city were profoundly affected by the devastation wrought by German forces after the Warsaw Uprising. Hitler, on the other hand, was furious at the abandonment of the 'fortress', arresting Colonel Bogislaw von Bonin, head of the Operations Branch of OKH, and sacking both the 9th Army and XXXVI Panzer Corps commanders; Generals Smilo Freiherr von Lüttwitz and Walter Fries.
The 2nd Guards Tank Army pressed forward to the Oder, while to the south the 8th Guards Army reached Łódź by 18 January, and took it by 19 January. The 1st Guards Tank Army moved to encircle Poznań by 25 January, and the 8th Guards Army began to fight its way into the city on the following day, though there was protracted and intense fighting in the Siege of Poznań before the city would finally be taken.
To the northeast of Zhukov's 1st Belorussian Front, the lead elements of Marshal Rokossovsky's 2nd Belorussian Front taking part in the East Prussian offensive had reached the Baltic coast of the Vistula delta by 24 January and so succeeded in isolating Army Group Centre in East Prussia. On 27 January, the abandoned Wolf's Lair - Hitler's former headquarters on the Eastern Front, was captured.
Zhukov's advance to the Oder
After encircling Poznań, the 1st Guards Tank Army advanced deep into the fortified region around the Obra River against patchy resistance from a variety of Volkssturm and Wehrmacht units. There was heavier resistance, however, on the approaches to the fortress of Küstrin.
The German reorganisation of command structure that resulted in the creation of Army Group Vistula was accompanied by the release of a few extra formations for the defense; the V SS Mountain Corps, with two reserve infantry divisions, was deployed along the Obra and the prewar border fortifications known as the Tierschtigel Riegel, while the Panzergrenadier-Division Kurmark was ordered to reinforce it.
On 16 January 1945 Colonel Bogislaw von Bonin, the Chief of the Operational Branch of the Army General Staff (Generalstab des Heeres) gave Army Group A permission to retreat from Warsaw, overruling a direct order from Hitler for them to hold fast. Three days later von Bonin was arrested by the Gestapo and imprisoned first at Flossenbürg and then Dachau concentration camp. The officer was eventually liberated along with other prisoners in South Tyrol by the US Army in May 1945.
The military historian Earl Ziemke described the advance thus:
On 25 January, Hitler renamed three army groups. Army Group North became Army Group Courland; Army Group Centre became Army Group North and Army Group A became Army Group Centre.
The 2nd Guards Tank and 5th Shock Armies reached the Oder almost unopposed; a unit of the 5th Shock Army crossed the river ice and took the town of Kienitz as early as 31 January.
Stavka declared the operation complete on 2 February. Zhukov had initially hoped to advance directly on Berlin, as the German defences had largely collapsed. However, the exposed northern flank of the 1st Belorussian Front in Pomerania, along with a German counter-attack (Operation Solstice) against its spearheads, convinced the Soviet command that it was essential to clear German forces from Pomerania in the East Pomeranian offensive before the Berlin offensive could proceed.
Liberation of Nazi concentration camps
In July 1944, the Soviet 8th Guards liberated Lublin, and after a brief skirmish with German forces outside the city, came upon the Majdanek concentration camp. Although the Soviets invited press from around the world to witness the horrors of the camp, other war news overshadowed the event.
After being caught off guard at Majdanek, the Nazis realized that the Soviets would end up finding every camp within Eastern Europe (with all of the prisoners and guards still present) if something were not to be done. As a result, by mid-January, the SS and Nazi-controlled police units had begun forcing thousands of camp prisoners from Poland, East Prussia, Silesia and Pomerania to walk westward away from the advancing Red Army. The death marches, which took place over hundreds of kilometers in sub-zero conditions without food and medicine, resulted in thousands of concentration camp prisoners and allied POWs dying en route. It is estimated that in March and April 1945, at least 250,000 men and women were marched on foot to the heartland of Germany and Austria sometimes for weeks at a time.
On 27 January, troops from Konev's 1st Ukrainian Front (322nd Rifle Division, 60th Army) liberated the Auschwitz concentration camp. Despite attempts by retreating SS units to destroy parts of the camp, the Soviet forces still found graphic evidence of the Holocaust. The Soviets would also liberate camps such as Płaszów, Stutthof, and Ravensbrück.
Flight of ethnic Germans
In anticipation of the approaching Red Army, the retreating Wehrmacht left parts of the German territory largely abandoned. With widespread unchecked chaos erupting, numerous reports of looting and attacks against ethnic Germans emerged. Nazi propaganda had furthermore demonized the Soviet Army so much that most Germans attempted to run. Millions of ethnic German refugees fled west, seeking relative safety in central or western Germany, or even in the custody of the Americans and British west of the Rhine.
Outcome
The Vistula–Oder offensive was a major success for the Soviet military. Within a matter of days, the forces involved had advanced hundreds of kilometers, taking much of Poland and striking deep within the pre-war borders of the Reich. The offensive broke the back of Army Group A and much of Germany's remaining capacity for military resistance. However, the stubborn resistance of German forces in Silesia and Pomerania, as well as continuing fighting in East Prussia, meant that the final offensive towards Berlin was delayed by two months, by which time the Wehrmacht had once again built up a substantial force on this axis.
Aftermath
On 31 January, the Soviet offensive was voluntarily halted, though Berlin was undefended and only approximately away from the Soviet bridgeheads across the Oder river. After the war, a debate raged, mainly between Vasily Chuikov and Georgy Zhukov, whether it was wise to stop the offensive. Chuikov argued Berlin should have been taken then, while Zhukov defended the decision to stop.
The operation was followed by a period of several weeks of mopping-up and consolidation on the part of the Red Army, along with ongoing hard fighting in pockets in the north. On 16 April, the Red Army jumped off from lines on the Oder and Neisse Rivers, the opening phase of the Battle of Berlin, which proved to be the culminating offensive of the war on the Eastern Front. The relatively rapid progress of this new offensive toward the German heartland seems to illustrate the cumulative extent of the erosion of the Wehrmacht's capability to defend a broad front. Nevertheless, they remained dangerous opponents for some weeks longer, especially when allowed or forced to concentrate in limited areas.
See also
East Prussian offensive, the parallel offensive in East Prussia
Western Carpathian offensive, the parallel offensive in Slovakia
Operation Solstice, German counter-offensive in Pomerania
East Pomeranian offensive, the operation to clear the northern flank of 1st Belorussian Front
Silesian offensives, operations to clear the southern flank of 1st Ukrainian Front
Battle of Berlin
References
Notes
Bibliography
Beevor, A. Berlin: The Downfall 1945, Penguin Books, 2002,
Duffy, C. Red Storm on the Reich: The Soviet March on Germany, 1945 Routledge 1991
Glantz, David M. & House, Jonathan (1995), When Titans Clashed: How the Red Army Stopped Hitler, Lawrence, Kansas: University Press of Kansas,
Le Tissier, T. Zhukov at the Oder, Greenwood, 1996,
Battles and operations of the Soviet–German War
Strategic operations of the Red Army in World War II
Conflicts in 1945
World War II aerial operations and battles of the Eastern Front
Military operations of World War II involving Germany
January 1945 events in Europe
February 1945 events in Europe
1945 in Germany
1945 in Poland
|
```objective-c
*
* your_sha256_hash-----------------------
* The following license statement only applies to this file (task_queue.h).
* your_sha256_hash-----------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef __LIBRETRO_SDK_TASK_QUEUE_H__
#define __LIBRETRO_SDK_TASK_QUEUE_H__
#include <stdint.h>
#include <stddef.h>
#include <boolean.h>
#include <retro_common.h>
#include <retro_common_api.h>
RETRO_BEGIN_DECLS
enum task_queue_ctl_state
{
TASK_QUEUE_CTL_NONE = 0,
/* Deinitializes the task system.
* This deinitializes the task system.
* The tasks that are running at
* the moment will stay on hold
* until TASK_QUEUE_CTL_INIT is called again. */
TASK_QUEUE_CTL_DEINIT,
/* Initializes the task system.
* This initializes the task system
* and chooses an appropriate
* implementation according to the settings.
*
* This must only be called from the main thread. */
TASK_QUEUE_CTL_INIT,
/**
* Calls func for every running task
* until it returns true.
* Returns a task or NULL if not found.
*/
TASK_QUEUE_CTL_FIND,
/**
* Calls func for every running task when handler
* parameter matches task handler, allowing the
* list parameter to be filled with user-defined
* data.
*/
TASK_QUEUE_CTL_RETRIEVE,
/* Blocks until all tasks have finished.
* This must only be called from the main thread. */
TASK_QUEUE_CTL_WAIT,
/* Checks for finished tasks
* Takes the finished tasks, if any,
* and runs their callbacks.
* This must only be called from the main thread. */
TASK_QUEUE_CTL_CHECK,
/* Pushes a task
* The task will start as soon as possible. */
TASK_QUEUE_CTL_PUSH,
/* Sends a signal to terminate all the tasks.
*
* This won't terminate the tasks immediately.
* They will finish as soon as possible.
*
* This must only be called from the main thread. */
TASK_QUEUE_CTL_RESET,
TASK_QUEUE_CTL_SET_THREADED,
TASK_QUEUE_CTL_UNSET_THREADED,
TASK_QUEUE_CTL_IS_THREADED,
/**
* Signals a task to end without waiting for
* it to complete. */
TASK_QUEUE_CTL_CANCEL
};
typedef struct retro_task retro_task_t;
typedef void (*retro_task_callback_t)(void *task_data,
void *user_data, const char *error);
typedef void (*retro_task_handler_t)(retro_task_t *task);
typedef bool (*retro_task_finder_t)(retro_task_t *task,
void *userdata);
typedef bool (*retro_task_retriever_t)(retro_task_t *task, void *data);
typedef struct
{
char *source_file;
} decompress_task_data_t;
struct retro_task
{
retro_task_handler_t handler;
/* always called from the main loop */
retro_task_callback_t callback;
/* task cleanup handler to free allocated resources, will
* be called immediately after running the main callback */
retro_task_handler_t cleanup;
/* set to true by the handler to signal
* the task has finished executing. */
bool finished;
/* set to true by the task system
* to signal the task *must* end. */
bool cancelled;
/* if true no OSD messages will be displayed. */
bool mute;
/* created by the handler, destroyed by the user */
void *task_data;
/* owned by the user */
void *user_data;
/* created and destroyed by the code related to the handler */
void *state;
/* created by task handler; destroyed by main loop
* (after calling the callback) */
char *error;
/* -1 = unmettered, 0-100 progress value */
int8_t progress;
/* handler can modify but will be
* free()d automatically if non-NULL. */
char *title;
/* don't touch this. */
retro_task_t *next;
};
typedef struct task_finder_data
{
retro_task_finder_t func;
void *userdata;
} task_finder_data_t;
typedef struct task_retriever_info
{
struct task_retriever_info *next;
void *data;
} task_retriever_info_t;
typedef struct task_retriever_data
{
retro_task_handler_t handler;
size_t element_size;
retro_task_retriever_t func;
task_retriever_info_t *list;
} task_retriever_data_t;
bool task_queue_ctl(enum task_queue_ctl_state state, void *data);
void *task_queue_retriever_info_next(task_retriever_info_t **link);
void task_queue_retriever_info_free(task_retriever_info_t *list);
void task_queue_cancel_task(void *task);
RETRO_END_DECLS
#endif
```
|
```objective-c
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_COMPILER_LIVENESS_ANAYZER_H_
#define V8_COMPILER_LIVENESS_ANAYZER_H_
#include "src/bit-vector.h"
#include "src/compiler/node.h"
#include "src/globals.h"
#include "src/zone/zone-containers.h"
namespace v8 {
namespace internal {
namespace compiler {
class LivenessAnalyzerBlock;
class Node;
class StateValuesCache;
class NonLiveFrameStateSlotReplacer {
public:
void ClearNonLiveFrameStateSlots(Node* frame_state, BitVector* liveness);
NonLiveFrameStateSlotReplacer(StateValuesCache* state_values_cache,
Node* replacement, size_t local_count,
bool has_accumulator, Zone* local_zone)
: replacement_node_(replacement),
state_values_cache_(state_values_cache),
local_zone_(local_zone),
permanently_live_(
static_cast<int>(local_count) + (has_accumulator ? 1 : 0),
local_zone),
inputs_buffer_(local_zone),
has_accumulator_(has_accumulator) {}
// TODO(leszeks): Not used by bytecode, remove once AST graph builder is gone.
void MarkPermanentlyLive(int var) { permanently_live_.Add(var); }
private:
Node* ClearNonLiveStateValues(Node* frame_state, BitVector* liveness);
StateValuesCache* state_values_cache() { return state_values_cache_; }
Zone* local_zone() { return local_zone_; }
// Node that replaces dead values.
Node* replacement_node_;
// Reference to state values cache so that we can create state values
// nodes.
StateValuesCache* state_values_cache_;
Zone* local_zone_;
BitVector permanently_live_;
NodeVector inputs_buffer_;
bool has_accumulator_;
};
class V8_EXPORT_PRIVATE LivenessAnalyzer {
public:
LivenessAnalyzer(size_t local_count, bool has_accumulator, Zone* zone);
LivenessAnalyzerBlock* NewBlock();
LivenessAnalyzerBlock* NewBlock(LivenessAnalyzerBlock* predecessor);
void Run(NonLiveFrameStateSlotReplacer* relaxer);
Zone* zone() { return zone_; }
void Print(std::ostream& os);
size_t local_count() { return local_count_; }
private:
void Queue(LivenessAnalyzerBlock* block);
Zone* zone_;
ZoneDeque<LivenessAnalyzerBlock*> blocks_;
size_t local_count_;
// TODO(leszeks): Always true for bytecode, remove once AST graph builder is
// gone.
bool has_accumulator_;
ZoneQueue<LivenessAnalyzerBlock*> queue_;
};
class LivenessAnalyzerBlock {
public:
friend class LivenessAnalyzer;
void Lookup(int var) { entries_.push_back(Entry(Entry::kLookup, var)); }
void Bind(int var) { entries_.push_back(Entry(Entry::kBind, var)); }
void LookupAccumulator() {
DCHECK(has_accumulator_);
// The last entry is the accumulator entry.
entries_.push_back(Entry(Entry::kLookup, live_.length() - 1));
}
void BindAccumulator() {
DCHECK(has_accumulator_);
// The last entry is the accumulator entry.
entries_.push_back(Entry(Entry::kBind, live_.length() - 1));
}
void Checkpoint(Node* node) { entries_.push_back(Entry(node)); }
void AddPredecessor(LivenessAnalyzerBlock* b) { predecessors_.push_back(b); }
LivenessAnalyzerBlock* GetPredecessor() {
DCHECK(predecessors_.size() == 1);
return predecessors_[0];
}
private:
class Entry {
public:
enum Kind { kBind, kLookup, kCheckpoint };
Kind kind() const { return kind_; }
Node* node() const {
DCHECK(kind() == kCheckpoint);
return node_;
}
int var() const {
DCHECK(kind() != kCheckpoint);
return var_;
}
explicit Entry(Node* node) : kind_(kCheckpoint), var_(-1), node_(node) {}
Entry(Kind kind, int var) : kind_(kind), var_(var), node_(nullptr) {
DCHECK(kind != kCheckpoint);
}
private:
Kind kind_;
int var_;
Node* node_;
};
LivenessAnalyzerBlock(size_t id, size_t local_count, bool has_accumulator,
Zone* zone);
void Process(BitVector* result, NonLiveFrameStateSlotReplacer* relaxer);
bool UpdateLive(BitVector* working_area);
void SetQueued() { queued_ = true; }
bool IsQueued() { return queued_; }
ZoneDeque<LivenessAnalyzerBlock*>::const_iterator pred_begin() {
return predecessors_.begin();
}
ZoneDeque<LivenessAnalyzerBlock*>::const_iterator pred_end() {
return predecessors_.end();
}
size_t id() { return id_; }
void Print(std::ostream& os);
ZoneDeque<Entry> entries_;
ZoneDeque<LivenessAnalyzerBlock*> predecessors_;
BitVector live_;
bool queued_;
bool has_accumulator_;
size_t id_;
};
} // namespace compiler
} // namespace internal
} // namespace v8
#endif // V8_COMPILER_AST_GRAPH_BUILDER_H_
```
|
Cer-vit is a family of glass-ceramic materials that were invented by Owens Illinois in the mid-1960s. Its principle ingredients are the oxides of lithium, aluminum and silicon. It is melted to form a glass which is then heat treated to nucleate and crystallize it into a material that is more than 90% microscopic crystals. Its formulation and heat treatment can be modified to produce a variety of material properties. One form is a material that is transparent and has a near zero thermal expansion. Its transparency is because the microscopic crystals are smaller than the wave length of light and are transparent, and its low thermal expansion is because they have a spodumene structure.
Cer-Vit C 101 was used to form large mirror blanks ( in diameter) that were used in telescopes in several places, including South America, France and Australia. Owens Illinois ceased production of C101 in 1978. In addition, Cer-Vit materials were used to make stove tops, cook ware and aviation applications, but never commercialized.
Today, glass-ceramic products such as transparent mirror blanks and stove tops, and cookware are manufactured and in daily use. These products include trade names of Zerodor, Hercuvit, and Pyroceram, most of which have low or zero thermal expansion, which allows them to be exposed to rapid temperature changes or localized heating or cooling.
Applications
At Mount Lemmon Observatory, two 1.5 meter diameter telescopes have a Cer-Vit glass mirror. One of the telescopes discovered 2011 AG5, an asteroid which achieved 1 on the Torino Scale.
References
Bibliography
Structure and Characterization of Lithiumaluminalsilicate Glass and Glass Ceramics derived from Spodumene Mineral. A. Nordman, Y Cheng, T.J. Bastock, Journal of Physics Condensed Matter, Volume 7, Number 16
Glass-ceramics capture $2 million telescope-mirror contract. David H. Taeler, Ceramic Age, August 1968, Volume 84, Number 8
Transparent Glass-Ceramics G. H. Beal, D. A. Duke, Journal of Materials Science 4(1969) 140-152
External links
Glass Types - Oldham Optical
Low thermal expansion glass ceramics - Hans Bach, Dieter Krause
Glass types
Glass-ceramics
Low-expansion glass
Glass trademarks and brands
Transparent materials
|
```c++
# /* **************************************************************************
# * *
# * accompanying file LICENSE_1_0.txt or copy at
# * path_to_url
# * *
# ************************************************************************** */
#
# /* See path_to_url for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_DETAIL_NULL_HPP
# define BOOST_PREPROCESSOR_DETAIL_NULL_HPP
#
# /* empty file */
#
# endif
```
|
The Madonna and Child with Two Musician Angels is an oil-on-panel painting by the Italian Renaissance painter Correggio, now in the Uffizi in Florence. Some date it to 1514–15 but it is more commonly dated to 1515–16.
History
On the back of the painting is a 16th-century monogram from the grand-ducal gallery in Florence, showing the identification number 2523, which does not feature in any of the lists of the gallery's holdings at that time. Though it cannot be clearly traced in any 17th-century inventories, it was probably one of the works taken to Düsseldorf by Anna Maria Luisa de' Medici in 1691 on her marriage to John William, Elector Palatine and which (after John William's death in 1717) were brought back to Florence. The first official mention places the work in the inventory of the Gallerie fiorentine in 1798, in the Sala dei Maestri Italiani, where it remained until the mid-19th century. Many copies were commissioned from the 18th century onwards, attesting to its popularity. It was then attributed to Titian, but Giovanni Morelli reattributed it as an early work by a young Correggio. This became the dominant attribution, supported by "the minute technical execution and the clear and shining colours".
Bibliography
Giuseppe Adani, Correggio pittore universale, Silvana Editoriale, Correggio 2007.
External links
1516 paintings
Paintings of the Madonna and Child by Correggio
Paintings by Correggio in the Uffizi
Angels in art
Musical instruments in art
|
Russell Werner Lee (July 21, 1903 – August 28, 1986) was an American photographer and photojournalist, best known for his work for the Farm Security Administration (FSA) during the Great Depression. His images documented the ethnography of various American classes and cultures.
Early life
The son of Burton Lee and his wife Adeline Werner, Lee grew up in Ottawa, Illinois. He attended Culver Military Academy in Culver, Indiana, for high school. He earned a bachelor's degree in chemical engineering from Lehigh University in Bethlehem, Pennsylvania.
Lee started working as a chemist, but gave up the position to become a painter. Originally he used photography as a precursor to his painting, but soon became interested in photography for its own sake. He recorded the people and places around him. Among his earliest subjects were Pennsylvanian bootleg mining and the Father Divine cult.
Photography
In the fall of 1936, during the Great Depression, Lee was hired for the federally sponsored Farm Security Administration (FSA) photographic documentation project of the Franklin D. Roosevelt administration. He joined a team assembled under Roy Stryker, along with Dorothea Lange, Arthur Rothstein, and Walker Evans. Stryker provided direction and bureaucratic protection to the group, leaving the photographers free to compile what in 1973 was described as "the greatest documentary collection which has ever been assembled."
Over the spring and summer of 1942, Lee was one of several government photographers to document the forced relocation of Japanese Americans from the West Coast. He produced more than 600 images of families waiting to be removed and their later lives in various detention facilities, most located in isolated areas of the interior of the country.
After the FSA was defunded in 1943, Lee served in the Air Transport Command (ATC). During this period, he took photographs of all the airfield approaches used by the ATC to supply the Armed Forces in World War II. In 1946 and 1947, he worked for the United States Department of the Interior (DOI), helping the agency compile a medical survey in communities involved in mining bituminous coal. He created over 4,000 photographs of miners and their working conditions in coal mines. In 1946, Lee completed a series of photos focused on a Pentecostal Church of God in a Kentucky coal camp.
While completing the DOI work, Lee also continued to work under Stryker. He produced public relations photographs for Standard Oil of New Jersey.
In 1947 Lee moved to Austin, Texas, and continued photography. In 1965 he became the first instructor of photography at the University of Texas there.
Legacy
Lee's work is held in collections at the University of Louisville, the New Mexico Museum of Art, Wittliff collections, Texas State University; the Dolph Briscoe Center for American History at the University of Texas at Austin, and the Library of Congress.
In 2016, Lee Elementary, a school in the Austin Independent School District, was renamed Russell Lee Elementary in honor of the photographer.
Selected photographs
References
External links
Bernard Bourrit, "Russell Lee, impossible inventaire" in Gruppen, 2017.
Biographical Sketch of Lee
Online Russell Lee collection
Article about Lee at the University of Texas website
Flickr Photostream: LOC's Archive of Russell Lee's FSA Photos
Wittliff Collection Southwestern and Mexican Photography, Texas State University
"Captured: America in Color from 1939–1943", Denver Post PLog, July 26, 2010.
Brisco – A Guide to the Russell Lee Photograph Collection, University of Texas
Russell Lee's FSA Photos of Pie Town, New Mexico Museum of Art
1903 births
1986 deaths
American photojournalists
Artists from Austin, Texas
Social realism
University of Texas at Austin faculty
People from Ottawa, Illinois
Military personnel from Illinois
Lehigh University alumni
Culver Academies alumni
|
```php
<?php
declare(strict_types=1);
namespace App;
use Exception as PhpException;
use Monolog\Level;
use Throwable;
class Exception extends PhpException
{
/** @var array Any additional data that can be displayed in debugging. */
protected array $extraData = [];
/** @var array Additional data supplied to the logger class when handling the exception. */
protected array $loggingContext = [];
protected ?string $formattedMessage;
public function __construct(
string $message = '',
int $code = 0,
Throwable $previous = null,
protected Level $loggerLevel = Level::Error
) {
parent::__construct($message, $code, $previous);
}
public function setMessage(string $message): void
{
$this->message = $message;
}
/**
* @return string A display-formatted message, if one exists, or
* the regular message if one doesn't.
*/
public function getFormattedMessage(): string
{
return $this->formattedMessage ?? $this->message;
}
/**
* Set a display-formatted message (if one exists).
*/
public function setFormattedMessage(?string $message): void
{
$this->formattedMessage = $message;
}
public function getLoggerLevel(): Level
{
return $this->loggerLevel;
}
public function setLoggerLevel(Level $loggerLevel): void
{
$this->loggerLevel = $loggerLevel;
}
public function addExtraData(int|string $legend, mixed $data): void
{
if (is_array($data)) {
$this->extraData[$legend] = $data;
}
}
/**
* @return mixed[]
*/
public function getExtraData(): array
{
return $this->extraData;
}
public function addLoggingContext(int|string $key, mixed $data): void
{
$this->loggingContext[$key] = $data;
}
public function getLoggingContext(): array
{
return $this->loggingContext;
}
}
```
|
Behadd (; English: Boundless) is a 2013 Pakistani drama film directed by Asim Raza, produced by Momina Duraid, and written by Umera Ahmad. The telefilm stars Fawad Khan, Nadia Jamil, Sajjal Ali, Nadia Afgan, Adnan Siddiqui, Adnan Jaffar and Shamoon Abbasi in pivot roles. Behadd premiered on 23 February 2013 on Hum TV. It was also aired in India on Zindagi, premiering on 30 August 2014.
Behadd reflects upon the relationship dynamics of a 'Parent' and 'Child', and shows how their love for one another becomes the cause of their heartache and the reflection of 'selflessness' verses 'selfishness' in love. Behadd received a Hum Award for Best Television Film at 2nd Hum Awards.
Plot
The story revolves around Masooma, a.k.a. Mo (Nadia Jamil), a working woman and single mother who lives with her fifteen-year-old daughter Maha (Sajjal Ali). After losing her husband in a road accident, Maha becomes Masooma's sole reason for existence; Maha grows into an introvert and is highly possessive of her mother.
One day, Masooma bumps into her best friend's younger brother, Jamal Ahmad, a.k.a. Jo (Fawad Khan). Jamal is Masooma's childhood friend and a divorcee. He visits Masooma's house for dinner and gets along well with Maha. Masooma is surprised as Maha usually doesn't warm up quickly to people. Jo's sister, Poppy (Nausheen), asks Masooma to find a girl for Jo, as she thinks Jo is very young and should remarry. Masooma introduces Shaista (Hira Tareen) to Jo at lunch, where Jo behaves carelessly and shows no interest in the proposal.
Jo starts spending a lot of time with Masooma and Maha, the latter warming up to him even more. Jo soon realises his love for Mo, and waits for the perfect moment to propose to Masooma, leaving her shocked. She refuses as she is a single mother five years older than him. Masooma also feels that Maha will never adjust to having a new father. However, Jo asks her to reconsider her decision as he genuinely loves and respects her and considers Maha, his daughter. Masooma's friend Shafaq (Nadia Afgan) makes her realise that she will never get a better husband than Jo. Shafaq assures her that Jo can be the father figure in Maha's life.
Masooma tells Maha about Jo's proposal and tells her they need someone like Jo in their lives. He has all the qualities of a good companion and a great person. Masooma also says that she will not accept the proposal if Maha is uncomfortable. Though a little taken aback by the proposal, Maha gives her consent to the marriage.
A few days later, Masooma asks Jamal to pick Maha up from school as she is busy with work. When she returns, she finds Maha screaming, seemingly due to Jamal sexually harassing her. Masooma is left guilt-ridden and heartbroken, and she breaks up with Jamal. After six months, Masooma decides to send Maha to London for higher studies, but Maha refuses to go. Maha confides in Shafaq that she framed Jamal because Masooma was falling in love with him, and she had become insecure about losing her mother.
Shafaq tells Maha the importance of Jamal in their lives. Maha then leaves Shafaq's house to apologise to Jamal and tells him why she accused him. Jamal tells her that it is up to her and Masooma to decide whether she wants him in their lives. He also reveals that Masooma is aware of the truth. Jamal explains that after two weeks of the incident, Masooma saw CCTV footage from that day and realised that Jamal was innocent.
Masooma secretly watches Maha apologise to Jamal; both mother and daughter become emotional and hug each other.
Cast
Principal Cast
Fawad Khan as Jamal "Jo" Ahmed
Nadia Jamil as Masooma "Mo" Jamal
Sajal Ali as Maha
Nadia Afgan as Shafaq
Nasheen Masud as Popi "Po" Masood
Rahma Saleem as Fareena
Sana Javed as Laiba (Cameo)
Aiman Khan as Sara
Zainab Raza as Maha's childhood
Maryam Raza as Maha's school friend
Special Appearance
Adnan Siddiqui as Hassan (Masooma's husband)
Adnan Jaffar as Shafaq's husband
Shamoon Abbasi as Masooma's boss
Hira Tareen as Shaista (Jo's proposal)
Production
In 2013, Asim Raza announced in an interview with Daily Times that he would mark his directional debut with Behadd which will be a television film, better known as a 'telefilm' in Pakistan. He clarified that it will be "a long play with substance and will be at par with a telefilm." In mid-2013 casting of the telefilm was confirmed with the cast of Fawad Khan, Nadia Jamil, Sajjal Ali and Nadia Afgan in central roles, while Adnan Siddiqui, Adnan Jaffar and Shamoon Abbasi joined the cast for supporting roles.
Filming
Filming began on 21 April 2013 in Karachi, Sindh. The shooting lasted a month and post-production was completed before 28 May 2013.
Music
The Title song of Behadd known as the Original Soundtrack was given by the music band Kaavish. It was produced, written and composed by Jaffer Zaidi and Maaz Maudood while one song was taken from season two of Coke Studio Pakistan sung and penned down by Zeb and Haniya and produced by Rohail Hyatt. The background score for the film was given by Fawad Khan himself along with Hasil Qureshi.
Track listing
Reception
Release
The film debuted on Hum TV on 8 June 2013, at 9:10 p.m., and had a later on-airing at Zee Zindagi on 30 August 2014. Hum TV also held a red carpet premier for Behadd.
In April 2020, Hum TV uploaded it on its official YouTube channel. It is also available under Zee Zindagi on the ZEE5 app.
Critical response
The film received praise for Asim Raza's direction, Umera Ahmad's story and successful transmission of the story into a play, acting (particularly that of Fawad Khan, Nadia Jamil, Sajjal Ali and Nadia Afgan), drama, moral messages and production values.
Despite strong positive reviews, there was much speculation that Behadd follows the same plot as Hasina Moin's 1980 PTV classic story Gudiya – (Doll).
Accolades
See also
2013 in Pakistani television
List of programs broadcast by Hum TV
References
External links
Official website
Behadd on YouTube
Behadd on Tumblr
Other resources
Behadd on DramasOnline
Reviews
Behadd official review by Reema Ali Syed
Behadd review by Fatima Awan.
Behadd review by Zainab Imam
Hum TV original programming
2013 television films
2013 films
2013 Pakistani television series debuts
Pakistani drama television series
Pakistani television films
Urdu-language television shows
Pakistani romance television series
2013 Pakistani television series endings
Films set in Karachi
Zee Zindagi original programming
Films directed by Asim Raza
|
Amanda Lathlin (born July 17, 1976) is a Canadian politician, who was elected to the Legislative Assembly of Manitoba in a by-election on April 22, 2015. She represents the constituency of The Pas-Kameesak as a member of the New Democratic Party of Manitoba.
She is the daughter of Oscar Lathlin, who represented The Pas in the provincial legislature from 1990 to 2008, and is the first First Nations woman ever elected to the provincial legislature. In the 2019 election, after The Pas riding was redistributed, she won the newly-created riding of The Pas-Kameesak.
Prior to her election to the legislature, Lathlin worked for the University College of the North and served as a band councillor for the Opaskwayak Cree Nation.
Electoral record
References
Cree people
First Nations women in politics
New Democratic Party of Manitoba MLAs
People from The Pas
Women MLAs in Manitoba
Living people
21st-century Canadian politicians
21st-century Canadian women politicians
First Nations politicians
1976 births
Canadian indigenous women academics
|
```scss
.mocks-card-list-item {
padding: 8px;
border-radius: 4px;
color: var(--white);
transition: 0.25s background ease-in-out;
cursor: pointer;
&:hover {
background: var(--surface-1);
}
&:hover .mocks-card-list-item-name {
text-decoration: underline;
text-decoration-color: var(--white);
text-decoration-thickness: 1px;
text-underline-offset: 4px;
}
}
```
|
Events from the year 1825 in France.
Incumbents
Monarch – Charles X
Prime Minister – Joseph de Villèle
Events
January - Anti-Sacrilege Act, law against blasphemy and sacrilege passed under King Charles X. The law is never applied (except for a minor point).
17 April - Charles X recognizes Haiti, 21 years after it expelled the French after the successful Haitian Revolution.
Franco-Trarzan War of 1825, conflict between the forces of the new amir of Trarza, Muhammad al Habib, and France.
Canal Saint-Martin opened in Paris.
Births
January to June
28 February - Jean-Baptiste Arban, cornetist and conductor (died 1889)
16 March - Auguste Poulet-Malassis, printer and publisher (died 1878)
6 May - Charlotte de Rothschild, socialite and painter (died 1899)
7 June - Gustave Emile Boissonade, legal scholar (died 1910)
14 June - Jean-Baptiste Joseph Émile Montégut, critic (died 1895)
30 June - Hervé, composer, librettist and conductor (died 1892)
July to December
2 July - Émile Ollivier, statesman, 30th Prime Minister of France (died 1913)
19 July - Pierre Potain, cardiologist (died 1901)
4 August - Victor Auguste, baron Duperré, colonial administrator (died 1900)
22 August - Auguste Arnaud, sculptor (died 1883)
17 October - Louis Joseph Troost, chemist (died 1911)
31 October - Charles Lavigerie, Cardinal, Primate of Africa (died 1892)
6 November - Charles Garnier, architect (died 1898)
29 November - Jean-Martin Charcot, neurologist and professor of anatomical pathology (died 1893)
30 November - William-Adolphe Bouguereau, painter (died 1905)
25 December - Henri de Bornier, poet and dramatist (died 1901)
Full date unknown
Joseph-Epiphane Darras, historian (died 1878)
Armand Gautier, painter and lithographer (died 1894)
Deaths
January to June
17 January - Antoine-François-Claude Ferrand, statesman and political writer (born 1751)
5 February - Pierre Gaveaux, operatic tenor and composer (born 1761)
17 February - Jean-Baptiste Robert Lindet, politician (born 1746)
25 March - Fabre d'Olivet, author, poet and composer (born 1767)
19 May - Claude Henri de Rouvroy, comte de Saint-Simon, utopian socialist thinker (born 1760)
21 May - André Briche, General (born 1772)
9 June - Pauline Bonaparte, younger and favourite sister of Napoleon I of France (born 1780)
July to December
26 September - Guillaume-André-Réné Baston, theologian (born 1741)
28 November - Maximilien Sebastien Foy, military leader, statesman and writer (born 1775)
3 December - Adélaïde Dufrénoy, poet and painter (born 1765)
5 December - Antoine Alexandre Barbier, librarian and bibliographer (born 1765)
29 December - Jacques-Louis David, painter (born 1748)
Full date unknown
Guillaume de Bonne-Carrere, diplomat (born 1754)
Raphaël, Comte de Casabianca, General (born 1738)
See also
References
1820s in France
|
Bara Suzapur is a census town in the Kaliachak I CD block in the Malda Sadar subdivision of Malda district in the state of West Bengal, India.
Geography
Location
Bara Suzapur is located at .
According to the map of Kaliachak CD block in the District Census Handbook, Maldah, 2011, Chhota Suzapur, Bara Suzapur, Chaspara, Nazirpur, Bamangram and Jalalpur form a cluster of census towns.
Area overview
The area shown in the adjoining map is the physiographic sub-region known as the diara. It "is a relatively well drained flat land formed by the fluvial deposition of newer alluvium." The most note-worthy feature is the Farakka Barrage across the Ganges. The area is a part of the Malda Sadar subdivision, which is an overwhelmingly rural region, but the area shown in the map has pockets of urbanization with 17 census towns, concentrated mostly in the Kaliachak I CD block. The bank of the Ganges between Bhutni and Panchanandapur (both the places are marked on the map), is the area worst hit by left bank erosion, a major problem in the Malda area. The ruins of Gauda, capital of several empires, is located in this area.
Note: The map alongside presents some of the notable locations in the area. All places marked in the map are linked in the larger full screen map.
Demographics
According to the 2011 Census of India, Bara Suzapur had a total population of 15,808, of which 8,129 (51%) were males and 7,675 (49%) were females. Population in the age range 0–6 years was 2,509. The total number of literate persons in Bara Suzapur was 10,315 (77.56% of the population over 6 years).
Infrastructure
According to the District Census Handbook, Maldah, 2011, Bara Suzapur covered an area of 2.4036 km2. It had 10 km roads with open drains. The protected water-supply involved overhead tank, pressure tank, tap water from treated sources, hand pump. It had 340 domestic electric connections. Among the medical facilities it had 1 hospital (with 15 beds), 1 veterinary hospital, 8 medicine shops. Among the educational facilities, it had 1 senior secondary school in town, the nearest general degree college at Malda 12 km away. It had 2 recognised typewriting, shorthand and vocational training institutes, 2 non-formal education centres (Sarva Siksha Abhiyan). Among the social, recreational and cultural facilities, it had 1 public library. It produced resham silk, mango products, beedi. It had branch offices of 2 nationalised banks, 1 private commercial bank, 1 cooperative bank.
Healthcare
There is a primary health centre, with 10 beds at Sujapur.
References
Cities and towns in Malda district
|
```html
---
layout: default
theme: love
route: love
---
{% include global/header.html %}
{%
include docs/hero.html
title="Love for Bulma"
subtitle="Happy thoughts from all around the world."
%}
{% assign encoded_url = site.data.meta.title | urlencode %}
{% assign encoded_url_bis = 'path_to_url | urlencode %}
{% assign tweet_href = 'path_to_url | append: encoded_url | append: '&hashtags=bulmaio&url=' | append: encoded_url_bis | append: '&via=jgthms' %}
{% capture call_button %}
{% include
docs/elements/tw-button.html
label="Tweet #bulmaio"
href=tweet_href
%}
{% endcapture %}
{%
include docs/components/call.html
color="love"
text='Are you a Bulma fan too? <strong>Show your support!</strong> <span style="font-size: 20px; margin-left: 2px; position: relative; top: 1px;"></span>'
button=call_button
%}
<script type="text/javascript">
function compareTweets(key) {
return (a, b) => {
const avalue = parseInt(a.dataset[key]);
const bvalue = parseInt(b.dataset[key]);
if (avalue > bvalue)
return -1;
if (avalue < bvalue)
return 1;
return 0;
}
}
function sortTweets(key) {
const $pills = document.querySelectorAll("#bd-pills .bd-pill-button");
$pills.forEach($pill => $pill.classList.remove('is-active'));
window.event.target.classList.add('is-active');
const $tweets = document.querySelectorAll("#love-tweets .bd-tw");
const tweets = Array.from($tweets);
let sorted = tweets.sort(compareTweets(key));
sorted.forEach(e =>
document.querySelector("#love-tweets .bd-tws-list").appendChild(e));
}
</script>
<nav id="bd-pills" class="bd-pills">
<div class="bd-pills-body">
<span class="bd-pill-label">Sort by</span>
<button class="bd-pill-button is-active" onclick="sortTweets('id')">Date</button>
<button class="bd-pill-button" onclick="sortTweets('likes')">Likes</button>
</div>
</nav>
<div id="love-tweets" class="bd-tws">
<div class="bd-tws-list">
{% for tweet_pair in site.data.love.tweets_by_id reversed %}
{% assign tweet_id = tweet_pair[0] %}
{% include docs/elements/tw.html tweet_id=tweet_id %}
{% endfor %}
</div>
</div>
```
|
```c
/* $OpenBSD: wcschr.c,v 1.6 2015/10/01 02:32:07 guenther Exp $ */
/* $NetBSD: wcschr.c,v 1.2 2001/01/03 14:29:36 lukem Exp $ */
/*-
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
*
* citrus Id: wcschr.c,v 1.2 2000/12/21 05:07:25 itojun Exp
*/
#include <wchar.h>
wchar_t *
wcschr(const wchar_t *s, wchar_t c)
{
const wchar_t *p;
p = s;
for (;;) {
if (*p == c) {
return (wchar_t *)p;
}
if (!*p)
return NULL;
p++;
}
/* NOTREACHED */
}
```
|
Marina Anatolyevna Pankova née Nikulina (; 3 March 1963 – 4 November 2015) was a Russian volleyball player who was a member of the Soviet team that won the gold medal at the 1988 Summer Olympics. Four years later, she won a silver medal with the Unified Team at the 1992 Summer Olympics.
References
External links
1963 births
2015 deaths
People from Bratsk
Soviet women's volleyball players
Russian women's volleyball players
Volleyball players at the 1988 Summer Olympics
Volleyball players at the 1992 Summer Olympics
Volleyball players at the 1996 Summer Olympics
Olympic volleyball players for the Soviet Union
Olympic volleyball players for the Unified Team
Olympic volleyball players for Russia
Olympic silver medalists for the Unified Team
Olympic gold medalists for the Soviet Union
Olympic medalists in volleyball
Medalists at the 1992 Summer Olympics
Medalists at the 1988 Summer Olympics
Competitors at the 1994 Goodwill Games
Goodwill Games medalists in volleyball
Galatasaray S.K. (women's volleyball) players
Russian expatriate sportspeople in Spain
Russian expatriate sportspeople in Turkey
Expatriate volleyball players in Spain
Expatriate volleyball players in Turkey
Sportspeople from Irkutsk Oblast
|
```html
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Struct template type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >></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. Boost.Icl">
<link rel="up" href="../../header/boost/icl/separate_interval_set_hpp.html" title="Header <boost/icl/separate_interval_set.hpp>">
<link rel="prev" href="is_interval_se_idp59549488.html" title="Struct template is_interval_separator<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>">
<link rel="next" href="../../header/boost/icl/split_interval_map_hpp.html" title="Header <boost/icl/split_interval_map.hpp>">
</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="../../../../../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="is_interval_se_idp59549488.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../header/boost/icl/separate_interval_set_hpp.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="../../header/boost/icl/split_interval_map_hpp.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="refentry">
<a name="boost.icl.type_to_string_idp59558992"></a><div class="titlepage"></div>
<div class="refnamediv">
<h2><span class="refentrytitle">Struct template type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >></span></h2>
<p>boost::icl::type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >></p>
</div>
<h2 xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" class="refsynopsisdiv-title">Synopsis</h2>
<div xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: <<a class="link" href="../../header/boost/icl/separate_interval_set_hpp.html" title="Header <boost/icl/separate_interval_set.hpp>">boost/icl/separate_interval_set.hpp</a>>
</span><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> DomainT<span class="special">,</span> <span class="identifier">ICL_COMPARE</span> Compare<span class="special">,</span>
<span class="identifier">ICL_INTERVAL</span><span class="special">(</span><span class="identifier">ICL_COMPARE</span><span class="special">)</span> Interval<span class="special">,</span> <span class="identifier">ICL_ALLOC</span> Alloc<span class="special">></span>
<span class="keyword">struct</span> <a class="link" href="type_to_string_idp59558992.html" title="Struct template type_to_string<icl::separate_interval_set< DomainT, Compare, Interval, Alloc >>">type_to_string</a><span class="special"><</span><span class="identifier">icl</span><span class="special">::</span><span class="identifier">separate_interval_set</span><span class="special"><</span> <span class="identifier">DomainT</span><span class="special">,</span> <span class="identifier">Compare</span><span class="special">,</span> <span class="identifier">Interval</span><span class="special">,</span> <span class="identifier">Alloc</span> <span class="special">></span><span class="special">></span> <span class="special">{</span>
<span class="comment">// <a class="link" href="type_to_string_idp59558992.html#idp59564096-bb">public static functions</a></span>
<span class="keyword">static</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <a class="link" href="type_to_string_idp59558992.html#idp59564656-bb"><span class="identifier">apply</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div>
<div class="refsect1">
<a name="idp124069184"></a><h2>Description</h2>
<div class="refsect2">
<a name="idp124069600"></a><h3>
<a name="idp59564096-bb"></a><code class="computeroutput">type_to_string</code> public static functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><pre class="literallayout"><span class="keyword">static</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <a name="idp59564656-bb"></a><span class="identifier">apply</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre></li></ol></div>
</div>
</div>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
GmbH<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="is_interval_se_idp59549488.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../header/boost/icl/separate_interval_set_hpp.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="../../header/boost/icl/split_interval_map_hpp.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
```html
<html>
<head>
<title>NVIDIA(R) PhysX(R) SDK 3.4 API Reference: Class Members - Functions</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<LINK HREF="NVIDIA.css" REL="stylesheet" TYPE="text/css">
</head>
<body bgcolor="#FFFFFF">
<div id="header">
<hr class="first">
<img alt="" src="images/PhysXlogo.png" align="middle"> <br>
<center>
<a class="qindex" href="main.html">Main Page</a>
<a class="qindex" href="hierarchy.html">Class Hierarchy</a>
<a class="qindex" href="annotated.html">Compound List</a>
<a class="qindex" href="functions.html">Compound Members</a>
</center>
<hr class="second">
</div>
<!-- Generated by Doxygen 1.5.8 -->
<div class="tabs">
<ul>
<li><a href="functions.html"><span>All</span></a></li>
<li class="current"><a href="functions_func.html"><span>Functions</span></a></li>
<li><a href="functions_vars.html"><span>Variables</span></a></li>
<li><a href="functions_type.html"><span>Typedefs</span></a></li>
<li><a href="functions_enum.html"><span>Enumerations</span></a></li>
<li><a href="functions_eval.html"><span>Enumerator</span></a></li>
<li><a href="functions_rela.html"><span>Related Functions</span></a></li>
</ul>
</div>
<div class="tabs">
<ul>
<li><a href="functions_func.html#index_a"><span>a</span></a></li>
<li><a href="functions_func_0x62.html#index_b"><span>b</span></a></li>
<li><a href="functions_func_0x63.html#index_c"><span>c</span></a></li>
<li><a href="functions_func_0x64.html#index_d"><span>d</span></a></li>
<li><a href="functions_func_0x65.html#index_e"><span>e</span></a></li>
<li><a href="functions_func_0x66.html#index_f"><span>f</span></a></li>
<li><a href="functions_func_0x67.html#index_g"><span>g</span></a></li>
<li><a href="functions_func_0x68.html#index_h"><span>h</span></a></li>
<li><a href="functions_func_0x69.html#index_i"><span>i</span></a></li>
<li><a href="functions_func_0x6c.html#index_l"><span>l</span></a></li>
<li><a href="functions_func_0x6d.html#index_m"><span>m</span></a></li>
<li><a href="functions_func_0x6e.html#index_n"><span>n</span></a></li>
<li><a href="functions_func_0x6f.html#index_o"><span>o</span></a></li>
<li class="current"><a href="functions_func_0x70.html#index_p"><span>p</span></a></li>
<li><a href="functions_func_0x72.html#index_r"><span>r</span></a></li>
<li><a href="functions_func_0x73.html#index_s"><span>s</span></a></li>
<li><a href="functions_func_0x74.html#index_t"><span>t</span></a></li>
<li><a href="functions_func_0x75.html#index_u"><span>u</span></a></li>
<li><a href="functions_func_0x76.html#index_v"><span>v</span></a></li>
<li><a href="functions_func_0x77.html#index_w"><span>w</span></a></li>
<li><a href="functions_func_0x7a.html#index_z"><span>z</span></a></li>
<li><a href="functions_func_0x7e.html#index_~"><span>~</span></a></li>
</ul>
</div>
<div class="contents">
<p>
<h3><a class="anchor" name="index_p">- p -</a></h3><ul>
<li>pairFound()
: <a class="el" href="classPxSimulationFilterCallback.html#a434e6ecd4e0cfa7bede6c9ad10d319e">PxSimulationFilterCallback</a>
<li>pairLost()
: <a class="el" href="classPxSimulationFilterCallback.html#da6fcf31c0678d3852f926f545884b3e">PxSimulationFilterCallback</a>
<li>patchupPointers()
: <a class="el" href="classPxVehicleWheels.html#07c073158a6df39214f655f59d130b69">PxVehicleWheels</a>
<li>patchUpPointers()
: <a class="el" href="classPxVehicleWheelsSimData.html#7b605042d1ef0fbd4dd84491e058c1cf">PxVehicleWheelsSimData</a>
<li>patchupPointers()
: <a class="el" href="classPxVehicleDrive.html#8548cd5c20014542d09506ee33cba69e">PxVehicleDrive</a>
<li>patchUpPointers()
: <a class="el" href="classPxVehicleWheelsDynData.html#e417ce1c175c365484f341dd537dc886">PxVehicleWheelsDynData</a>
<li>peek()
: <a class="el" href="classPxFileBuf.html#63e0abac3fa4cf71760142dd7088ef36">PxFileBuf</a>
<li>plane()
: <a class="el" href="classPxGeometryHolder.html#da7be9a86ef1c21903f8a6999449f8c9">PxGeometryHolder</a>
<li>platformMismatch()
: <a class="el" href="classPxCooking.html#82e0864b92d51d409f3134cc8f740102">PxCooking</a>
<li>pointDistance()
: <a class="el" href="classPxGeometryQuery.html#248da4b70cd35bd32d4481775b4c9821">PxGeometryQuery</a>
<li>pointFromUV()
: <a class="el" href="classPxTriangle.html#a8871506b2da5d6a82ffb5bb7410cb39">PxTriangle</a>
<li>pointInPlane()
: <a class="el" href="classPxPlane.html#b2e1652edb0075afcdf4e28f513ec736">PxPlane</a>
<li>poseExtent()
: <a class="el" href="group__foundation.html#g7141493e2ce93a7c29947147874eb372">PxBounds3</a>
<li>postFilter()
: <a class="el" href="classPxQueryFilterCallback.html#a93cf87c4ec4548afc8cc5476c719781">PxQueryFilterCallback</a>
<li>preFilter()
: <a class="el" href="classPxQueryFilterCallback.html#227beae6749182b04ae18728c1aecd26">PxQueryFilterCallback</a>
<li>prepareData()
: <a class="el" href="classPxConstraintConnector.html#f04ac1b3cbd43565ac99957dd9cde100">PxConstraintConnector</a>
<li>process()
: <a class="el" href="classPxProcessPxBaseCallback.html#b0421495c7988c6b2300ee52d92918fc">PxProcessPxBaseCallback</a>
<li>processCallbacks()
: <a class="el" href="classPxScene.html#9f212d5f07851efca3731594eccbccfd">PxScene</a>
<li>processShapes()
: <a class="el" href="structPxVolumeCache_1_1Iterator.html#865f03b842d2e74a249ed840435d17a9">PxVolumeCache::PxVolumeCache::Iterator</a>
<li>processTouches()
: <a class="el" href="structPxHitCallback.html#9c6fc25eb66c22dad2a35d5630d4ec68">PxHitCallback< HitType ></a>
, <a class="el" href="structPxHitBuffer.html#f60ac2d3405c5af467f767f812f3f01d">PxHitBuffer< HitType ></a>
<li>project()
: <a class="el" href="classPxPlane.html#3d23d45c05f3ad071d8f77cf78a5b231">PxPlane</a>
<li>ptr()
: <a class="el" href="classPxStrideIterator.html#02ce9aba790d7ae3842376c5e9f34adb">PxStrideIterator< T ></a>
<li>purgeControllers()
: <a class="el" href="classPxControllerManager.html#78043dd98d6ff9c6fec577fb367a3a1f">PxControllerManager</a>
<li>put()
: <a class="el" href="classPxGeometryHolder.html#ed9b1ec5ec2cacafa9e3d5ee43dabc7b">PxGeometryHolder</a>
<li>putToSleep()
: <a class="el" href="classPxArticulation.html#b7da60ba6a4a5b7068115dc79a545b73">PxArticulation</a>
, <a class="el" href="classPxRigidDynamic.html#ae00aa2067a2fe268b999aad04f27c28">PxRigidDynamic</a>
, <a class="el" href="classPxCloth.html#f6f826b1ea5bcde8aadcbdc0775b1ce1">PxCloth</a>
<li>Px1DConstraintFlag()
: <a class="el" href="structPx1DConstraintFlag.html#7257c40cb8c4724bd3dc33b357f9ab84">Px1DConstraintFlag</a>
<li>PX_ALIGN()
: <a class="el" href="structPxContactPatch.html#3e3339828c1f435a5feda69f2a603f04">PxContactPatch</a>
, <a class="el" href="structPxExtendedContact.html#3aa89b24ea6a047ecd3bbe9afb66c404">PxExtendedContact</a>
, <a class="el" href="structPxModifiableContact.html#f8d69f98f2518b9295d72dbaac501ff2">PxModifiableContact</a>
, <a class="el" href="structPxRigidBodyData.html#8330c5ededefabed26dc861f14a23299">PxRigidBodyData</a>
, <a class="el" href="structPxContactPatch.html#43c76bf63475b98545b19d4b3705adba">PxContactPatch</a>
<li>PxActor()
: <a class="el" href="classPxActor.html#05d86747e2fc14c89497fa06c8f0f252">PxActor</a>
<li>PxActorShape()
: <a class="el" href="structPxActorShape.html#05dd357bb0aba0bb5dd8150be3f9857e">PxActorShape</a>
<li>PxAggregate()
: <a class="el" href="classPxAggregate.html#5a056899bfb00d7165bd04bcb6e0dc52">PxAggregate</a>
<li>PxArticulation()
: <a class="el" href="classPxArticulation.html#34e5bd7f69fc0de6c32a9bdd86ad42cc">PxArticulation</a>
<li>PxArticulationDriveCache()
: <a class="el" href="classPxArticulationDriveCache.html#3694fca773d3027d309732183dcfa737">PxArticulationDriveCache</a>
<li>PxArticulationJoint()
: <a class="el" href="classPxArticulationJoint.html#8ecb6fb89ec7e18314cfc9c6b255bd41">PxArticulationJoint</a>
<li>PxArticulationLink()
: <a class="el" href="classPxArticulationLink.html#ce5afc3529010882d65234d3a2954665">PxArticulationLink</a>
<li>PxBase()
: <a class="el" href="classPxBase.html#263f1ef821c74058ce9335e06cb842a4">PxBase</a>
<li>PxBaseTask()
: <a class="el" href="classphysx_1_1PxBaseTask.html#387b986ef3916322502452724d9ba582">physx::PxBaseTask</a>
<li>PxBatchQueryDesc()
: <a class="el" href="group__physics.html#g7c50eeff3e586897d4441a18e43b7237">PxBatchQueryDesc</a>
<li>PxBatchQueryMemory()
: <a class="el" href="structPxBatchQueryMemory.html#048b4eea81e88e96e8c7b74445a1020d">PxBatchQueryMemory</a>
<li>PxBinaryConverter()
: <a class="el" href="classPxBinaryConverter.html#76e9b36969e46ef131f22d2d95aa31cb">PxBinaryConverter</a>
<li>PxBitAndDataT()
: <a class="el" href="classPxBitAndDataT.html#d756412651559e3d4545581d39abb058">PxBitAndDataT< storageType, bitMask ></a>
<li>PxBoundedData()
: <a class="el" href="structPxBoundedData.html#60c37ab46c80399c8228035b36ae7604">PxBoundedData</a>
<li>PxBounds3()
: <a class="el" href="classPxBounds3.html#127d0cb9a4212d0ab70d086e28f0c3f7">PxBounds3</a>
<li>PxBoxController()
: <a class="el" href="classPxBoxController.html#5182b7d6bd38b10d31ecdc6453b0ecbe">PxBoxController</a>
<li>PxBoxControllerDesc()
: <a class="el" href="group__character.html#g5d8e29dacee8a0a6543029435c0d5dc6">PxBoxControllerDesc</a>
<li>PxBoxGeometry()
: <a class="el" href="classPxBoxGeometry.html#ab5633a2c4280cc591bf9f13902405c2">PxBoxGeometry</a>
<li>PxBoxObstacle()
: <a class="el" href="classPxBoxObstacle.html#9f4e679d66f76565b0b2bf09fc6a2026">PxBoxObstacle</a>
<li>PxBVH33TriangleMesh()
: <a class="el" href="classPxBVH33TriangleMesh.html#47a4931d52d707691d9eee2b30e3bd24">PxBVH33TriangleMesh</a>
<li>PxBVH34TriangleMesh()
: <a class="el" href="classPxBVH34TriangleMesh.html#38a81b9df1a936497f665c65ee1bc9c2">PxBVH34TriangleMesh</a>
<li>PxCapsuleController()
: <a class="el" href="classPxCapsuleController.html#600fba0f4d5bc98c70e45c162f0b6dd6">PxCapsuleController</a>
<li>PxCapsuleControllerDesc()
: <a class="el" href="group__character.html#g9a157f74e3a2d7c0756bd527ca69d387">PxCapsuleControllerDesc</a>
<li>PxCapsuleGeometry()
: <a class="el" href="classPxCapsuleGeometry.html#5764bb1f327ae431aaf875560930e41f">PxCapsuleGeometry</a>
<li>PxCapsuleObstacle()
: <a class="el" href="classPxCapsuleObstacle.html#6b02c2ce8d27fc144a3d6384692f8f57">PxCapsuleObstacle</a>
<li>PxCloth()
: <a class="el" href="classPxCloth.html#d7f51836089966060cb8e2a980deac85">PxCloth</a>
<li>PxClothCollisionPlane()
: <a class="el" href="structPxClothCollisionPlane.html#c2109f7d48a1a56beae79591a26f77b9">PxClothCollisionPlane</a>
<li>PxClothCollisionSphere()
: <a class="el" href="structPxClothCollisionSphere.html#f7f3ff5f23299fc3c1f4956c634efc14">PxClothCollisionSphere</a>
<li>PxClothCollisionTriangle()
: <a class="el" href="structPxClothCollisionTriangle.html#9f876a5633bba15bde95711884a61115">PxClothCollisionTriangle</a>
<li>PxClothFabric()
: <a class="el" href="classPxClothFabric.html#57fdb4cae7066205298f234ff7e5c15d">PxClothFabric</a>
<li>PxClothFabricCooker()
: <a class="el" href="classPxClothFabricCooker.html#b837011efb0ada8bc6a9866d539ec72f">PxClothFabricCooker</a>
<li>PxClothFabricDesc()
: <a class="el" href="group__cloth.html#g67e57148524e0336ebc001c5dc9f345f">PxClothFabricDesc</a>
<li>PxClothFabricPhase()
: <a class="el" href="group__cloth.html#ga6666ad3d3501085542b7c9ccc94a8d7">PxClothFabricPhase</a>
<li>PxClothGeodesicTetherCooker()
: <a class="el" href="classPxClothGeodesicTetherCooker.html#c6ca1841c73fd3b6fe485ac6159cfa1e">PxClothGeodesicTetherCooker</a>
<li>PxClothMeshDesc()
: <a class="el" href="group__cooking.html#g5f214c974f4031e62cfed89231ee1d65">PxClothMeshDesc</a>
<li>PxClothMeshQuadifier()
: <a class="el" href="classPxClothMeshQuadifier.html#65bc6ac7630b441cf9c9f3a153119c3c">PxClothMeshQuadifier</a>
<li>PxClothMotionConstraintConfig()
: <a class="el" href="structPxClothMotionConstraintConfig.html#0139d62ddc4315632ea7dd773e8498ee">PxClothMotionConstraintConfig</a>
<li>PxClothParticle()
: <a class="el" href="structPxClothParticle.html#d001c98574b520a472c4fe69c5feda97">PxClothParticle</a>
<li>PxClothParticleMotionConstraint()
: <a class="el" href="structPxClothParticleMotionConstraint.html#428b98638f5d2b52a9b3cb448686b9c1">PxClothParticleMotionConstraint</a>
<li>PxClothParticleSeparationConstraint()
: <a class="el" href="structPxClothParticleSeparationConstraint.html#f005d1595e3341242d4f1f982432da44">PxClothParticleSeparationConstraint</a>
<li>PxClothSimpleTetherCooker()
: <a class="el" href="classPxClothSimpleTetherCooker.html#12acbb7e523e2b1cff25a41add360e79">PxClothSimpleTetherCooker</a>
<li>PxClothStretchConfig()
: <a class="el" href="structPxClothStretchConfig.html#94ea9465247eaace088e6a358c161ae5">PxClothStretchConfig</a>
<li>PxClothTetherConfig()
: <a class="el" href="structPxClothTetherConfig.html#d8c144efc57cfd6eca2740538295d76e">PxClothTetherConfig</a>
<li>PxCollection()
: <a class="el" href="classPxCollection.html#3cf81c15b4dcd6e16f56c1d0bc383ba3">PxCollection</a>
<li>PxConstraint()
: <a class="el" href="classPxConstraint.html#505f367bc330fa15970154faf7f75d47">PxConstraint</a>
<li>PxConstraintInfo()
: <a class="el" href="structPxConstraintInfo.html#073f7587ffb496c4bdc470eb34032fd2">PxConstraintInfo</a>
<li>PxConstraintInvMassScale()
: <a class="el" href="structPxConstraintInvMassScale.html#92d334aba103ace81f47efdf17e10e6b">PxConstraintInvMassScale</a>
<li>PxContactPair()
: <a class="el" href="structPxContactPair.html#d9a904aa67a0cec9887d03521c636d9e">PxContactPair</a>
<li>PxContactPairExtraDataItem()
: <a class="el" href="structPxContactPairExtraDataItem.html#79c3bb558f707953197bd57b15baa0fe">PxContactPairExtraDataItem</a>
<li>PxContactPairExtraDataIterator()
: <a class="el" href="structPxContactPairExtraDataIterator.html#f5d36be4d51a22af103523375a04d5e0">PxContactPairExtraDataIterator</a>
<li>PxContactPairHeader()
: <a class="el" href="structPxContactPairHeader.html#d5ae557cec81ae4c92b0e987b682af7d">PxContactPairHeader</a>
<li>PxContactPairIndex()
: <a class="el" href="structPxContactPairIndex.html#0aae6856f18cbe9040c586ef4852a862">PxContactPairIndex</a>
<li>PxContactPairPose()
: <a class="el" href="structPxContactPairPose.html#a6ed45b56106284558faeebdde10c8f1">PxContactPairPose</a>
<li>PxContactPairVelocity()
: <a class="el" href="structPxContactPairVelocity.html#413001492fb89e7e85dd76ed7a8d8f6d">PxContactPairVelocity</a>
<li>PxContactStreamIterator()
: <a class="el" href="structPxContactStreamIterator.html#1fff9bd121666ef99f0610ed37168e55">PxContactStreamIterator</a>
<li>PxController()
: <a class="el" href="classPxController.html#4694a2b9523adf437e190e0d15257ef1">PxController</a>
<li>PxControllerDesc()
: <a class="el" href="group__character.html#g749a16c7bcdb8341d346abe43c023c12">PxControllerDesc</a>
<li>PxControllerFilters()
: <a class="el" href="classPxControllerFilters.html#227af0c6a4dd87dc7b40e8ba4fda2c92">PxControllerFilters</a>
<li>PxControllerManager()
: <a class="el" href="classPxControllerManager.html#801a75dc7e874c8f65e13baa5aaf6a04">PxControllerManager</a>
<li>PxConvexMesh()
: <a class="el" href="classPxConvexMesh.html#54250e0e545e7d32586f981b1e217526">PxConvexMesh</a>
<li>PxConvexMeshDesc()
: <a class="el" href="group__cooking.html#g2b98217f34d8856ebe839821740ac438">PxConvexMeshDesc</a>
<li>PxConvexMeshGeometry()
: <a class="el" href="classPxConvexMeshGeometry.html#9a514176c85b854f1a32b0d3ae0c00bc">PxConvexMeshGeometry</a>
<li>PxCookingParams()
: <a class="el" href="structPxCookingParams.html#738bc9799f789da5c453cadae5eaec47">PxCookingParams</a>
<li>PxD6Joint()
: <a class="el" href="classPxD6Joint.html#aa40f40276764b205e795befd10d1a50">PxD6Joint</a>
<li>PxD6JointDrive()
: <a class="el" href="classPxD6JointDrive.html#fc858c65b698a54bcdbe8036de4ff82b">PxD6JointDrive</a>
<li>PxDebugLine()
: <a class="el" href="structPxDebugLine.html#10269eccc2fe05978ff765aca850c2c4">PxDebugLine</a>
<li>PxDebugPoint()
: <a class="el" href="structPxDebugPoint.html#fbafc4862a38a0db581d2382ead4296a">PxDebugPoint</a>
<li>PxDebugText()
: <a class="el" href="structPxDebugText.html#3d263f21a8ed41bebda87ab9729f5df8">PxDebugText</a>
<li>PxDebugTriangle()
: <a class="el" href="structPxDebugTriangle.html#9680024224f24c2e94d0f3be8bad0b02">PxDebugTriangle</a>
<li>PxDefaultErrorCallback()
: <a class="el" href="classPxDefaultErrorCallback.html#cbbaca1f9ad004bf4a08580e2013310f">PxDefaultErrorCallback</a>
<li>PxDefaultFileInputData()
: <a class="el" href="classPxDefaultFileInputData.html#2c88c3e9ccea05b57cef38fcba31e574">PxDefaultFileInputData</a>
<li>PxDefaultFileOutputStream()
: <a class="el" href="classPxDefaultFileOutputStream.html#add35e22bcb4df88ea5a0f688b836cdb">PxDefaultFileOutputStream</a>
<li>PxDefaultMemoryInputData()
: <a class="el" href="classPxDefaultMemoryInputData.html#c8fb2f18c72eeac8eddcd2e018705de4">PxDefaultMemoryInputData</a>
<li>PxDefaultMemoryOutputStream()
: <a class="el" href="classPxDefaultMemoryOutputStream.html#8d2f97d7f4f7a06f86459125eff5f906">PxDefaultMemoryOutputStream</a>
<li>PxDeletionListener()
: <a class="el" href="classPxDeletionListener.html#fc09e12240bd133f30d23fd73adb62d2">PxDeletionListener</a>
<li>PxDeserializationContext()
: <a class="el" href="classPxDeserializationContext.html#18007433a2cc90ef8ccf4353fb8b123d">PxDeserializationContext</a>
<li>PxDistanceJoint()
: <a class="el" href="classPxDistanceJoint.html#ae85edd4c5a075bbefb05045efe264dc">PxDistanceJoint</a>
<li>PxDominanceGroupPair()
: <a class="el" href="structPxDominanceGroupPair.html#395d82a00772ffb5ea3b8ad10b510f94">PxDominanceGroupPair</a>
<li>PxExtendedVec3()
: <a class="el" href="structPxExtendedVec3.html#d00ecb9928814db7d497ecd9b3c7686a">PxExtendedVec3</a>
<li>PxFileBuf()
: <a class="el" href="classPxFileBuf.html#e46af0c1492c02d53ed1488361b5c7d6">PxFileBuf</a>
<li>PxFilterData()
: <a class="el" href="structPxFilterData.html#469ff4e6a40879e92ed4dc5de4b68a48">PxFilterData</a>
<li>PxFilterInfo()
: <a class="el" href="structPxFilterInfo.html#ecaeb3497f2990e0f45fed7c5034d503">PxFilterInfo</a>
<li>PxFixedJoint()
: <a class="el" href="classPxFixedJoint.html#0b7b4136d03244ee300096764be4ad7c">PxFixedJoint</a>
<li>PxFixedSizeLookupTable()
: <a class="el" href="classPxFixedSizeLookupTable.html#54ad0271b5dfd72f31bc7a5935a95c42">PxFixedSizeLookupTable< NB_ELEMENTS ></a>
<li>PxFlags()
: <a class="el" href="classPxFlags.html#5772810962f40450a773af8c5aaf9b52">PxFlags< enumtype, storagetype ></a>
<li>PxgDynamicsMemoryConfig()
: <a class="el" href="structPxgDynamicsMemoryConfig.html#23f805337d85ee65a944feb8458659cf">PxgDynamicsMemoryConfig</a>
<li>PxGeometry()
: <a class="el" href="classPxGeometry.html#2507c9f4d63fe816968fe9a2744ac549">PxGeometry</a>
<li>PxGeometryHolder()
: <a class="el" href="classPxGeometryHolder.html#6baa5591f15ee31feb06bf32774be779">PxGeometryHolder</a>
<li>PxGpuTask()
: <a class="el" href="classphysx_1_1PxGpuTask.html#7d727e580b4bca6074447f178aded143">physx::PxGpuTask</a>
<li>PxGroupsMask()
: <a class="el" href="classPxGroupsMask.html#b11d864275e39aae95f32c3feab00afc">PxGroupsMask</a>
<li>PxHeightField()
: <a class="el" href="classPxHeightField.html#3687346446cb1c0f7ec1e36ccebb0e65">PxHeightField</a>
<li>PxHeightFieldDesc()
: <a class="el" href="group__geomutils.html#g0e3fd140462fac286debed6c6a960c3d">PxHeightFieldDesc</a>
<li>PxHeightFieldGeometry()
: <a class="el" href="classPxHeightFieldGeometry.html#211bb1407a1be542699e5e73ceaabbe5">PxHeightFieldGeometry</a>
<li>PxHitBuffer()
: <a class="el" href="structPxHitBuffer.html#89bcec685c76c5cdc0662eb52b67d699">PxHitBuffer< HitType ></a>
<li>PxHitCallback()
: <a class="el" href="structPxHitCallback.html#062cff2cdd2dfe1f63d0549758ea2627">PxHitCallback< HitType ></a>
<li>PxJoint()
: <a class="el" href="classPxJoint.html#e0d4e45e29a51cf4953e22eaf0e7a22b">PxJoint</a>
<li>PxJointAngularLimitPair()
: <a class="el" href="classPxJointAngularLimitPair.html#dc790f4203b0608a63ef886a49e8e2c1">PxJointAngularLimitPair</a>
<li>PxJointLimitCone()
: <a class="el" href="classPxJointLimitCone.html#6b3ff7c47d158bb4ef637c69ce349706">PxJointLimitCone</a>
<li>PxJointLimitParameters()
: <a class="el" href="classPxJointLimitParameters.html#b706ebb59cf473d1537741edfab2c387">PxJointLimitParameters</a>
<li>PxJointLinearLimit()
: <a class="el" href="classPxJointLinearLimit.html#d381f82db6aa6022f7e71d99603fb339">PxJointLinearLimit</a>
<li>PxJointLinearLimitPair()
: <a class="el" href="classPxJointLinearLimitPair.html#ebd9d130d0b09c7bc81044a91da6a32d">PxJointLinearLimitPair</a>
<li>PxLightCpuTask()
: <a class="el" href="classphysx_1_1PxLightCpuTask.html#1576f85a8b81170e5fd28dec773c2a45">physx::PxLightCpuTask</a>
<li>PxLocationHit()
: <a class="el" href="structPxLocationHit.html#9dce7a1e378082e86859350601591072">PxLocationHit</a>
<li>PxMassProperties()
: <a class="el" href="classPxMassProperties.html#1cbdb127fcb5b2b3617693e24ccdb49b">PxMassProperties</a>
<li>PxMat33()
: <a class="el" href="classPxMat33.html#92525fe88727f40493acfd0857680fc4">PxMat33</a>
<li>PxMat44()
: <a class="el" href="classPxMat44.html#d514b6d688fc320ffb13e94367fcdf1b">PxMat44</a>
<li>PxMaterial()
: <a class="el" href="classPxMaterial.html#9f402b870b0729455ba8199b46a0fccd">PxMaterial</a>
<li>PxMeshOverlapUtil()
: <a class="el" href="classPxMeshOverlapUtil.html#bd9c8b4408c4a5d4a8edddfd77ae3a32">PxMeshOverlapUtil</a>
<li>PxMeshScale()
: <a class="el" href="classPxMeshScale.html#073dcde32362dd33ba16db1375d32ded">PxMeshScale</a>
<li>PxMidphaseDesc()
: <a class="el" href="classPxMidphaseDesc.html#2884c3beff507638b6bceb78c46c9eee">PxMidphaseDesc</a>
<li>PxObstacle()
: <a class="el" href="classPxObstacle.html#5d833a794c92cf49451ca56cc0a82ba6">PxObstacle</a>
<li>PxObstacleContext()
: <a class="el" href="classPxObstacleContext.html#53b1408cf617fc505dc1bbf19f94f1ff">PxObstacleContext</a>
<li>PxOverlapBufferN()
: <a class="el" href="structPxOverlapBufferN.html#0b62aca23f26fef278dcbac1cb729291">PxOverlapBufferN< N ></a>
<li>PxPadding()
: <a class="el" href="structPxPadding.html#3a6e900438823b303b5818030d2df083">PxPadding< TNumBytes ></a>
<li>PxParticleBase()
: <a class="el" href="classPxParticleBase.html#1688c7c5736ab69e7606d419daccfe39">PxParticleBase</a>
<li>PxParticleCreationData()
: <a class="el" href="group__particles.html#g8946abea4ff273cbecd459cd74e83f79">PxParticleCreationData</a>
<li>PxParticleFluid()
: <a class="el" href="classPxParticleFluid.html#1355760c2e345ab70190308946fbd825">PxParticleFluid</a>
<li>PxParticleSystem()
: <a class="el" href="classPxParticleSystem.html#fd52afc4a8cff4049dc6a7db67c6d75f">PxParticleSystem</a>
<li>PxPhysicsInsertionCallback()
: <a class="el" href="classPxPhysicsInsertionCallback.html#d1424ae705471676424f57e2037f63dd">PxPhysicsInsertionCallback</a>
<li>PxPlane()
: <a class="el" href="classPxPlane.html#a91bd50f689e65d8df16b9bc451adbe4">PxPlane</a>
<li>PxPlaneGeometry()
: <a class="el" href="classPxPlaneGeometry.html#d71ebf9ac3a2f3831fb65dfe91adf505">PxPlaneGeometry</a>
<li>PxPrismaticJoint()
: <a class="el" href="classPxPrismaticJoint.html#fa9275b9e82afed2d12e8bbd20c318ff">PxPrismaticJoint</a>
<li>PxProfileScoped()
: <a class="el" href="classphysx_1_1PxProfileScoped.html#7aa2be3e529c68553421da54ef8ecb2c">physx::PxProfileScoped</a>
<li>PxPruningStructure()
: <a class="el" href="classPxPruningStructure.html#034b569b8e1db318efcb97fa3dc03020">PxPruningStructure</a>
<li>PxQuat()
: <a class="el" href="group__foundation.html#gf4ea3337baa14716f97e5cae7f6047c2">PxQuat</a>
<li>PxQueryCache()
: <a class="el" href="structPxQueryCache.html#810ecb74536e940be1719d60aedfd3cd">PxQueryCache</a>
<li>PxQueryFilterData()
: <a class="el" href="structPxQueryFilterData.html#589e393317001f2effd196324ee459ed">PxQueryFilterData</a>
<li>PxQueryHit()
: <a class="el" href="structPxQueryHit.html#f8b229617f39cc007c74a646f8026dff">PxQueryHit</a>
<li>PxRaycastBufferN()
: <a class="el" href="structPxRaycastBufferN.html#75c64893a9241f9e962c4f144345698f">PxRaycastBufferN< N ></a>
<li>PxRaycastHit()
: <a class="el" href="structPxRaycastHit.html#5e1097c8e1265bf67cd92ea6c39122c0">PxRaycastHit</a>
<li>PxRepXInstantiationArgs()
: <a class="el" href="structPxRepXInstantiationArgs.html#030a16eab5b43df69854f966c0b95f17">PxRepXInstantiationArgs</a>
<li>PxRepXObject()
: <a class="el" href="structPxRepXObject.html#a1cc707ced49e51838f39a1867566893">PxRepXObject</a>
<li>PxRevoluteJoint()
: <a class="el" href="classPxRevoluteJoint.html#738a0a094358001c58c9c3ea070730a2">PxRevoluteJoint</a>
<li>PxRigidActor()
: <a class="el" href="classPxRigidActor.html#bc3690608611b90d1efd033e804fd774">PxRigidActor</a>
<li>PxRigidBody()
: <a class="el" href="classPxRigidBody.html#14d4e7068063768f6029a975ff5d41e4">PxRigidBody</a>
<li>PxRigidDynamic()
: <a class="el" href="classPxRigidDynamic.html#b21ed0e4e1be20fc975fcd3ceeb4e064">PxRigidDynamic</a>
<li>PxRigidStatic()
: <a class="el" href="classPxRigidStatic.html#7881e50c535f44a6d69f40af3baa7ffc">PxRigidStatic</a>
<li>PxScene()
: <a class="el" href="classPxScene.html#37b5f1aed7edbae16640e0555d9271ae">PxScene</a>
<li>PxSceneDesc()
: <a class="el" href="group__physics.html#g8c083fd86a8c52ff269aa4dd3407127b">PxSceneDesc</a>
<li>PxSceneLimits()
: <a class="el" href="group__physics.html#gd36024f1760b55b0947dc0d91e080bd7">PxSceneLimits</a>
<li>PxSceneReadLock()
: <a class="el" href="classPxSceneReadLock.html#ef1281bce24a99ed88fc45e88c702266">PxSceneReadLock</a>
<li>PxSceneWriteLock()
: <a class="el" href="classPxSceneWriteLock.html#79dfa45a702ade06c4ca4af9de6ea160">PxSceneWriteLock</a>
<li>PxSerializationContext()
: <a class="el" href="classPxSerializationContext.html#586e2fdab9eb45ee4f88c5fc3f637936">PxSerializationContext</a>
<li>PxSerializerDefaultAdapter()
: <a class="el" href="classPxSerializerDefaultAdapter.html#3a59a446ea4fc277d0c224881c2f8658">PxSerializerDefaultAdapter< T ></a>
<li>PxShape()
: <a class="el" href="classPxShape.html#74ff05bd6c8ac9db9fcae9be23c08d82">PxShape</a>
<li>PxSimpleTriangleMesh()
: <a class="el" href="group__geomutils.html#g9acd5763a76bcf9f41b42c3a30a6421a">PxSimpleTriangleMesh</a>
<li>PxSimulationStatistics()
: <a class="el" href="classPxSimulationStatistics.html#910e1921a55acda66f5c22ee173eda32">PxSimulationStatistics</a>
<li>PxSphereGeometry()
: <a class="el" href="classPxSphereGeometry.html#f190d00c7a0b5748e8159eba87cdb23a">PxSphereGeometry</a>
<li>PxSphericalJoint()
: <a class="el" href="classPxSphericalJoint.html#b06e4205a73a38b86f803b33596ff2b0">PxSphericalJoint</a>
<li>PxSpring()
: <a class="el" href="classPxSpring.html#2fe1f5d75c8b8e0c7ad9ce417c8fdebc">PxSpring</a>
<li>PxStridedData()
: <a class="el" href="structPxStridedData.html#f327f6129229e98cb13b949b3fa2a26d">PxStridedData</a>
<li>PxStrideIterator()
: <a class="el" href="classPxStrideIterator.html#47b65f7b217b7b58e41c60eba2036c6a">PxStrideIterator< T ></a>
<li>PxSweepBufferN()
: <a class="el" href="structPxSweepBufferN.html#b8be2772b4fe811563efc01824201a61">PxSweepBufferN< N ></a>
<li>PxSweepHit()
: <a class="el" href="structPxSweepHit.html#7a872b4eff912e5e37e1ee8d551547ac">PxSweepHit</a>
<li>PxTask()
: <a class="el" href="classphysx_1_1PxTask.html#01ed1f8968b3e631509c42994b10b5cd">physx::PxTask</a>
<li>PxTolerancesScale()
: <a class="el" href="group__common.html#gf2bc9f0c0e1ee44a548900a13bb1136c">PxTolerancesScale</a>
<li>PxTransform()
: <a class="el" href="classPxTransform.html#b414a3463acc556445fb095ee32e98d8">PxTransform</a>
<li>PxTriangle()
: <a class="el" href="classPxTriangle.html#a85f97202f9b4811cdacc3f126da023b">PxTriangle</a>
<li>PxTriangleMesh()
: <a class="el" href="classPxTriangleMesh.html#b6401ba6b8f477e3c95a79da42f4e3b0">PxTriangleMesh</a>
<li>PxTriangleMeshDesc()
: <a class="el" href="group__cooking.html#g15d3050ac143dfb67ad43a8682c7b569">PxTriangleMeshDesc</a>
<li>PxTriangleMeshGeometry()
: <a class="el" href="classPxTriangleMeshGeometry.html#1a1cef2255e9fc7357a4f9e07c2826b4">PxTriangleMeshGeometry</a>
<li>PxTriggerPair()
: <a class="el" href="structPxTriggerPair.html#adedcfa39f52b9e32b73d9f2096069f1">PxTriggerPair</a>
<li>PxTypedStridedData()
: <a class="el" href="structPxTypedStridedData.html#00c6a63c63d01bdca92b06f60e6909bb">PxTypedStridedData< TDataType ></a>
<li>PxVec2()
: <a class="el" href="classPxVec2.html#4b60f4c08b8019e8c28967ed33d436ce">PxVec2</a>
<li>PxVec3()
: <a class="el" href="classPxVec3.html#672e12542fc6f752d21368493578af4e">PxVec3</a>
<li>PxVec4()
: <a class="el" href="classPxVec4.html#719a2783335631f273eb46c6f4a61925">PxVec4</a>
<li>PxVehicleAckermannGeometryData()
: <a class="el" href="classPxVehicleAckermannGeometryData.html#6d15ee641598033fef887c399f547422">PxVehicleAckermannGeometryData</a>
<li>PxVehicleAntiRollBarData()
: <a class="el" href="classPxVehicleAntiRollBarData.html#e926b0985fe5243a1e671405d19e9dac">PxVehicleAntiRollBarData</a>
<li>PxVehicleAutoBoxData()
: <a class="el" href="classPxVehicleAutoBoxData.html#4f2313daab10500b71271d46ebbd0fc5">PxVehicleAutoBoxData</a>
<li>PxVehicleChassisData()
: <a class="el" href="classPxVehicleChassisData.html#edff02e1e05309618636a393743265f4">PxVehicleChassisData</a>
<li>PxVehicleClutchData()
: <a class="el" href="classPxVehicleClutchData.html#5f50479c769bfc6ae880b92036abce8d">PxVehicleClutchData</a>
<li>PxVehicleConcurrentUpdateData()
: <a class="el" href="structPxVehicleConcurrentUpdateData.html#66a66af954cf0dc1f5fc2eec992de647">PxVehicleConcurrentUpdateData</a>
<li>PxVehicleCopyDynamicsMap()
: <a class="el" href="classPxVehicleCopyDynamicsMap.html#46e1abd50a1efeb2c4d1cd65454b284d">PxVehicleCopyDynamicsMap</a>
<li>PxVehicleDifferential4WData()
: <a class="el" href="classPxVehicleDifferential4WData.html#87b843efc25143193fea2e7112aadc41">PxVehicleDifferential4WData</a>
<li>PxVehicleDifferentialNWData()
: <a class="el" href="classPxVehicleDifferentialNWData.html#a363bb07cd4533cfee8a59bc14d03c10">PxVehicleDifferentialNWData</a>
<li>PxVehicleDrivableSurfaceToTireFrictionPairs()
: <a class="el" href="classPxVehicleDrivableSurfaceToTireFrictionPairs.html#6838139851fe46e93a55cc3fb4f55239">PxVehicleDrivableSurfaceToTireFrictionPairs</a>
<li>PxVehicleDrive()
: <a class="el" href="classPxVehicleDrive.html#fc560f3fed1fb50c39eed8bdb1d12204">PxVehicleDrive</a>
<li>PxVehicleDrive4W()
: <a class="el" href="classPxVehicleDrive4W.html#c829d935d067980fd6cda927dbdb5a0f">PxVehicleDrive4W</a>
<li>PxVehicleDrive4WRawInputData()
: <a class="el" href="classPxVehicleDrive4WRawInputData.html#f897772ee3457a2100945890f3d025ef">PxVehicleDrive4WRawInputData</a>
<li>PxVehicleDriveDynData()
: <a class="el" href="classPxVehicleDriveDynData.html#f38233e891d581d123bcae2724d57dc7">PxVehicleDriveDynData</a>
<li>PxVehicleDriveNW()
: <a class="el" href="classPxVehicleDriveNW.html#f463dfdb64f6135628c5838908bb5395">PxVehicleDriveNW</a>
<li>PxVehicleDriveNWRawInputData()
: <a class="el" href="classPxVehicleDriveNWRawInputData.html#69da40337ef28425e015fc3ba0bde4eb">PxVehicleDriveNWRawInputData</a>
<li>PxVehicleDriveSimData()
: <a class="el" href="classPxVehicleDriveSimData.html#5da8eea1e75acb69885a5d9058a12b4d">PxVehicleDriveSimData</a>
<li>PxVehicleDriveSimData4W()
: <a class="el" href="classPxVehicleDriveSimData4W.html#db99a930a7426f4835c48574ee77e947">PxVehicleDriveSimData4W</a>
<li>PxVehicleDriveSimDataNW()
: <a class="el" href="classPxVehicleDriveSimDataNW.html#e3625d06e1733b2c574f409299507c46">PxVehicleDriveSimDataNW</a>
<li>PxVehicleDriveTank()
: <a class="el" href="classPxVehicleDriveTank.html#1d3db837be4782115495f7e5bfcd0a29">PxVehicleDriveTank</a>
<li>PxVehicleDriveTankRawInputData()
: <a class="el" href="classPxVehicleDriveTankRawInputData.html#99b71417ecdde92487aa06d3c0ecb832">PxVehicleDriveTankRawInputData</a>
<li>PxVehicleEngineData()
: <a class="el" href="classPxVehicleEngineData.html#003aa44611d0be2a466787521db49fb2">PxVehicleEngineData</a>
<li>PxVehicleGearsData()
: <a class="el" href="classPxVehicleGearsData.html#197ff974ac25dfbad8c8f323a74a8a0d">PxVehicleGearsData</a>
<li>PxVehicleNoDrive()
: <a class="el" href="classPxVehicleNoDrive.html#b2efce97fc543b50bed1e8ed6881ba38">PxVehicleNoDrive</a>
<li>PxVehicleSuspensionData()
: <a class="el" href="classPxVehicleSuspensionData.html#8edf19ece4a7b7c32af4aa823e98c434">PxVehicleSuspensionData</a>
<li>PxVehicleTireData()
: <a class="el" href="classPxVehicleTireData.html#4f7cde0fb3943e130fe35a786f649d1d">PxVehicleTireData</a>
<li>PxVehicleTireLoadFilterData()
: <a class="el" href="classPxVehicleTireLoadFilterData.html#b856f54f8e45dc86b9b1a396ccfa05ff">PxVehicleTireLoadFilterData</a>
<li>PxVehicleWheelConcurrentUpdateData()
: <a class="el" href="structPxVehicleWheelConcurrentUpdateData.html#5d00e2311128d7bb90b0568fa2323a68">PxVehicleWheelConcurrentUpdateData</a>
<li>PxVehicleWheelData()
: <a class="el" href="classPxVehicleWheelData.html#0041dd83bf7afcd53489fa1fa9727496">PxVehicleWheelData</a>
<li>PxVehicleWheels()
: <a class="el" href="classPxVehicleWheels.html#0a75ee48309f1052d10acdc9b727ab06">PxVehicleWheels</a>
<li>PxVehicleWheelsDynData()
: <a class="el" href="classPxVehicleWheelsDynData.html#5243d9d4a70183f44b248df5b39b05d3">PxVehicleWheelsDynData</a>
<li>PxVehicleWheelsSimData()
: <a class="el" href="classPxVehicleWheelsSimData.html#9fbfa747a9ef9fe0cc1deef89a5b1238">PxVehicleWheelsSimData</a>
<li>PxWheelQueryResult()
: <a class="el" href="structPxWheelQueryResult.html#161b38c47540b17befebc36c02c8e996">PxWheelQueryResult</a>
<li>PxXmlMiscParameter()
: <a class="el" href="structPxSerialization_1_1PxXmlMiscParameter.html#c6b7fd9141603396399775d536dbe9a8">PxSerialization::PxSerialization::PxXmlMiscParameter</a>
</ul>
</div>
<hr style="width: 100%; height: 2px;"><br>
</body>
</html>
```
|
Paddy O'Brien is the name of:
Sports
Paddy O'Brien (Australian rules footballer) (1893–1964)
Paddy O'Brien (Gaelic footballer) (1925–2016), inter-county Irish Gaelic footballer
Paddy O'Brien (rugby union) (born 1959), New Zealand international rugby union referee
Paddy O'Brien (Tipperary hurler) (born 1979), Irish left corner-forward
Paddy O'Brien (Éire Óg hurler), member of the 1947 Kilkenny Hurling Team
Paddy O'Brien (Laois hurler), played in the 1949 All-Ireland Senior Hurling Championship Final
Paddy O'Brien (fl. 1949), a Tipperary hurler
Other people
Paddy O'Brien (accordionist) (1922–1991), Irish button accordion player and composer
Paddy O'Brien (musician and author) (born 1945), Irish-American accordionist, born County Offaly
Paddy O'Brien (singer) (born 1954), Irish country singer, born County Waterford
Paddy O'Brien, minion of the Austin Powers character Dr. Evil
Paddy (Patrick) O'Brien, multiple officers involved in IRA operations:
see Battle of Dublin
see Clonbanin Ambush
see Kilmichael Ambush
See also
Patrick O'Brien (disambiguation)
|
Tesreau is a surname. Notable people with the surname include:
Elmer Tesreau (1905–1955), American college football player
Jeff Tesreau (1888–1946), American baseball player
Krista Tesreau (born 1964), American actress
See also
Tesro Aayam, a literary movement in Nepal and India
|
Procession at Seville and bullfighting Scenes is a non-fiction short film created by Auguste and Louis Lumière between 1898 and 1899.
The Lumière brothers used a cinematograph to film this motion picture in Seville, Spain.
Plot
Procession at Seville and bullfighting scenes depicts the traditional Spanish Holy Week celebration, portraying Spain in the 19th century. This recording includes a traditional parade and bullfights in Spain, representing how this holiday was celebrated at the time. At the beginning, the short film shows the Procession Parade from the Christ of Sorrows. This celebration occurs during Holy Week in Seville which is celebrated one week before Easter. It includes decorated chariots that are pulled around the city streets by Costaleros. The Penitentes, dressed in tunics and a cape, march together in the procession along with the chariots and other people wearing traditional and formal clothing During the bullfighting celebration, the Banderillero entertains the bull and plays with it, meanwhile a Picador (Lancer) enters the spectacle. The Picador is riding a horse and manages to stab the bull. The short film displays the process of bullfighting and how each participant plays their specific role, as well as the traditional parade.
Production and development
Production
To create the short film, the Lumière Brothers used a cinematograph, a new projection device which was beginning to be used at that time. The brothers sent different equipment all over the world in order to film a variety of scenes and images. Two of the main filming locations were France and Spain. This short non-fiction film marked the first time that someone filmed the Spanish Holy Week.
Distribution and reception
The first 1,000 copies of this film were distributed by Auguste and Louis Lumière. Procession at Seville and bullfighting scenes was found later on a 16mm reel and a videocassette, along with other 46 Lumière films. After this, the Library of Congress as well as the World Digital Library, the latter created by the UNESCO in order to distribute cultural and academic content, distributed the video in a digital format via the Internet.
References
External links
1898 films
1899 films
1890s sports films
Bullfighting films
Films directed by Auguste and Louis Lumière
Films set in Seville
Films shot in Spain
French silent short films
French black-and-white films
French sports films
1898 short films
1899 short films
1890s French films
Silent sports films
|
```xml
/*
*
* See the LICENSE file at the top-level directory of this distribution
* for licensing information.
*
* Unless otherwise agreed in a custom licensing agreement with the Lisk Foundation,
* no part of this software, including this file, may be copied, modified,
* propagated, or distributed except according to the terms contained in the
* LICENSE file.
*
* Removal or modification of this copyright notice is prohibited.
*/
import {
CHAIN_ID_LENGTH,
TOKEN_ID_LENGTH,
MAX_DATA_LENGTH,
MIN_MODULE_NAME_LENGTH,
MAX_MODULE_NAME_LENGTH,
} from './constants';
export const configSchema = {
$id: '/token/config',
type: 'object',
properties: {
userAccountInitializationFee: {
type: 'string',
format: 'uint64',
},
escrowAccountInitializationFee: {
type: 'string',
format: 'uint64',
},
},
};
export interface AvailableLocalIDStoreData {
nextAvailableLocalID: Buffer;
}
export const availableLocalIDStoreSchema = {
$id: '/token/store/availableLocalID',
type: 'object',
required: ['nextAvailableLocalID'],
properties: {
nextAvailableLocalID: {
dataType: 'bytes',
fieldNumber: 1,
},
},
};
export interface TerminatedEscrowStoreData {
escrowTerminated: boolean;
}
export const terminatedEscrowStoreSchema = {
$id: '/token/store/terminatedEscrow',
type: 'object',
required: ['escrowTerminated'],
properties: {
escrowTerminated: {
dataType: 'boolean',
fieldNumber: 1,
},
},
};
/**
* Parameters of the token transfer command
*/
export const transferParamsSchema = {
/** The unique identifier of the schema. */
$id: '/lisk/transferParams',
/** Schema title */
title: 'Transfer transaction params',
type: 'object',
/** The required parameters for the command. */
required: ['tokenID', 'amount', 'recipientAddress', 'data'],
/** A list describing the available parameters for the command. */
properties: {
/**
* ID of the tokens being transferred.
* `minLength` and `maxLength` are {@link TOKEN_ID_LENGTH}.
*/
tokenID: {
dataType: 'bytes',
fieldNumber: 1,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
/** Amount of tokens to be transferred in Beddows. */
amount: {
dataType: 'uint64',
fieldNumber: 2,
},
/** Address of the recipient. */
recipientAddress: {
dataType: 'bytes',
fieldNumber: 3,
format: 'lisk32',
},
/** Optional field for data / messages.
*
* `maxLength` is {@link MAX_DATA_LENGTH}.
* */
data: {
dataType: 'string',
fieldNumber: 4,
minLength: 0,
maxLength: MAX_DATA_LENGTH,
},
},
};
/**
* Parameters of the cross-chain token transfer command
*/
export const crossChainTransferParamsSchema = {
/** The unique identifier of the schema. */
$id: '/lisk/ccTransferParams',
type: 'object',
/** The required parameters for the command. */
required: [
'tokenID',
'amount',
'receivingChainID',
'recipientAddress',
'data',
'messageFee',
'messageFeeTokenID',
],
/** A list describing the available parameters for the command. */
properties: {
/**
* ID of the tokens being transferred.
* `minLength` and `maxLength` are {@link TOKEN_ID_LENGTH}.
*/
tokenID: {
dataType: 'bytes',
fieldNumber: 1,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
/** Amount of tokens to be transferred in Beddows. */
amount: {
dataType: 'uint64',
fieldNumber: 2,
},
/**
* The chain ID of the receiving chain.
*
* `maxLength` and `minLength` are equal to {@link CHAIN_ID_LENGTH}.
*/
receivingChainID: {
dataType: 'bytes',
fieldNumber: 3,
minLength: CHAIN_ID_LENGTH,
maxLength: CHAIN_ID_LENGTH,
},
/** Address of the recipient. */
recipientAddress: {
dataType: 'bytes',
fieldNumber: 4,
format: 'lisk32',
},
/** Optional field for data / messages.
*
* `maxLength` is {@link MAX_DATA_LENGTH}.
*/
data: {
dataType: 'string',
fieldNumber: 5,
minLength: 0,
maxLength: MAX_DATA_LENGTH,
},
messageFee: {
dataType: 'uint64',
fieldNumber: 6,
},
messageFeeTokenID: {
dataType: 'bytes',
fieldNumber: 7,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
},
};
export interface CCTransferMessageParams {
tokenID: Buffer;
amount: bigint;
senderAddress: Buffer;
recipientAddress: Buffer;
data: string;
}
/**
* Parameters of the cross-chain token transfer CCM
*/
export const crossChainTransferMessageParams = {
/** The unique identifier of the schema. */
$id: '/lisk/ccTransferMessageParams',
type: 'object',
/** The required parameters for the command. */
required: ['tokenID', 'amount', 'senderAddress', 'recipientAddress', 'data'],
/** A list describing the available parameters for the CCM. */
properties: {
/**
* ID of the tokens being transferred.
* `minLength` and `maxLength` are {@link TOKEN_ID_LENGTH}.
*/
tokenID: {
dataType: 'bytes',
fieldNumber: 1,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
/** Amount of tokens to be transferred in Beddows. */
amount: {
dataType: 'uint64',
fieldNumber: 2,
},
/** Address of the sender. */
senderAddress: {
dataType: 'bytes',
fieldNumber: 3,
format: 'lisk32',
},
/** Address of the recipient. */
recipientAddress: {
dataType: 'bytes',
fieldNumber: 4,
format: 'lisk32',
},
/** Optional field for data / messages.
*
* `minLength is `0`.
* `maxLength` is {@link MAX_DATA_LENGTH}.
*/
data: {
dataType: 'string',
fieldNumber: 5,
minLength: 0,
maxLength: MAX_DATA_LENGTH,
},
},
};
export interface CCForwardMessageParams {
tokenID: Buffer;
amount: bigint;
senderAddress: Buffer;
forwardToChainID: Buffer;
recipientAddress: Buffer;
data: string;
forwardedMessageFee: bigint;
}
export const crossChainForwardMessageParams = {
$id: '/lisk/ccForwardMessageParams',
type: 'object',
required: [
'tokenID',
'amount',
'senderAddress',
'forwardToChainID',
'recipientAddress',
'data',
'forwardedMessageFee',
],
properties: {
tokenID: {
dataType: 'bytes',
fieldNumber: 1,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
amount: {
dataType: 'uint64',
fieldNumber: 2,
},
senderAddress: {
dataType: 'bytes',
fieldNumber: 3,
format: 'lisk32',
},
forwardToChainID: {
dataType: 'bytes',
fieldNumber: 4,
minLength: CHAIN_ID_LENGTH,
maxLength: CHAIN_ID_LENGTH,
},
recipientAddress: {
dataType: 'bytes',
fieldNumber: 5,
format: 'lisk32',
},
data: {
dataType: 'string',
fieldNumber: 6,
minLength: 0,
maxLength: MAX_DATA_LENGTH,
},
forwardedMessageFee: {
dataType: 'uint64',
fieldNumber: 7,
},
},
};
export const genesisTokenStoreSchema = {
$id: '/token/module/genesis',
type: 'object',
required: ['userSubstore', 'supplySubstore', 'escrowSubstore', 'supportedTokensSubstore'],
properties: {
userSubstore: {
type: 'array',
fieldNumber: 1,
items: {
type: 'object',
required: ['address', 'tokenID', 'availableBalance', 'lockedBalances'],
properties: {
address: {
dataType: 'bytes',
format: 'lisk32',
fieldNumber: 1,
},
tokenID: {
dataType: 'bytes',
fieldNumber: 2,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
availableBalance: {
dataType: 'uint64',
fieldNumber: 3,
},
lockedBalances: {
type: 'array',
fieldNumber: 4,
items: {
type: 'object',
required: ['module', 'amount'],
properties: {
module: {
dataType: 'string',
minLength: MIN_MODULE_NAME_LENGTH,
maxLength: MAX_MODULE_NAME_LENGTH,
fieldNumber: 1,
},
amount: {
dataType: 'uint64',
fieldNumber: 2,
},
},
},
},
},
},
},
supplySubstore: {
type: 'array',
fieldNumber: 2,
items: {
type: 'object',
required: ['tokenID', 'totalSupply'],
properties: {
tokenID: {
dataType: 'bytes',
fieldNumber: 1,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
totalSupply: {
dataType: 'uint64',
fieldNumber: 2,
},
},
},
},
escrowSubstore: {
type: 'array',
fieldNumber: 3,
items: {
type: 'object',
required: ['escrowChainID', 'tokenID', 'amount'],
properties: {
escrowChainID: {
dataType: 'bytes',
minLength: CHAIN_ID_LENGTH,
maxLength: CHAIN_ID_LENGTH,
fieldNumber: 1,
},
tokenID: {
dataType: 'bytes',
fieldNumber: 2,
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
amount: {
dataType: 'uint64',
fieldNumber: 3,
},
},
},
},
supportedTokensSubstore: {
type: 'array',
fieldNumber: 4,
items: {
type: 'object',
required: ['chainID', 'supportedTokenIDs'],
properties: {
chainID: {
dataType: 'bytes',
fieldNumber: 1,
},
supportedTokenIDs: {
type: 'array',
fieldNumber: 2,
items: {
dataType: 'bytes',
minLength: TOKEN_ID_LENGTH,
maxLength: TOKEN_ID_LENGTH,
},
},
},
},
},
},
};
export const getBalanceRequestSchema = {
$id: '/token/endpoint/getBalanceRequest',
type: 'object',
properties: {
address: {
type: 'string',
format: 'lisk32',
},
tokenID: {
type: 'string',
format: 'hex',
minLength: TOKEN_ID_LENGTH * 2,
maxLength: TOKEN_ID_LENGTH * 2,
},
},
required: ['address', 'tokenID'],
};
export const getBalanceResponseSchema = {
$id: '/token/endpoint/getBalanceResponse',
type: 'object',
required: ['availableBalance', 'lockedBalances'],
properties: {
availableBalance: {
type: 'string',
format: 'uint64',
},
lockedBalances: {
type: 'array',
items: {
type: 'object',
required: ['module', 'amount'],
properties: {
module: {
type: 'string',
},
amount: {
type: 'string',
format: 'uint64',
},
},
},
},
},
};
export const getBalancesRequestSchema = {
$id: '/token/endpoint/getBalancesRequest',
type: 'object',
properties: {
address: {
type: 'string',
format: 'lisk32',
},
},
required: ['address'],
};
export const getBalancesResponseSchema = {
$id: '/token/endpoint/getBalancesResponse',
type: 'object',
required: ['balances'],
properties: {
balances: {
type: 'array',
items: {
type: 'object',
required: ['availableBalance', 'lockedBalances', 'tokenID'],
properties: {
tokenID: {
type: 'string',
format: 'hex',
},
availableBalance: {
type: 'string',
format: 'uint64',
},
lockedBalances: {
type: 'array',
items: {
type: 'object',
required: ['module', 'amount'],
properties: {
module: {
type: 'string',
},
amount: {
type: 'string',
format: 'uint64',
},
},
},
},
},
},
},
},
};
export const getTotalSupplyResponseSchema = {
$id: '/token/endpoint/getTotalSupplyResponse',
type: 'object',
properties: {
totalSupply: {
type: 'array',
items: {
type: 'object',
required: ['totalSupply', 'tokenID'],
properties: {
tokenID: {
type: 'string',
format: 'hex',
},
totalSupply: {
type: 'string',
format: 'uint64',
},
},
},
},
},
};
export const getSupportedTokensResponseSchema = {
$id: '/token/endpoint/getSupportedTokensResponse',
type: 'object',
properties: {
tokenIDs: {
type: 'array',
items: {
type: 'string',
format: 'hex',
},
},
},
};
export const getEscrowedAmountsResponseSchema = {
$id: '/token/endpoint/getEscrowedAmountsResponse',
type: 'object',
properties: {
escrowedAmounts: {
type: 'array',
items: {
type: 'object',
required: ['escrowChainID', 'amount', 'tokenID'],
properties: {
escrowChainID: {
type: 'string',
format: 'hex',
},
tokenID: {
type: 'string',
format: 'hex',
},
amount: {
type: 'string',
format: 'uint64',
},
},
},
},
},
};
export const isSupportedRequestSchema = {
$id: '/token/endpoint/isSupportedRequest',
type: 'object',
properties: {
tokenID: {
type: 'string',
format: 'hex',
minLength: TOKEN_ID_LENGTH * 2,
maxLength: TOKEN_ID_LENGTH * 2,
},
},
required: ['tokenID'],
};
export const isSupportedResponseSchema = {
$id: '/token/endpoint/isSupportedResponse',
type: 'object',
properties: {
supported: {
dataType: 'boolean',
},
},
required: ['supported'],
};
export const getInitializationFeesResponseSchema = {
$id: '/token/endpoint/getInitializationFees',
type: 'object',
properties: {
userAccount: {
type: 'string',
format: 'uint64',
},
escrowAccount: {
type: 'string',
format: 'uint64',
},
},
required: ['userAccount', 'escrowAccount'],
};
export const hasUserAccountRequestSchema = {
$id: '/token/endpoint/hasUserAccountRequest',
type: 'object',
properties: {
address: {
type: 'string',
format: 'lisk32',
},
tokenID: {
type: 'string',
format: 'hex',
minLength: TOKEN_ID_LENGTH * 2,
maxLength: TOKEN_ID_LENGTH * 2,
},
},
required: ['address', 'tokenID'],
};
export const hasEscrowAccountRequestSchema = {
$id: '/token/endpoint/hasEscrowAccountRequest',
type: 'object',
properties: {
tokenID: {
type: 'string',
format: 'hex',
minLength: TOKEN_ID_LENGTH * 2,
maxLength: TOKEN_ID_LENGTH * 2,
},
escrowChainID: {
type: 'string',
format: 'hex',
},
},
required: ['tokenID', 'escrowChainID'],
};
export const hasUserAccountResponseSchema = {
$id: '/token/endpoint/hasUserAccountResponse',
type: 'object',
properties: {
exists: {
type: 'boolean',
},
},
};
export const hasEscrowAccountResponseSchema = {
$id: '/token/endpoint/hasEscrowAccountResponse',
type: 'object',
properties: {
exists: {
type: 'boolean',
},
},
};
```
|
The Early Bird is a 1936 British comedy film directed by Donovan Pedelty and starring Richard Hayward, Jimmy Mageean and Charlotte Tedlie.
Production
The film was made at Highbury Studios and in Northern Ireland. It was a quota quickie produced for distribution by the American studio Paramount Pictures. The film's sets were designed by art director George Provis.
Cast
Richard Hayward as Daniel Duff
Jimmy Mageean as Charlie Simpson
Charlotte Tedlie as Mrs. Gordon
Myrtle Adams as Lizzie
Nan Cullen as Mrs. Madill
Elma Hayward as Susan Duff
Terence Grainger as Archie Macready
Charles Fagan as Harold Gordon
References
Bibliography
Chibnall, Steve. Quota Quickies: The British of the British 'B' Film. British Film Institute, 2007.
Low, Rachael. Filmmaking in 1930s Britain. George Allen & Unwin, 1985.
Wood, Linda. British Films, 1927-1939. British Film Institute, 1986.
External links
1936 films
British comedy films
British black-and-white films
1936 comedy films
Films directed by Donovan Pedelty
Films set in Ireland
Films shot at Highbury Studios
1930s English-language films
1930s British films
English-language comedy films
|
```scss
@use '../../styles/colors';
.ScrollAreaRoot {
border-radius: 4px;
overflow: hidden;
--scrollbar-size: 6px;
height: 100%;
}
.ScrollAreaViewport {
width: 100%;
height: 100%;
border-radius: inherit;
& > * {
padding-right: 8px;
}
}
.ScrollAreaScrollbar {
display: flex;
/* ensures no selection */
user-select: none;
/* disable browser handling of all panning and zooming gestures on touch devices */
touch-action: none;
padding: 2px;
background: colors.$background-secondary;
transition: background 160ms ease-out;
}
.ScrollAreaScrollbar:hover {
background: colors.$background-secondary;
}
.ScrollAreaScrollbar[data-orientation='vertical'] {
width: var(--scrollbar-size);
}
.ScrollAreaScrollbar[data-orientation='horizontal'] {
flex-direction: column;
height: var(--scrollbar-size);
}
.ScrollAreaThumb {
flex: 1;
background: colors.$primary-active;
border-radius: var(--scrollbar-size);
position: relative;
}
/* increase target size for touch devices path_to_url */
.ScrollAreaThumb::before {
content: '';
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
width: 100%;
height: 100%;
min-width: 44px;
min-height: 44px;
}
.ScrollAreaCorner {
background: colors.$background-secondary;
}
```
|
```smalltalk
using System;
using System.Runtime.CompilerServices;
using System.Globalization;
using System.Text;
namespace CsPotrace.BezierToBiarc
{
public struct Vector2 : IEquatable<Vector2>, IFormattable
{
/// <summary>Componente X del vettore. </summary>
public float X;
/// <summary>Componente Y del vettore. </summary>
public float Y;
/// <summary>Restituisce un vettore i cui 2 elementi sono uguali a zero. </summary>
/// <returns>Vettore i cui due elementi sono uguali a zero (ovvero, restituisce il vettore (0,0)). </returns>
public static Vector2 Zero
{
get
{
return new Vector2();
}
}
/// <summary>Ottiene un vettore i cui 2 elementi sono uguali a uno. </summary>
/// <returns>Vettore i cui due elementi sono uguali a uno (ovvero, restituisce il vettore (1,1)).</returns>
public static Vector2 One
{
get
{
return new Vector2(1f, 1f);
}
}
/// <summary>Ottiene il vettore (1,0). </summary>
/// <returns>Vettore (1,0). </returns>
public static Vector2 UnitX
{
get
{
return new Vector2(1f, 0.0f);
}
}
/// <summary>Ottiene il vettore (0,1).</summary>
/// <returns>Vettore (0,1).</returns>
public static Vector2 UnitY
{
get
{
return new Vector2(0.0f, 1f);
}
}
/// <summary>Crea un nuovo oggetto <see cref="T:System.Numerics.Vector2" /> i cui due elementi hanno lo stesso valore.</summary>
/// <param name="value">Valore da assegnare a entrambi gli elementi. </param>
public Vector2(float value)
{
this = new Vector2(value, value);
}
/// <summary>Crea un vettore i cui elementi hanno i valori specificati. </summary>
/// <param name="x">Valore da assegnare al campo <see cref="F:System.Numerics.Vector2.X" />. </param>
/// <param name="y">Valore da assegnare al campo <see cref="F:System.Numerics.Vector2.Y" />. </param>
public Vector2(float x, float y)
{
this.X = x;
this.Y = y;
}
/// <summary>Somma due vettori. </summary>
/// <returns>Vettore sommato. </returns>
/// <param name="left">Primo vettore da sommare. </param>
/// <param name="right">Secondo vettore da sommare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator +(Vector2 left, Vector2 right)
{
return new Vector2(left.X + right.X, left.Y + right.Y);
}
/// <summary>Sottrae il secondo vettore dal primo. </summary>
/// <returns>Vettore risultante dalla sottrazione di <paramref name="right" /> da <paramref name="left" />. </returns>
/// <param name="left">Primo vettore. </param>
/// <param name="right">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator -(Vector2 left, Vector2 right)
{
return new Vector2(left.X - right.X, left.Y - right.Y);
}
/// <summary>Moltiplica due vettori. </summary>
/// <returns>Vettore prodotto. </returns>
/// <param name="left">Primo vettore. </param>
/// <param name="right">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator *(Vector2 left, Vector2 right)
{
return new Vector2(left.X * right.X, left.Y * right.Y);
}
/// <summary>Moltiplica il valore scalare per il vettore specificato. </summary>
/// <returns>Vettore scalato. </returns>
/// <param name="left">Vettore. </param>
/// <param name="right">Valore scalare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator *(float left, Vector2 right)
{
return new Vector2(left, left) * right;
}
/// <summary>Moltiplica il vettore specificato per il valore scalare specificato. </summary>
/// <returns>Vettore scalato. </returns>
/// <param name="left">Vettore. </param>
/// <param name="right">Valore scalare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator *(Vector2 left, float right)
{
return left * new Vector2(right, right);
}
/// <summary>Divide il primo vettore per il secondo. </summary>
/// <returns>Vettore risultante dalla divisione di <paramref name="left" /> per <paramref name="right" />. </returns>
/// <param name="left">Primo vettore. </param>
/// <param name="right">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator /(Vector2 left, Vector2 right)
{
return new Vector2(left.X / right.X, left.Y / right.Y);
}
/// <summary>Divide il vettore specificato per un valore scalare specificato.</summary>
/// <returns>Risultato della divisione. </returns>
/// <param name="value1">Vettore. </param>
/// <param name="value2">Valore scalare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator /(Vector2 value1, float value2)
{
float num = 1f / value2;
return new Vector2(value1.X * num, value1.Y * num);
}
/// <summary>Nega il vettore specificato. </summary>
/// <returns>Vettore negato. </returns>
/// <param name="value">Vettore da negare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 operator -(Vector2 value)
{
return Vector2.Zero - value;
}
/// <summary>Restituisce un valore che indica se le coppie di elementi in due vettori specificati sono uguali. </summary>
/// <returns>true se <paramref name="left" /> e <paramref name="right" /> sono uguali; in caso contrario, false.</returns>
/// <param name="left">Primo vettore da confrontare. </param>
/// <param name="right">Secondo vettore da confrontare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(Vector2 left, Vector2 right)
{
return left.Equals(right);
}
/// <summary>Restituisce un valore che indica se due vettori specificati non sono uguali. </summary>
/// <returns>true se <paramref name="left" /> e <paramref name="right" /> non sono uguali; in caso contrario, false. </returns>
/// <param name="left">Primo vettore da confrontare. </param>
/// <param name="right">Secondo vettore da confrontare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(Vector2 left, Vector2 right)
{
return !(left == right);
}
/// <summary>Restituisce il codice hash per l'istanza. </summary>
/// <returns>Codice hash. </returns>
public override int GetHashCode()
{
return this.X.GetHashCode() ^ this.Y.GetHashCode();
}
/// <summary>Restituisce un valore che indica se questa istanza uguale a un oggetto specificato.</summary>
/// <returns>true se l'istanza corrente uguale a <paramref name="obj" />; in caso contrario, false. Se <paramref name="obj" /> null, il metodo restituisce false. </returns>
/// <param name="obj">Oggetto da confrontare con l'istanza corrente. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override bool Equals(object obj)
{
if (!(obj is Vector2))
return false;
return this.Equals((Vector2) obj);
}
/// <summary>Restituisce la rappresentazione di stringa dell'istanza corrente usando la formattazione predefinita. </summary>
/// <returns>Rappresentazione di stringa dell'istanza corrente. </returns>
public override string ToString()
{
return this.ToString("G", (IFormatProvider) CultureInfo.CurrentCulture);
}
/// <summary>Restituisce la rappresentazione di stringa dell'istanza corrente usando la stringa di formato specificata per formattare i singoli elementi. </summary>
/// <returns>Rappresentazione di stringa dell'istanza corrente. </returns>
/// <param name="format">Stringa di formato standard o numerico personalizzato che definisce il formato dei singoli elementi.</param>
public string ToString(string format)
{
return this.ToString(format, (IFormatProvider) CultureInfo.CurrentCulture);
}
/// <summary>Restituisce la rappresentazione di stringa dell'istanza corrente usando la stringa di formato specificata per formattare i singoli elementi e il provider di formato specificato per definire la formattazione specifica delle impostazioni cultura.</summary>
/// <returns>Rappresentazione di stringa dell'istanza corrente. </returns>
/// <param name="format">Stringa di formato standard o numerico personalizzato che definisce il formato dei singoli elementi. </param>
/// <param name="formatProvider">Provider di formato che fornisce informazioni di formattazione specifiche delle impostazioni cultura. </param>
public string ToString(string format, IFormatProvider formatProvider)
{
StringBuilder stringBuilder = new StringBuilder();
string numberGroupSeparator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
stringBuilder.Append('<');
stringBuilder.Append(this.X.ToString(format, formatProvider));
stringBuilder.Append(numberGroupSeparator);
stringBuilder.Append(' ');
stringBuilder.Append(this.Y.ToString(format, formatProvider));
stringBuilder.Append('>');
return stringBuilder.ToString();
}
/// <summary>Restituisce la lunghezza del vettore. </summary>
/// <returns>Lunghezza del vettore. </returns>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float Length()
{
return (float) Math.Sqrt((double) this.X * (double) this.X + (double) this.Y * (double) this.Y);
}
/// <summary>Restituisce la lunghezza del vettore al quadrato. </summary>
/// <returns>Lunghezza al quadrato del vettore. </returns>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float LengthSquared()
{
return (float) ((double) this.X * (double) this.X + (double) this.Y * (double) this.Y);
}
/// <summary>Calcola la distanza euclidea tra due punti specificati. </summary>
/// <returns>Distanza. </returns>
/// <param name="value1">Primo punto. </param>
/// <param name="value2">Secondo punto. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float Distance(Vector2 value1, Vector2 value2)
{
float num1 = value1.X - value2.X;
float num2 = value1.Y - value2.Y;
return (float) Math.Sqrt((double) num1 * (double) num1 + (double) num2 * (double) num2);
}
/// <summary>Restituisce la distanza euclidea quadratica tra due punti specificati. </summary>
/// <returns>Distanza quadratica. </returns>
/// <param name="value1">Primo punto. </param>
/// <param name="value2">Secondo punto. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float DistanceSquared(Vector2 value1, Vector2 value2)
{
float num1 = value1.X - value2.X;
float num2 = value1.Y - value2.Y;
return (float) ((double) num1 * (double) num1 + (double) num2 * (double) num2);
}
/// <summary>Restituisce un vettore con la stessa direzione del vettore specificato, ma con una lunghezza di uno. </summary>
/// <returns>Vettore normalizzato. </returns>
/// <param name="value">Vettore da normalizzare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Normalize(Vector2 value)
{
float num1 = 1f / (float) Math.Sqrt((double) value.X * (double) value.X + (double) value.Y * (double) value.Y);
return new Vector2(value.X * num1, value.Y * num1);
}
/// <summary>Restituisce la reflection di un vettore da una superficie con la normale specificata. </summary>
/// <returns>Vettore riflesso. </returns>
/// <param name="vector">Vettore di origine. </param>
/// <param name="normal">Normale della superficie riflessa. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Reflect(Vector2 vector, Vector2 normal)
{
float num1 = (float) ((double) vector.X * (double) normal.X + (double) vector.Y * (double) normal.Y);
return new Vector2(vector.X - 2f * num1 * normal.X, vector.Y - 2f * num1 * normal.Y);
}
/// <summary>Limita un vettore tra un valore minimo e un valore massimo. </summary>
/// <returns>Vettore limitato. </returns>
/// <param name="value1">Vettore da limitare. </param>
/// <param name="min">Valore minimo. </param>
/// <param name="max">Valore massimo. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max)
{
float x1 = value1.X;
float num1 = (double) x1 > (double) max.X ? max.X : x1;
float x2 = (double) num1 < (double) min.X ? min.X : num1;
float y1 = value1.Y;
float num2 = (double) y1 > (double) max.Y ? max.Y : y1;
float y2 = (double) num2 < (double) min.Y ? min.Y : num2;
return new Vector2(x2, y2);
}
/// <summary>Esegue un'interpolazione lineare tra due vettori in base al peso specificato. </summary>
/// <returns>Vettore interpolato. </returns>
/// <param name="value1">Primo vettore. </param>
/// <param name="value2">Secondo vettore. </param>
/// <param name="amount">Valore compreso tra 0 e 1 che indica il peso di <paramref name="value2" />. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount)
{
return new Vector2(value1.X + (value2.X - value1.X) * amount, value1.Y + (value2.Y - value1.Y) * amount);
}
// /// <summary>Trasforma un vettore in base a una matrice 3x2 specificata. </summary>
// /// <returns>Vettore trasformato. </returns>
// /// <param name="position">Vettore da trasformare. </param>
// /// <param name="matrix">Matrice di trasformazione. </param>
//
// //[MethodImpl(MethodImplOptions.AggressiveInlining)]
// public static Vector2 Transform(Vector2 position, Matrix3x2 matrix)
// {
// return new Vector2((float) ((double) position.X * (double) matrix.M11 + (double) position.Y * (double) matrix.M21) + matrix.M31, (float) ((double) position.X * (double) matrix.M12 + (double) position.Y * (double) matrix.M22) + matrix.M32);
// }
// /// <summary>Trasforma un vettore in base a una matrice 4x4 specificata. </summary>
// /// <returns>Vettore trasformato. </returns>
// /// <param name="position">Vettore da trasformare. </param>
// /// <param name="matrix">Matrice di trasformazione. </param>
//
// //[MethodImpl(MethodImplOptions.AggressiveInlining)]
// public static Vector2 Transform(Vector2 position, Matrix4x4 matrix)
// {
// return new Vector2((float) ((double) position.X * (double) matrix.M11 + (double) position.Y * (double) matrix.M21) + matrix.M41, (float) ((double) position.X * (double) matrix.M12 + (double) position.Y * (double) matrix.M22) + matrix.M42);
// }
// /// <summary>Trasforma la normale di un vettore in base alla matrice 3x2 specificata. </summary>
// /// <returns>Vettore trasformato. </returns>
// /// <param name="normal">Vettore di origine. </param>
// /// <param name="matrix">Matrice. </param>
//
// //[MethodImpl(MethodImplOptions.AggressiveInlining)]
// public static Vector2 TransformNormal(Vector2 normal, Matrix3x2 matrix)
// {
// return new Vector2((float) ((double) normal.X * (double) matrix.M11 + (double) normal.Y * (double) matrix.M21), (float) ((double) normal.X * (double) matrix.M12 + (double) normal.Y * (double) matrix.M22));
// }
// /// <summary>Trasforma la normale di un vettore in base alla matrice 4x4 specificata. </summary>
// /// <returns>Vettore trasformato. </returns>
// /// <param name="normal">Vettore di origine. </param>
// /// <param name="matrix">Matrice. </param>
//
// //[MethodImpl(MethodImplOptions.AggressiveInlining)]
// public static Vector2 TransformNormal(Vector2 normal, Matrix4x4 matrix)
// {
// return new Vector2((float) ((double) normal.X * (double) matrix.M11 + (double) normal.Y * (double) matrix.M21), (float) ((double) normal.X * (double) matrix.M12 + (double) normal.Y * (double) matrix.M22));
// }
/// <summary>Trasforma un vettore in base al valore di rotazione Quaternion specificato. </summary>
/// <returns>Vettore trasformato. </returns>
/// <param name="value">Vettore da ruotare. </param>
/// <param name="rotation">Rotazione da applicare. </param>
// //[MethodImpl(MethodImplOptions.AggressiveInlining)]
// public static Vector2 Transform(Vector2 value, Quaternion rotation)
// {
// float num1 = rotation.X + rotation.X;
// float num2 = rotation.Y + rotation.Y;
// float num3 = rotation.Z + rotation.Z;
// float num4 = rotation.W * num3;
// float num5 = rotation.X * num1;
// float num6 = rotation.X * num2;
// float num7 = rotation.Y * num2;
// float num8 = rotation.Z * num3;
// return new Vector2((float) ((double) value.X * (1.0 - (double) num7 - (double) num8) + (double) value.Y * ((double) num6 - (double) num4)), (float) ((double) value.X * ((double) num6 + (double) num4) + (double) value.Y * (1.0 - (double) num5 - (double) num8)));
// }
/// <summary>Somma due vettori. </summary>
/// <returns>Vettore sommato. </returns>
/// <param name="left">Primo vettore da sommare. </param>
/// <param name="right">Secondo vettore da sommare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Add(Vector2 left, Vector2 right)
{
return left + right;
}
/// <summary>Sottrae il secondo vettore dal primo. </summary>
/// <returns>Vettore differenza. </returns>
/// <param name="left">Primo vettore. </param>
/// <param name="right">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Subtract(Vector2 left, Vector2 right)
{
return left - right;
}
/// <summary>Moltiplica due vettori. </summary>
/// <returns>Vettore prodotto. </returns>
/// <param name="left">Primo vettore. </param>
/// <param name="right">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Multiply(Vector2 left, Vector2 right)
{
return left * right;
}
/// <summary>Moltiplica un vettore per un valore scalare specificato. </summary>
/// <returns>Vettore scalato. </returns>
/// <param name="left">Vettore da moltiplicare. </param>
/// <param name="right">Valore scalare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Multiply(Vector2 left, float right)
{
return left * right;
}
/// <summary>Moltiplica un valore scalare per un vettore specificato.</summary>
/// <returns>Vettore scalato. </returns>
/// <param name="left">Valore scalato. </param>
/// <param name="right">Vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Multiply(float left, Vector2 right)
{
return left * right;
}
/// <summary>Divide il primo vettore per il secondo. </summary>
/// <returns>Vettore risultante dalla divisione. </returns>
/// <param name="left">Primo vettore. </param>
/// <param name="right">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Divide(Vector2 left, Vector2 right)
{
return left / right;
}
/// <summary>Divide il vettore specificato per un valore scalare specificato. </summary>
/// <returns>Vettore risultante dalla divisione. </returns>
/// <param name="left">Vettore. </param>
/// <param name="divisor">Valore scalare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Divide(Vector2 left, float divisor)
{
return left / divisor;
}
/// <summary>Nega un vettore specificato. </summary>
/// <returns>Vettore negato. </returns>
/// <param name="value">Vettore da negare. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Negate(Vector2 value)
{
return -value;
}
/// <summary>Copia gli elementi del vettore nella matrice specificata. </summary>
/// <param name="array">Matrice di destinazione. </param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="array" /> null. </exception>
/// <exception cref="T:System.ArgumentException">Il numero di elementi nell'istanza corrente maggiore della matrice. </exception>
/// <exception cref="T:System.RankException">
/// <paramref name="array" /> multidimensionale.</exception>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void CopyTo(float[] array)
{
this.CopyTo(array, 0);
}
/// <summary>Copia gli elementi del vettore nella matrice specificata, partendo dalla posizione dell'indice specificata.</summary>
/// <param name="array">Matrice di destinazione.</param>
/// <param name="index">Indice in cui copiare il primo elemento del vettore. </param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="array" /> null. </exception>
/// <exception cref="T:System.ArgumentException">Il numero di elementi nell'istanza corrente maggiore della matrice. </exception>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="index" /> minore di zero.-oppure-<paramref name="index" /> maggiore o uguale alla lunghezza della matrice. </exception>
/// <exception cref="T:System.RankException">
/// <paramref name="array" /> multidimensionale.</exception>
public void CopyTo(float[] array, int index)
{
if (array == null)
throw new NullReferenceException("Arg_NullArgumentNullRef");
if (index < 0 || index >= array.Length)
throw new ArgumentOutOfRangeException("Arg_ArgumentOutOfRangeException");
if (array.Length - index < 2)
throw new ArgumentException("Arg_ElementsInSourceIsGreaterThanDestination");
array[index] = this.X;
array[index + 1] = this.Y;
}
/// <summary>Restituisce un valore che indica se questa istanza uguale a un altro vettore. </summary>
/// <returns>true se i due vettori sono uguali; in caso contrario, false. </returns>
/// <param name="other">L'altro vettore. </param>
public bool Equals(Vector2 other)
{
if ((double) this.X == (double) other.X)
return (double) this.Y == (double) other.Y;
return false;
}
/// <summary>Restituisce il prodotto scalare di due vettori. </summary>
/// <returns>Prodotto scalare. </returns>
/// <param name="value1">Primo vettore. </param>
/// <param name="value2">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float Dot(Vector2 value1, Vector2 value2)
{
return (float) ((double) value1.X * (double) value2.X + (double) value1.Y * (double) value2.Y);
}
/// <summary>Restituisce un vettore che contiene il valore pi basso da ognuna delle coppie di elementi nei due vettori specificati.</summary>
/// <returns>Vettore minimizzato. </returns>
/// <param name="value1">Primo vettore. </param>
/// <param name="value2">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Min(Vector2 value1, Vector2 value2)
{
return new Vector2((double) value1.X < (double) value2.X ? value1.X : value2.X, (double) value1.Y < (double) value2.Y ? value1.Y : value2.Y);
}
/// <summary>Restituisce un vettore che contiene il valore pi alto da ognuna delle coppie di elementi nei due vettori specificati.</summary>
/// <returns>Vettore massimizzato. </returns>
/// <param name="value1">Primo vettore. </param>
/// <param name="value2">Secondo vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Max(Vector2 value1, Vector2 value2)
{
return new Vector2((double) value1.X > (double) value2.X ? value1.X : value2.X, (double) value1.Y > (double) value2.Y ? value1.Y : value2.Y);
}
/// <summary>Restituisce un vettore i cui elementi sono i valori assoluti di ognuno degli elementi del vettore specificato. </summary>
/// <returns>Valore assoluto del vettore. </returns>
/// <param name="value">Vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 Abs(Vector2 value)
{
return new Vector2(Math.Abs(value.X), Math.Abs(value.Y));
}
/// <summary>Restituisce un vettore i cui elementi sono la radice quadrata di ognuno degli elementi del vettore specificato.</summary>
/// <returns>Vettore radice quadrata. </returns>
/// <param name="value">Vettore. </param>
//[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Vector2 SquareRoot(Vector2 value)
{
return new Vector2((float) Math.Sqrt((double) value.X), (float) Math.Sqrt((double) value.Y));
}
}
}
```
|
Riya is an feminine given name. Notable people with the name include:
Riya, Japanese singer
Riya Bamniyal, Indian actress
Riya Deepsi, Indian actress and model
Riya Sen (born 1981), Indian actress
Riya Suman, Indian actress
Riya Vishwanathan, Indian actress
Feminine given names
|
```xml
<!--
***********************************************************************************************
Sdk.targets
WARNING: DO NOT MODIFY this file unless you are knowledgeable about MSBuild and have
created a backup copy. Incorrect changes to this file will make it
impossible to load or build your projects from the command-line or the IDE.
***********************************************************************************************
-->
<Project ToolsVersion="14.0" xmlns="path_to_url">
<Import Sdk="Microsoft.NET.Sdk" Project="Sdk.targets" />
<Import Project="$(MSBuildThisFileDirectory)..\targets\Microsoft.NET.Sdk.Worker.targets"
Condition="Exists('$(MSBuildThisFileDirectory)..\targets\Microsoft.NET.Sdk.Worker.targets')" />
</Project>
```
|
```c
#include "sodium_crypto_generichash.h"
#include "sodium_randombytes.h"
size_t
crypto_generichash_bytes_min(void)
{
return crypto_generichash_BYTES_MIN;
}
size_t
crypto_generichash_bytes_max(void)
{
return crypto_generichash_BYTES_MAX;
}
size_t
crypto_generichash_bytes(void)
{
return crypto_generichash_BYTES;
}
size_t
crypto_generichash_keybytes_min(void)
{
return crypto_generichash_KEYBYTES_MIN;
}
size_t
crypto_generichash_keybytes_max(void)
{
return crypto_generichash_KEYBYTES_MAX;
}
size_t
crypto_generichash_keybytes(void)
{
return crypto_generichash_KEYBYTES;
}
const char *
crypto_generichash_primitive(void)
{
return crypto_generichash_PRIMITIVE;
}
size_t
crypto_generichash_statebytes(void)
{
return (sizeof(crypto_generichash_state) + (size_t) 63U) & ~(size_t) 63U;
}
int
crypto_generichash(unsigned char *out, size_t outlen, const unsigned char *in,
unsigned long long inlen, const unsigned char *key,
size_t keylen)
{
return crypto_generichash_blake2b(out, outlen, in, inlen, key, keylen);
}
int
crypto_generichash_init(crypto_generichash_state *state,
const unsigned char *key,
const size_t keylen, const size_t outlen)
{
return crypto_generichash_blake2b_init
((crypto_generichash_blake2b_state *) state, key, keylen, outlen);
}
int
crypto_generichash_update(crypto_generichash_state *state,
const unsigned char *in,
unsigned long long inlen)
{
return crypto_generichash_blake2b_update
((crypto_generichash_blake2b_state *) state, in, inlen);
}
int
crypto_generichash_final(crypto_generichash_state *state,
unsigned char *out, const size_t outlen)
{
return crypto_generichash_blake2b_final
((crypto_generichash_blake2b_state *) state, out, outlen);
}
void
crypto_generichash_keygen(unsigned char k[crypto_generichash_KEYBYTES])
{
randombytes_buf(k, crypto_generichash_KEYBYTES);
}
```
|
```python
import pytest
from zeep import AsyncClient
@pytest.mark.requests
@pytest.mark.asyncio
async def test_context_manager():
async with AsyncClient("tests/wsdl_files/soap.wsdl") as async_client:
assert async_client
```
|
Anna Maria von Baden-Durlach (May 29, 1617 – October 17, 1672) was a German poet and painter. She was a daughter of Margrave Georg Friedrich von Baden.
Life
Anna Maria von Baden-Durlach was a daughter of Margrave Georg Friedrich von Baden from his second marriage to Agathe of Erbach. After the early death of her mother (1621) she grew up under the care of her "faithful Starschedelin" in the Margrave's Dragon Castle on the Ill in Strasbourg. Like her younger sister Elisabeth, she received a thorough education, although at the time the Thirty Years War was worsening. She had a poetic and artistic talent, and quite early she began to write and paint.
According to Karl Obser (1935), her poetry was influenced by the Strasbourg "Sincere Society of the Firs". She wrote poems and sayings. "They are free of baroque tears and express their instructive wisdom and their simple-religious meaning in a pleasing way. The poetic element is small, but the God-given view of life finds and gives consolation". "Some examples of headings may illustrate their moral purpose and life experience: Anger is an evil of all evils . A faithful friend is a great treasure , praise of humility , thought from eternity ,Beauty passes, virtue persists."
Anna Maria of Baden-Durlach also wrote a longer poem about the Swedish king Gustavus Adolphus (1647), a lovely bukolika on "the Lord's President Selmmitzen Feldgut zu Berghausen". She also translated poems from Italian and French, occasional poems wrote to name days. Her literary work was not published during her lifetime.
Among her works there are red chalk, Indian ink and pen drawings, portraits and tracings on the Dutch model, animal and flower displays. Her work was usually given to family members or friends.
Anna Maria von Baden-Durlach was closely associated with her younger sister Elisabeth, who was also artistically active, but less gifted. They worked together on many things. Anna Maria maintained contacts to numerous artists. In the field of paper cutting she made remarkable. After she had spent the youth in Strasbourg, later lived alternately in the Margravial courts in Basel and Strasbourg. She remained unmarried. Although she died in Basel, she was buried in Pforzheim on November 1, 1672.
References
Citations
Bibliography
Karl Obser: "Oberrheinische Miniaturbildnisse. Friedrich Brentels und seiner Schule." In: Zeitschrift für die Geschichte des Oberrheins, Karlsruhe: Braun 1935, S. 1–25
Hans Rott: Kunst und Künstler am Baden-Durlacher Hofe bis zur Gründung Karlsruhes, Karlsruhe: Müller 1917
Wilhelm Engelbert Oestering: "Geschichte der Literatur in Baden. Ein Abriß, I. Teil, Vom Kloster bis zur Klassik." In „Heimatblätter Vom Bodensee zum Main“, 36, Karlsruhe: Müller 1930, S. 3–102
Karl Zell: Fürstentöchter des Hauses Baden. Eine geschichtliche Darstellung zur Feier der Vermählung … der Prinzessin Alexandrine von Baden mit … dem Erbprinzen Ernst von Sachsen-Koburg-Gotha, Karlsruhe: Braun 1842
Johann Christian Keck: Angst und Trost der Christen, Bey der Durchlauchtigsten Fürstin, Prinzessin Annae, Marggräffin… zu Baden und Hochberg, … zu Pforzheim den 1. November 1672 vollbrachter Bestattung. Durlach 1672 Digitalisat bei der Badischen Landesbibliothek
17th-century German painters
German women painters
17th-century German poets
German women poets
German nobility
1617 births
1672 deaths
Artists from Strasbourg
Writers from Strasbourg
Daughters of monarchs
|
Celaenorrhinus leona, commonly known as the Sierra Leone sprite, is a species of butterfly in the family Hesperiidae. It is found in Guinea, Sierra Leone, the Ivory Coast and Ghana. The habitat consists of forests.
References
Butterflies described in 1975
leona
|
Keith Marcel Veney (born December 12, 1974) is an American former basketball player who was notable for his standout career for Marshall University and is currently an assistant coach for the Dallas Mavericks of the National Basketball Association (NBA). He is tied with two other players for the National Collegiate Athletic Association (NCAA) Division I record for the most three-point field goals made in a single game, with 15, and is the only one of the three to have done so against a Division I opponent.
High school career
Veney, a native of Seabrook, Maryland, played high school basketball at Bishop McNamara High School in Forestville where he led the area in scoring at over 30 points per game as a senior.
College career
He then went on to play his first two years of college basketball at Lamar University before transferring to Marshall for the remaining two years. On March 20, 2018, Bishop McNamara announced that Veney would return to the school as the new boys’ varsity basketball head coach.
During his cumulative four-year NCAA career, Veney scored 409 three-pointers, which is currently in the top 25 all-time in Division I history. At the time of his graduation, he was number one. Veney scored 51 points while making a still-standing NCAA record 15 three-pointers against Morehead State on December 14, 1996.
Professional career
After college, Veney went on to play five years of professional basketball in France, Israel, Iceland, Poland and the Dominican Republic.
In January 2000, Veney signed with Úrvalsdeild karla powerhouse Njarðvík. On January 15, he participated in the Icelandic All-Star game where he was named the game's MVP after making 12 three point shoots on his way to 43 points. In middle of February, Veney was released by Njarðvík after averaging 10.6 points and 4.1 assists in 7 games.
After his playing career ended, he returned to the United States as a Nike NBA player representative before eventually starting his own company, Veney Management Group. Today, he also runs basketball clinics and camps for younger players all over the country.
See also
List of NCAA Division I men's basketball players with 12 or more 3-point field goals in a game
List of NCAA Division I men's basketball career 3-point scoring leaders
References
External links
Úrvalsdeild karla statistics at kki.is
Profile at eurobasket.com
Profile at Israeli Basketball Premier League Official site
1974 births
Living people
American expatriate basketball people in the Dominican Republic
American expatriate basketball people in France
American expatriate basketball people in Israel
American expatriate basketball people in Iceland
American expatriate basketball people in Poland
Israeli Basketball Premier League players
Hapoel Tel Aviv B.C. players
Élan Béarnais players
American men's basketball players
High school basketball coaches in the United States
Lamar Cardinals basketball players
Marshall Thundering Herd men's basketball players
Njarðvík men's basketball players
People from Forestville, Maryland
Basketball players from Prince George's County, Maryland
Shooting guards
Úrvalsdeild karla (basketball) players
|
```c++
/*your_sha256_hash--------
Junction: Concurrent data structures in C++
Original location: path_to_url
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the LICENSE file for more information.
your_sha256_hash--------*/
#include <junction/Core.h>
#include <turf/Heap.h>
#include <junction/extra/MapAdapter.h>
#include <iostream>
using namespace turf::intTypes;
int main() {
junction::extra::MapAdapter adapter(1);
junction::extra::MapAdapter::ThreadContext context(adapter, 0);
junction::extra::MapAdapter::Map map(65536);
context.registerThread();
ureg population = 0;
for (ureg i = 0; i < 100; i++) {
#if TURF_USE_DLMALLOC && TURF_DLMALLOC_FAST_STATS
std::cout << "Population=" << population << ", inUse=" << TURF_HEAP.getInUseBytes() << std::endl;
#endif
for (; population < i * 5000; population++)
map.assign(population + 1, (void*) ((population << 2) | 3));
}
context.update();
context.unregisterThread();
return 0;
}
```
|
```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 resolve = require( 'path' ).resolve;
var tape = require( 'tape' );
var PINF = require( '@stdlib/constants/float64/pinf' );
var NINF = require( '@stdlib/constants/float64/ninf' );
var isnan = require( '@stdlib/math/base/assert/is-nan' );
var tryRequire = require( '@stdlib/utils/try-require' );
// VARIABLES //
var deg2rad = tryRequire( resolve( __dirname, './../lib/native.js' ) );
var opts = {
'skip': ( deg2rad instanceof Error )
};
// FIXTURES //
var data = require( './fixtures/julia/data.json' );
// TESTS //
tape( 'main export is a function', opts, function test( t ) {
t.ok( true, __filename );
t.strictEqual( typeof deg2rad, 'function', 'main export is a function' );
t.end();
});
tape( 'if provided `+infinity`, the function returns `+infinity`', opts, function test( t ) {
var r = deg2rad( PINF );
t.equal( r, PINF, 'returns +infinity' );
t.end();
});
tape( 'if provided `-infinity`, the function returns `-infinity`', opts, function test( t ) {
var r = deg2rad( NINF );
t.equal( r, NINF, 'returns -infinity' );
t.end();
});
tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
var r = deg2rad( NaN );
t.equal( isnan( r ), true, 'returns NaN' );
t.end();
});
tape( 'the function converts an angle from degrees to radians', opts, function test( t ) {
var expected;
var x;
var r;
var i;
x = data.x;
expected = data.expected;
for ( i = 0; i < x.length; i++ ) {
r = deg2rad( x[i] );
t.equal( r, expected[i], 'returns '+expected[i]+' when provided '+x[i] );
}
t.end();
});
tape( 'if provided a value less than `~5e-324*180/pi`, the function will underflow', opts, function test( t ) {
var r = deg2rad( 1.0e-322 );
t.equal( r, 0.0, 'returns 0' );
t.end();
});
```
|
Hapoel Ironi Gedera Football Club () is an Israeli football club based in Gedera. The club plays in Liga Bet, the fourth tier of the Israeli football league system.
History
The original club was established in 1958 and spent most of its years in the lower tiers of the Israeli football league system, rising, at its best, to Liga Bet, then the third tier, for two seasons in 1959–60 and 1960–61, and for another season, in 1975–76. The original club folded in 1998.
Re-establishment
The club was re-established in 2011 and was placed in the Central division, in which it played since, its best position was 5th, achieved in 2014–15.
Honours
Liga Gimel
1958–59
1974–75
External links
Hapoel Ironi Gedera Israel Football Association
References
Gedera
Gedera
Association football clubs established in 1958
Association football clubs established in 2011
Association football clubs disestablished in 1998
1958 establishments in Israel
2011 establishments in Israel
1998 disestablishments in Israel
|
```java
/**
*
* 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
*/
package org.thoughtcrime.securesms.scribbles;
import android.content.Intent;
import android.os.Bundle;
import androidx.annotation.Nullable;
import com.google.android.material.tabs.TabLayout;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentStatePagerAdapter;
import androidx.viewpager.widget.ViewPager;
import android.view.MenuItem;
import org.thoughtcrime.securesms.R;
public class StickerSelectActivity extends FragmentActivity implements StickerSelectFragment.StickerSelectionListener {
private static final String TAG = StickerSelectActivity.class.getSimpleName();
public static final String EXTRA_STICKER_FILE = "extra_sticker_file";
private static final int[] TAB_TITLES = new int[] {
R.drawable.ic_tag_faces_white_24dp,
R.drawable.ic_work_white_24dp,
R.drawable.ic_pets_white_24dp,
R.drawable.ic_local_dining_white_24dp,
R.drawable.ic_wb_sunny_white_24dp
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.scribble_select_sticker_activity);
ViewPager viewPager = findViewById(R.id.camera_sticker_pager);
viewPager.setAdapter(new StickerPagerAdapter(getSupportFragmentManager(), this));
TabLayout tabLayout = findViewById(R.id.camera_sticker_tabs);
tabLayout.setupWithViewPager(viewPager);
for (int i=0;i<tabLayout.getTabCount();i++) {
tabLayout.getTabAt(i).setIcon(TAB_TITLES[i]);
}
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId() == android.R.id.home) {
onBackPressed();
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public void onStickerSelected(String name) {
Intent intent = new Intent();
intent.putExtra(EXTRA_STICKER_FILE, name);
setResult(RESULT_OK, intent);
finish();
}
static class StickerPagerAdapter extends FragmentStatePagerAdapter {
private final Fragment[] fragments;
StickerPagerAdapter(FragmentManager fm, StickerSelectFragment.StickerSelectionListener listener) {
super(fm);
this.fragments = new Fragment[] {
StickerSelectFragment.newInstance("stickers/emoticons"),
StickerSelectFragment.newInstance("stickers/clothes"),
StickerSelectFragment.newInstance("stickers/animals"),
StickerSelectFragment.newInstance("stickers/food"),
StickerSelectFragment.newInstance("stickers/weather"),
};
for (Fragment fragment : fragments) {
((StickerSelectFragment)fragment).setListener(listener);
}
}
@Override
public Fragment getItem(int position) {
return fragments[position];
}
@Override
public int getCount() {
return fragments.length;
}
}
}
```
|
```dart
import 'dart:async';
import 'dart:mirrors';
import 'package:angel_framework/angel_framework.dart';
import 'plural.dart' as pluralize;
import 'no_service.dart';
/// Represents a relationship in which the current [service] "belongs to"
/// multiple members of the service at [servicePath]. Use [as] to set the name
/// on the target object.
///
/// Defaults:
/// * [foreignKey]: `userId`
/// * [localKey]: `id`
HookedServiceEventListener belongsToMany(Pattern servicePath,
{String as,
String foreignKey,
String localKey,
getForeignKey(obj),
assignForeignObject(List foreign, obj)}) {
String localId = localKey;
var foreignName =
as?.isNotEmpty == true ? as : pluralize.plural(servicePath.toString());
if (localId == null) {
localId = foreignName + 'Id';
// print('No local key provided for belongsToMany, defaulting to \'$localId\'.');
}
return (HookedServiceEvent e) async {
var ref = e.service.app.service(servicePath);
if (ref == null) throw noService(servicePath);
_getForeignKey(obj) {
if (getForeignKey != null)
return getForeignKey(obj);
else if (obj is Map)
return obj[localId];
else if (obj is Extensible)
return obj.properties[localId];
else if (localId == null || localId == 'userId')
return obj.userId;
else
return reflect(obj).getField(new Symbol(localId)).reflectee;
}
_assignForeignObject(foreign, obj) {
if (assignForeignObject != null)
return assignForeignObject(foreign, obj);
else if (obj is Map)
obj[foreignName] = foreign;
else if (obj is Extensible)
obj.properties[foreignName] = foreign;
else
reflect(obj).setField(new Symbol(foreignName), foreign);
}
_normalize(obj) async {
if (obj != null) {
var id = await _getForeignKey(obj);
var indexed = await ref.index({
'query': {foreignKey ?? 'id': id}
});
if (indexed == null || indexed is! List || indexed.isNotEmpty != true) {
await _assignForeignObject(null, obj);
} else {
var child = indexed is Iterable ? indexed.toList() : [indexed];
await _assignForeignObject(child, obj);
}
}
}
if (e.result is Iterable) {
await Future.wait(e.result.map(_normalize));
} else
await _normalize(e.result);
};
}
```
|
```xml
/*
* @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.
*/
// TypeScript Version: 4.1
/* eslint-disable max-lines */
import cdf = require( '@stdlib/stats/base/dists/negative-binomial/cdf' );
import NegativeBinomial = require( '@stdlib/stats/base/dists/negative-binomial/ctor' );
import kurtosis = require( '@stdlib/stats/base/dists/negative-binomial/kurtosis' );
import logpmf = require( '@stdlib/stats/base/dists/negative-binomial/logpmf' );
import mean = require( '@stdlib/stats/base/dists/negative-binomial/mean' );
import mgf = require( '@stdlib/stats/base/dists/negative-binomial/mgf' );
import mode = require( '@stdlib/stats/base/dists/negative-binomial/mode' );
import pmf = require( '@stdlib/stats/base/dists/negative-binomial/pmf' );
import quantile = require( '@stdlib/stats/base/dists/negative-binomial/quantile' );
import skewness = require( '@stdlib/stats/base/dists/negative-binomial/skewness' );
import stdev = require( '@stdlib/stats/base/dists/negative-binomial/stdev' );
import variance = require( '@stdlib/stats/base/dists/negative-binomial/variance' );
/**
* Interface describing the `negative-binomial` namespace.
*/
interface Namespace {
/**
* Negative binomial distribution cumulative distribution function (CDF).
*
* @param x - input value
* @param r - number of successes until experiment is stopped
* @param p - success probability
* @returns evaluated CDF
*
* @example
* var y = ns.cdf( 5.0, 20.0, 0.8 );
* // returns ~0.617
*
* y = ns.cdf( 21.0, 20.0, 0.5 );
* // returns ~0.622
*
* y = ns.cdf( 5.0, 10.0, 0.4 );
* // returns ~0.034
*
* y = ns.cdf( 0.0, 10.0, 0.9 );
* // returns ~0.349
*
* y = ns.cdf( 21.0, 15.5, 0.5 );
* // returns ~0.859
*
* y = ns.cdf( 5.0, 7.4, 0.4 );
* // returns ~0.131
*
* var mycdf = ns.cdf.factory( 10, 0.5 );
* y = mycdf( 3.0 );
* // returns ~0.046
*
* y = mycdf( 11.0 );
* // returns ~0.668
*/
cdf: typeof cdf;
/**
* Negative Binomial Distribution.
*/
NegativeBinomial: typeof NegativeBinomial;
/**
* Returns the excess kurtosis of a negative binomial distribution.
*
* ## Notes
*
* - If provided a `r` which is not a positive number, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param r - number of failures until experiment is stopped
* @param p - success probability
* @returns excess kurtosis
*
* @example
* var v = ns.kurtosis( 100, 0.2 );
* // returns ~0.061
*
* @example
* var v = ns.kurtosis( 20, 0.5 );
* // returns ~0.325
*
* @example
* var v = ns.kurtosis( 10.3, 0.8 );
* // returns ~0.893
*
* @example
* var v = ns.kurtosis( -2, 0.5 );
* // returns NaN
*
* @example
* var v = ns.kurtosis( 20, 1.1 );
* // returns NaN
*
* @example
* var v = ns.kurtosis( 20, NaN );
* // returns NaN
*
* @example
* var v = ns.kurtosis( NaN, 0.5 );
* // returns NaN
*/
kurtosis: typeof kurtosis;
/**
* Negative binomial distribution natural logarithm of the probability mass function (logPMF).
*
* @param x - input value
* @param r - number of successes until experiment is stopped
* @param p - success probability
* @returns evaluated logPMF
*
* @example
* var y = ns.logpmf( 3.0, 20, 0.2 );
* // returns ~-1.583
*
* y = ns.logpmf( 21.0, 20, 0.2 );
* // returns -Infinity
*
* y = ns.logpmf( 5.0, 10, 0.4 );
* // returns ~-1.606
*
* y = ns.logpmf( 0.0, 10, 0.4 );
* // returns ~-5.108
*
* var mylogpmf = ns.logpmf.factory( 10, 0.5 );
*
* y = mylogpmf( 3.0 );
* // returns ~-2.146
*
* y = mylogpmf( 5.0 );
* // returns ~-1.402
*/
logpmf: typeof logpmf;
/**
* Returns the expected value of a negative binomial distribution.
*
* ## Notes
*
* - If provided a `r` which is not a positive number, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param r - number of failures until experiment is stopped
* @param p - success probability
* @returns expected value
*
* @example
* var v = ns.mean( 100, 0.2 );
* // returns 400.0
*
* @example
* var v = ns.mean( 20, 0.5 );
* // returns 20.0
*
* @example
* var v = ns.mean( 10.3, 0.8 );
* // returns ~2.575
*
* @example
* var v = ns.mean( -2, 0.5 );
* // returns NaN
*
* @example
* var v = ns.mean( 20, 1.1 );
* // returns NaN
*
* @example
* var v = ns.mean( 20, NaN );
* // returns NaN
*
* @example
* var v = ns.mean( NaN, 0.5 );
* // returns NaN
*/
mean: typeof mean;
/**
* Negative binomial distribution moment-generating function (MGF).
*
* @param t - input value
* @param r - number of successes until experiment is stopped
* @param p - success probability
* @returns evaluated MGF
*
* @example
* var y = ns.mgf( 0.05, 20.0, 0.8 );
* // returns ~267.839
*
* y = ns.mgf( 0.1, 20.0, 0.1 );
* // returns ~9.347
*
* y = ns.mgf( 0.5, 10.0, 0.4 );
* // returns ~42822.023
*
* var myMGF = ns.mgf.factory( 4.3, 0.4 );
* y = myMGF( 0.2 );
* // returns ~4.696
*
* y = myMGF( 0.4 );
* // returns ~30.83
*/
mgf: typeof mgf;
/**
* Returns the mode of a negative binomial distribution.
*
* ## Notes
*
* - If provided a `r` which is not a positive number, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param r - number of failures until experiment is stopped
* @param p - success probability
* @returns mode
*
* @example
* var v = ns.mode( 100, 0.2 );
* // returns 396
*
* @example
* var v = ns.mode( 20, 0.5 );
* // returns 19
*
* @example
* var v = ns.mode( 10.3, 0.8 );
* // returns 2
*
* @example
* var v = ns.mode( -2, 0.5 );
* // returns NaN
*
* @example
* var v = ns.mode( 20, 1.1 );
* // returns NaN
*
* @example
* var v = ns.mode( 20, NaN );
* // returns NaN
*
* @example
* var v = ns.mode( NaN, 0.5 );
* // returns NaN
*/
mode: typeof mode;
/**
* Negative binomial distribution probability mass function (PMF).
*
* @param x - input value
* @param r - number of successes until experiment is stopped
* @param p - success probability
* @returns evaluated PMF
*
* @example
* var y = ns.pmf( 5.0, 20.0, 0.8 );
* // returns ~0.157
*
* y = ns.pmf( 21.0, 20.0, 0.5 );
* // returns ~0.06
*
* y = ns.pmf( 5.0, 10.0, 0.4 );
* // returns ~0.016
*
* y = ns.pmf( 0.0, 10.0, 0.9 );
* // returns ~0.349
*
* y = ns.pmf( 21.0, 15.5, 0.5 );
* // returns ~0.037
*
* y = ns.pmf( 5.0, 7.4, 0.4 );
* // returns ~0.051
*
* var mypmf = ns.pmf.factory( 10, 0.5 );
* y = mypmf( 3.0 );
* // returns ~0.027
*
* y = mypmf( 5.0 );
* // returns ~0.061
*/
pmf: typeof pmf;
/**
* Negative binomial distribution quantile function.
*
* @param k - input value
* @param r - number of successes until experiment is stopped
* @param p - success probability
* @returns evaluated quantile function
*
* @example
* var y = ns.quantile( 0.9, 20.0, 0.2 );
* // returns 106
*
* y = ns.quantile( 0.9, 20.0, 0.8 );
* // returns 8
*
* var myquantile = ns.quantile.factory( 10.0, 0.5 );
* y = myquantile( 0.1 );
* // returns 5
*
* y = myquantile( 0.9 );
* // returns 16
*/
quantile: typeof quantile;
/**
* Returns the skewness of a negative binomial distribution.
*
* ## Notes
*
* - If provided a `r` which is not a positive number, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param r - number of failures until experiment is stopped
* @param p - success probability
* @returns skewness
*
* @example
* var v = ns.skewness( 100, 0.2 );
* // returns ~0.201
*
* @example
* var v = ns.skewness( 20, 0.5 );
* // returns ~0.474
*
* @example
* var v = ns.skewness( 10.3, 0.8 );
* // returns ~0.836
*
* @example
* var v = ns.skewness( -2, 0.5 );
* // returns NaN
*
* @example
* var v = ns.skewness( 20, 1.1 );
* // returns NaN
*
* @example
* var v = ns.skewness( 20, NaN );
* // returns NaN
*
* @example
* var v = ns.skewness( NaN, 0.5 );
* // returns NaN
*/
skewness: typeof skewness;
/**
* Returns the standard deviation of a negative binomial distribution.
*
* ## Notes
*
* - If provided a `r` which is not a positive number, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param r - number of failures until experiment is stopped
* @param p - success probability
* @returns standard deviation
*
* @example
* var v = ns.stdev( 100, 0.2 );
* // returns ~44.721
*
* @example
* var v = ns.stdev( 20, 0.5 );
* // returns ~6.325
*
* @example
* var v = ns.stdev( 10.3, 0.8 );
* // returns ~1.794
*
* @example
* var v = ns.stdev( -2, 0.5 );
* // returns NaN
*
* @example
* var v = ns.stdev( 20, 1.1 );
* // returns NaN
*
* @example
* var v = ns.stdev( 20, NaN );
* // returns NaN
*
* @example
* var v = ns.stdev( NaN, 0.5 );
* // returns NaN
*/
stdev: typeof stdev;
/**
* Returns the variance of a negative binomial distribution.
*
* ## Notes
*
* - If provided a `r` which is not a positive number, the function returns `NaN`.
* - If `p < 0` or `p > 1`, the function returns `NaN`.
*
* @param r - number of failures until experiment is stopped
* @param p - success probability
* @returns variance
*
* @example
* var v = ns.variance( 100, 0.2 );
* // returns 2000.0
*
* @example
* var v = ns.variance( 20, 0.5 );
* // returns 40.0
*
* @example
* var v = ns.variance( 10.3, 0.8 );
* // returns ~3.219
*
* @example
* var v = ns.variance( -2, 0.5 );
* // returns NaN
*
* @example
* var v = ns.variance( 20, 1.1 );
* // returns NaN
*
* @example
* var v = ns.variance( 20, NaN );
* // returns NaN
*
* @example
* var v = ns.variance( NaN, 0.5 );
* // returns NaN
*/
variance: typeof variance;
}
/**
* Negative binomial distribution.
*/
declare var ns: Namespace;
// EXPORTS //
export = ns;
```
|
```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 rest
import (
"crypto/tls"
"errors"
"net/http"
"k8s.io/client-go/plugin/pkg/client/auth/exec"
"k8s.io/client-go/transport"
)
// TLSConfigFor returns a tls.Config that will provide the transport level security defined
// by the provided Config. Will return nil if no transport level security is requested.
func TLSConfigFor(config *Config) (*tls.Config, error) {
cfg, err := config.TransportConfig()
if err != nil {
return nil, err
}
return transport.TLSConfigFor(cfg)
}
// TransportFor returns an http.RoundTripper that will provide the authentication
// or transport level security defined by the provided Config. Will return the
// default http.DefaultTransport if no special case behavior is needed.
func TransportFor(config *Config) (http.RoundTripper, error) {
cfg, err := config.TransportConfig()
if err != nil {
return nil, err
}
return transport.New(cfg)
}
// HTTPWrappersForConfig wraps a round tripper with any relevant layered behavior from the
// config. Exposed to allow more clients that need HTTP-like behavior but then must hijack
// the underlying connection (like WebSocket or HTTP2 clients). Pure HTTP clients should use
// the higher level TransportFor or RESTClientFor methods.
func HTTPWrappersForConfig(config *Config, rt http.RoundTripper) (http.RoundTripper, error) {
cfg, err := config.TransportConfig()
if err != nil {
return nil, err
}
return transport.HTTPWrappersForConfig(cfg, rt)
}
// TransportConfig converts a client config to an appropriate transport config.
func (c *Config) TransportConfig() (*transport.Config, error) {
conf := &transport.Config{
UserAgent: c.UserAgent,
Transport: c.Transport,
WrapTransport: c.WrapTransport,
DisableCompression: c.DisableCompression,
TLS: transport.TLSConfig{
Insecure: c.Insecure,
ServerName: c.ServerName,
CAFile: c.CAFile,
CAData: c.CAData,
CertFile: c.CertFile,
CertData: c.CertData,
KeyFile: c.KeyFile,
KeyData: c.KeyData,
NextProtos: c.NextProtos,
},
Username: c.Username,
Password: c.Password,
BearerToken: c.BearerToken,
BearerTokenFile: c.BearerTokenFile,
Impersonate: transport.ImpersonationConfig{
UserName: c.Impersonate.UserName,
Groups: c.Impersonate.Groups,
Extra: c.Impersonate.Extra,
},
Dial: c.Dial,
Proxy: c.Proxy,
}
if c.ExecProvider != nil && c.AuthProvider != nil {
return nil, errors.New("execProvider and authProvider cannot be used in combination")
}
if c.ExecProvider != nil {
provider, err := exec.GetAuthenticator(c.ExecProvider)
if err != nil {
return nil, err
}
if err := provider.UpdateTransportConfig(conf); err != nil {
return nil, err
}
}
if c.AuthProvider != nil {
provider, err := GetAuthProvider(c.Host, c.AuthProvider, c.AuthConfigPersister)
if err != nil {
return nil, err
}
conf.Wrap(provider.WrapTransport)
}
return conf, nil
}
// Wrap adds a transport middleware function that will give the caller
// an opportunity to wrap the underlying http.RoundTripper prior to the
// first API call being made. The provided function is invoked after any
// existing transport wrappers are invoked.
func (c *Config) Wrap(fn transport.WrapperFunc) {
c.WrapTransport = transport.Wrappers(c.WrapTransport, fn)
}
```
|
```dart
// @dart=2.9
import 'package:term_glyph/term_glyph.dart' as term_glyph;
import 'package:test/test.dart';
import 'package:_tests/compiler.dart';
import 'package:angular_compiler/v2/context.dart';
void main() {
setUpAll(() {
term_glyph.ascii = true;
CompileContext.overrideForTesting();
});
test('should identify a possibly unresolvable directive', () async {
await compilesExpecting('''
import '$ngImport';
@Directive(
selector: 'valid',
)
class ValidDirective {}
@Component(
selector: 'bad-comp',
directives: const [
OopsDirective,
ValidDirective,
],
template: '',
)
class BadComp {}
''', errors: [
allOf([
contains('Compiling @Component-annotated class "BadComp" failed'),
containsSourceLocation(11, 11),
contains('OopsDirective')
]),
]);
});
test('should error on invalid use of const', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'bad-comp',
directives: const [
UndeclaredIdentifier(),
],
template: '',
)
class BadComp {}
''', errors: [
allOf([
contains('Compiling @Component-annotated class "BadComp" failed'),
containsSourceLocation(6, 11), // points to 'const Undeclared..'
]),
]);
});
test('should error on an incorrect member annotation', () async {
// NOTE: @Input on BadComp.inValue is invalid.
await compilesExpecting('''
import '$ngImport';
@Directive(
selector: 'valid',
)
class ValidDirective {}
@Component(
selector: 'bad-comp',
directives: const [
],
template: '',
)
class BadComp {
@Input
String? inValue;
}
''', warnings: [
allOf(
contains('Annotation creation must have arguments'),
contains('Input'),
containsSourceLocation(15, 9),
),
]);
});
test('should not report unrelated errors', () async {
await compilesExpecting('''
import '$ngImport';
const int neverMentionFour = "four";
@Component(
selector: 'bad-comp',
directives: const [
OopsDirective,
],
template: '',
)
class BadComp {}
''', errors: [
allOf([
isNot(
contains(
"The argument type 'int' can't be assigned to the parameter type 'String'",
),
),
isNot(
contains('neverMentionFour'),
)
]),
]);
});
test('should error gracefully on bad constructor parameters', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'bad-constructor',
template: '',
)
class BadConstructor {
BadConstructor(@HuhWhatIsThis foo);
}
''', errors: [
// TODO(b/124524346): Only print one error.
allOf([
contains('Error evaluating annotation'),
containsSourceLocation(8, 24)
]),
]);
});
test('should identify a possibly unresolvable pipe', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'bad-comp',
template: '',
pipes: [MissingPipe],
)
class BadComp {}
''', errors: [
allOf([
contains('Compiling @Component-annotated class "BadComp" failed'),
containsSourceLocation(6, 17),
contains('MissingPipe')
]),
]);
});
test('should identify an unresolved provider', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'bad-provider',
directives: const [
ClassProvider(Nope),
],
template: '',
)
class BadProvider {}
''', errors: [
allOf([
contains('Compiling @Component-annotated class "BadProvider" failed'),
containsSourceLocation(6, 25),
contains('Nope')
])
]);
});
test('should warn on dead code', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'opaque',
template: 'I am a rock'
)
class OpaqueComponent {}
@Component(
selector: 'hidden-gold',
template: '<opaque>Dropped</opaque>',
directives: [OpaqueComponent]
)
class HiddenGoldComponenet {}
''', warnings: [
allOf([
'line 1, column 9 of asset:pkg/lib/input.dart: Dead code in template: '
'Non-empty text node (Dropped) is a child of a non-projecting '
'component (opaque) and will not be added to the DOM.\n'
' ,\n'
'1 | <opaque>Dropped</opaque>\n'
' | ^^^^^^^\n'
" '"
])
]);
});
test('should throw on unused directive types', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'generic',
template: 'Bye',
)
class GenericComponent<T> {
GenericComponent() {}
}
@Component(
selector: 'mis-match',
template: 'Aye',
directves: [],
directiveTypes: [Typed<GenericComponent<String>>()])
class ExampleComponent {}
''', errors: [
allOf([
contains('Entry in "directiveTypes" missing corresponding entry in'
' "directives" for "GenericComponent".'),
containsSourceLocation(11, 5)
])
]);
});
test('should throw on empty selector', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: '',
template: 'boo'
)
class EmptySelector {}
''', errors: [
allOf([
contains('Selector is required, got ""'),
containsSourceLocation(3, 5)
])
]);
});
test('should throw on async ngDoCheck', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'async-docheck',
template: 'boo'
)
class AsyncDoCheck implements DoCheck {
void ngDoCheck() async {}
}
''', errors: [
allOf([
contains('ngDoCheck should not be "async"'),
containsSourceLocation(8, 12)
])
]);
});
test('should throw if both "template" and "templateUrl" are present',
() async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'double-up',
template: 'boo',
templateUrl: 'boo.html'
)
class DoubleUp {}
''', errors: [
allOf([
contains(
'Cannot supply both "template" and "templateUrl" for an @Component'),
containsSourceLocation(3, 5)
])
]);
});
test('should throw if "templateUrl" fails to parse', () async {
await compilesExpecting('''
import '$ngImport';
@Component(
selector: 'bad-url',
templateUrl: '<scheme:urlWithBadScheme'
)
class BadUrl {}
''', errors: [
allOf([
contains('@Component.templateUrl is not a valid URI'),
containsSourceLocation(3, 5)
])
]);
});
test('should bind events to local variables', () async {
await compilesExpecting("""
import '$ngImport';
@Component(
selector: 'hero',
template: '<div *ngFor="let cb of callbacks"><button (click)="cb()">X</button></div>',
directives: [NgFor]
)
class HeroComponent {
final callbacks = [() => print("Hello"), () => print("Hi")];
}
""", errors: [
allOf(
contains('Expected method for event binding'),
containsSourceLocation(1, 43),
)
]);
});
test('<ng-content> should compile as expected', () async {
await compilesNormally("""
import '$ngImport';
@Component(
selector: 'foo',
template: '<ng-content select="[highlight]"></ng-content>',
)
class FooAComponent {}
@Component(
selector: 'foo[box]',
providers: [ExistingProvider(FooAComponent, FooBComponent)],
template: '',
)
class FooBComponent {}
@Component(
selector: 'test',
template: '<foo @skipSchemaValidationFor="[box]" box><p highlight>bar</p></foo>',
directives: [FooAComponent, FooBComponent],
)
class TestComponent {}
""");
});
test('should support generic component with dynamic type argument', () {
return compilesNormally('''
import '$ngImport';
@Component(
selector: 'generic',
template: '',
)
class GenericComponent<T> {}
@Component(
selector: 'test',
template: '<generic></generic>',
directives: [GenericComponent],
directiveTypes: [Typed<GenericComponent<dynamic>>()],
)
class TestComponent {}
''');
});
group('providers', () {
test('should error on invalid token', () async {
await compilesExpecting('''
import '$ngImport';
const tokenRef = BadToken;
@Component(
selector: 'badToken',
template: '',
providers: [ClassProvider(tokenRef)]
)
class BadComponent {}
''', errors: [
allOf(
contains(
'Evaluation of this constant expression throws an exception',
),
containsSourceLocation(8, 21),
),
]);
});
test('should warn on when provider is not a class', () async {
await compilesExpecting('''
import '$ngImport';
typedef Compare = int Function(Object a, Object b);
@Component(
selector: 'stringProvider',
template: '',
providers: [Compare]
)
class BadComponent {}
''', errors: [], warnings: [
allOf(
contains('Expected to find class in provider list'),
containsSourceLocation(
4,
7,
),
), // pointing at @Component
]);
});
test('should error on when useClass is not a class', () async {
await compilesExpecting('''
import '$ngImport';
class ToProvide {}
typedef Compare = int Function(Object a, Object b);
@Component(
selector: 'useClass',
template: '',
providers: [ClassProvider(ToProvide, useClass: Compare)]
)
class BadComponent {}
''', errors: [
allOf(
contains('Provider.useClass can only be used with a class'),
containsSourceLocation(6, 7),
) // pointing at @Component
]);
});
test('should error on when useFactory is not a function', () async {
await compilesExpecting(
'''
import '$ngImport';
class ToProvide {}
@Component(
selector: 'useFactory',
template: '',
providers: [FactoryProvider(ToProvide, ToProvide)]
)
class BadComponent {}
''',
errors: [
allOf(
contains('ToProvide'),
containsSourceLocation(8, 48),
),
],
);
});
test('should still warn when useClass: is used with an interface',
() async {
await compilesExpecting("""
import '$ngImport';
abstract class JustAnInterface {}
@Component(
selector: 'comp',
provides: const [
const Provider(JustAnInterface, useClass: JustAnInterface),
],
template: '',
)
class Comp {}
""", warnings: [
contains('Found a constructor for an abstract class JustAnInterface'),
]);
},
skip:
'This fails both before AND after the fix for #906. Fixing after.');
test('should still warn when using a type implicitly as useClass:',
() async {
await compilesExpecting("""
import '$ngImport';
abstract class JustAnInterface {}
@Component(
selector: 'comp',
provides: const [
JustAnInterface,
],
template: '',
)
class Comp {}
""", warnings: [
contains('Found a constructor for an abstract class JustAnInterface'),
]);
},
skip:
'This fails both before AND after the fix for #906. Fixing after.');
});
test('test', () async {
final wrongType = 'Model Function()';
await compilesExpecting("""
import '$ngImport';
@Injectable()
class Model {}
@Injectable()
class TypeUndefined {
final $wrongType _model;
TypeUndefined(this._model);
}
@Component(
selector: 'test',
template: '',
providers: [ClassProvider(TypeUndefined)],
)
class TypeUndefinedComp {
final _type;
TypeUndefinedComp(this._type);
}
""", errors: [
contains('A function type: $wrongType is not recognized'),
]);
});
}
```
|
The Bridlington Principles are a set of rules aimed at resolving conflicts among trade unions. in the United Kingdom. The principles form the Trades Union Congress (TUC) code of practice that unions in England and Wales must adhere to as a condition of continued affiliation.
First adopted in 1939 at the TUC's 1939 Congress meeting in Bridlington, the principles initially required that unions did not attempt to "poach" each other's members, in the interests of a cohesive, non-conflictual atmosphere of industrial relations.
In trade union branch meetings, membership applications from members of other unions are often "accepted subject to Bridlington".
The principles have been updated over time by TUC, and have been published in a booklet called TUC Disputes Principles and Procedures since 1976. In May 2000, an update took into account the then new statutory recognition scheme. In September 2007, TUC agreed to changes to Principle 3 recommended by the TUC Executive Committee in the Annual Report to Congress. References to situations where a union is currently engaged in organising activity were added. The most recent update to the booklet and principles was published in March 2019. This and the previous 2016 update "strengthened the provisions regarding union conduct towards sister organisations, and reinforced the responsibility of unions to positively engage when members transfer their employment," including provisions against undercutting sister unions' membership rates. The 2019 update also set out principles for joint working arrangements on industrial campaigns in multi-union environments.
The four principles cover:
Co-operation and the prevention of disputes
Membership
Organisation and recognition
Inter-union disputes and industrial action
See also
UK labour law
References
United Kingdom labour law
1939 in the United Kingdom
1939 in labor relations
|
```xml
import React from "react";
import gql from "graphql-tag";
import { DocumentNode } from "graphql";
import { render, waitFor } from "@testing-library/react";
import { ApolloClient } from "../../../../core";
import { ApolloProvider } from "../../../context";
import { InMemoryCache as Cache } from "../../../../cache";
import { itAsync, mockSingleLink } from "../../../../testing";
import { graphql } from "../../graphql";
import { ChildProps } from "../../types";
describe("[queries] updateQuery", () => {
// updateQuery
itAsync("exposes updateQuery as part of the props api", (resolve, reject) => {
const query: DocumentNode = gql`
query people {
allPeople(first: 1) {
people {
name
}
}
}
`;
const link = mockSingleLink({
request: { query },
result: { data: { allPeople: { people: [{ name: "Luke Skywalker" }] } } },
});
const client = new ApolloClient({
link,
cache: new Cache({ addTypename: false }),
});
let done = false;
const Container = graphql(query)(
class extends React.Component<ChildProps> {
componentDidUpdate() {
const { data } = this.props;
expect(data!.updateQuery).toBeTruthy();
expect(data!.updateQuery instanceof Function).toBeTruthy();
try {
data!.updateQuery(() => {
done = true;
});
} catch (error) {
reject(error);
}
}
render() {
return null;
}
}
);
render(
<ApolloProvider client={client}>
<Container />
</ApolloProvider>
);
waitFor(() => expect(done).toBeTruthy()).then(resolve, reject);
});
itAsync(
"exposes updateQuery as part of the props api during componentWillMount",
(resolve, reject) => {
let done = false;
const query: DocumentNode = gql`
query people {
allPeople(first: 1) {
people {
name
}
}
}
`;
const link = mockSingleLink({
request: { query },
result: {
data: { allPeople: { people: [{ name: "Luke Skywalker" }] } },
},
});
const client = new ApolloClient({
link,
cache: new Cache({ addTypename: false }),
});
const Container = graphql(query)(
class extends React.Component<ChildProps> {
render() {
expect(this.props.data!.updateQuery).toBeTruthy();
expect(
this.props.data!.updateQuery instanceof Function
).toBeTruthy();
done = true;
return null;
}
}
);
render(
<ApolloProvider client={client}>
<Container />
</ApolloProvider>
);
waitFor(() => {
expect(done).toBe(true);
}).then(resolve, reject);
}
);
itAsync(
"updateQuery throws if called before data has returned",
(resolve, reject) => {
let renderCount = 0;
const query: DocumentNode = gql`
query people {
allPeople(first: 1) {
people {
name
}
}
}
`;
const link = mockSingleLink({
request: { query },
result: {
data: { allPeople: { people: [{ name: "Luke Skywalker" }] } },
},
});
const client = new ApolloClient({
link,
cache: new Cache({ addTypename: false }),
});
const Container = graphql(query)(
class extends React.Component<ChildProps> {
render() {
expect(this.props.data!.updateQuery).toBeTruthy();
expect(
this.props.data!.updateQuery instanceof Function
).toBeTruthy();
try {
this.props.data!.updateQuery((p) => p);
} catch (e: any) {
// TODO: branch never hit in test
expect(e.toString()).toMatch(
/ObservableQuery with this id doesn't exist:/
);
}
renderCount += 1;
return null;
}
}
);
render(
<ApolloProvider client={client}>
<Container />
</ApolloProvider>
);
waitFor(() => {
expect(renderCount).toBe(2);
}).then(resolve, reject);
}
);
itAsync(
"allows updating query results after query has finished (early binding)",
(resolve, reject) => {
let done = false;
const query: DocumentNode = gql`
query people {
allPeople(first: 1) {
people {
name
}
}
}
`;
const data1 = { allPeople: { people: [{ name: "Luke Skywalker" }] } };
type Data = typeof data1;
const data2 = { allPeople: { people: [{ name: "Leia Skywalker" }] } };
const link = mockSingleLink(
{ request: { query }, result: { data: data1 } },
{ request: { query }, result: { data: data2 } }
);
const client = new ApolloClient({
link,
cache: new Cache({ addTypename: false }),
});
let isUpdated = false;
const Container = graphql<{}, Data>(query)(
class extends React.Component<ChildProps<{}, Data>> {
public updateQuery: any;
componentDidUpdate() {
if (isUpdated) {
expect(this.props.data!.allPeople).toEqual(data2.allPeople);
done = true;
return;
} else {
isUpdated = true;
this.updateQuery(() => {
return data2;
});
}
}
render() {
this.updateQuery = this.props.data!.updateQuery;
return null;
}
}
);
render(
<ApolloProvider client={client}>
<Container />
</ApolloProvider>
);
waitFor(() => {
expect(done).toBe(true);
}).then(resolve, reject);
}
);
itAsync(
"allows updating query results after query has finished",
(resolve, reject) => {
let done = false;
const query: DocumentNode = gql`
query people {
allPeople(first: 1) {
people {
name
}
}
}
`;
const data1 = { allPeople: { people: [{ name: "Luke Skywalker" }] } };
type Data = typeof data1;
const data2 = { allPeople: { people: [{ name: "Leia Skywalker" }] } };
const link = mockSingleLink(
{ request: { query }, result: { data: data1 } },
{ request: { query }, result: { data: data2 } }
);
const client = new ApolloClient({
link,
cache: new Cache({ addTypename: false }),
});
let isUpdated = false;
const Container = graphql<{}, Data>(query)(
class extends React.Component<ChildProps<{}, Data>> {
componentDidUpdate() {
if (isUpdated) {
expect(this.props.data!.allPeople).toEqual(data2.allPeople);
done = true;
return;
} else {
isUpdated = true;
this.props.data!.updateQuery(() => {
return data2;
});
}
}
render() {
return null;
}
}
);
render(
<ApolloProvider client={client}>
<Container />
</ApolloProvider>
);
waitFor(() => {
expect(done).toBe(true);
}).then(resolve, reject);
}
);
});
```
|
```javascript
/*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/**
* @interface
*/
WebInspector.LayerView = function()
{
}
WebInspector.LayerView.prototype = {
/**
* @param {?WebInspector.LayerView.Selection} selection
*/
hoverObject: function(selection) { },
/**
* @param {?WebInspector.LayerView.Selection} selection
*/
selectObject: function(selection) { },
/**
* @param {?WebInspector.LayerTreeBase} layerTree
*/
setLayerTree: function(layerTree) { }
}
/**
* @constructor
* @param {!WebInspector.LayerView.Selection.Type} type
* @param {!WebInspector.Layer} layer
*/
WebInspector.LayerView.Selection = function(type, layer)
{
this._type = type;
this._layer = layer;
}
/**
* @enum {string}
*/
WebInspector.LayerView.Selection.Type = {
Layer: "Layer",
ScrollRect: "ScrollRect",
Tile: "Tile",
}
WebInspector.LayerView.Selection.prototype = {
/**
* @return {!WebInspector.LayerView.Selection.Type}
*/
type: function()
{
return this._type;
},
/**
* @return {!WebInspector.Layer}
*/
layer: function()
{
return this._layer;
},
/**
* @param {!WebInspector.LayerView.Selection} other
* @return {boolean}
*/
isEqual: function(other)
{
return false;
}
}
/**
* @constructor
* @extends {WebInspector.LayerView.Selection}
* @param {!WebInspector.Layer} layer
*/
WebInspector.LayerView.LayerSelection = function(layer)
{
console.assert(layer, "LayerSelection with empty layer");
WebInspector.LayerView.Selection.call(this, WebInspector.LayerView.Selection.Type.Layer, layer);
}
WebInspector.LayerView.LayerSelection.prototype = {
/**
* @override
* @param {!WebInspector.LayerView.Selection} other
* @return {boolean}
*/
isEqual: function(other)
{
return other._type === WebInspector.LayerView.Selection.Type.Layer && other.layer().id() === this.layer().id();
},
__proto__: WebInspector.LayerView.Selection.prototype
}
/**
* @constructor
* @extends {WebInspector.LayerView.Selection}
* @param {!WebInspector.Layer} layer
* @param {number} scrollRectIndex
*/
WebInspector.LayerView.ScrollRectSelection = function(layer, scrollRectIndex)
{
WebInspector.LayerView.Selection.call(this, WebInspector.LayerView.Selection.Type.ScrollRect, layer);
this.scrollRectIndex = scrollRectIndex;
}
WebInspector.LayerView.ScrollRectSelection.prototype = {
/**
* @override
* @param {!WebInspector.LayerView.Selection} other
* @return {boolean}
*/
isEqual: function(other)
{
return other._type === WebInspector.LayerView.Selection.Type.ScrollRect &&
this.layer().id() === other.layer().id() && this.scrollRectIndex === other.scrollRectIndex;
},
__proto__: WebInspector.LayerView.Selection.prototype
}
/**
* @constructor
* @extends {WebInspector.LayerView.Selection}
* @param {!WebInspector.Layer} layer
* @param {!WebInspector.TracingModel.Event} traceEvent
*/
WebInspector.LayerView.TileSelection = function(layer, traceEvent)
{
WebInspector.LayerView.Selection.call(this, WebInspector.LayerView.Selection.Type.Tile, layer);
this._traceEvent = traceEvent;
}
WebInspector.LayerView.TileSelection.prototype = {
/**
* @override
* @param {!WebInspector.LayerView.Selection} other
* @return {boolean}
*/
isEqual: function(other)
{
return other._type === WebInspector.LayerView.Selection.Type.Tile
&& this.layer().id() === other.layer().id() && this.traceEvent === other.traceEvent;
},
/**
* @return {!WebInspector.TracingModel.Event}
*/
traceEvent: function()
{
return this._traceEvent;
},
__proto__: WebInspector.LayerView.Selection.prototype
}
/**
* @constructor
*/
WebInspector.LayerViewHost = function()
{
/** @type {!Array.<!WebInspector.LayerView>} */
this._views = [];
this._selectedObject = null;
this._hoveredObject = null;
this._showInternalLayersSetting = WebInspector.settings.createSetting("layersShowInternalLayers", false);
}
WebInspector.LayerViewHost.prototype = {
/**
* @param {!WebInspector.LayerView} layerView
*/
registerView: function(layerView)
{
this._views.push(layerView);
},
/**
* @param {?WebInspector.LayerTreeBase} layerTree
*/
setLayerTree: function(layerTree)
{
this._target = layerTree.target();
var selectedLayer = this._selectedObject && this._selectedObject.layer();
if (selectedLayer && (!layerTree || !layerTree.layerById(selectedLayer.id())))
this.selectObject(null);
var hoveredLayer = this._hoveredObject && this._hoveredObject.layer();
if (hoveredLayer && (!layerTree || !layerTree.layerById(hoveredLayer.id())))
this.hoverObject(null);
for (var view of this._views)
view.setLayerTree(layerTree);
},
/**
* @param {?WebInspector.LayerView.Selection} selection
*/
hoverObject: function(selection)
{
if (this._hoveredObject === selection)
return;
this._hoveredObject = selection;
var layer = selection && selection.layer();
this._toggleNodeHighlight(layer ? layer.nodeForSelfOrAncestor() : null);
for (var view of this._views)
view.hoverObject(selection);
},
/**
* @param {?WebInspector.LayerView.Selection} selection
*/
selectObject: function(selection)
{
if (this._selectedObject === selection)
return;
this._selectedObject = selection;
for (var view of this._views)
view.selectObject(selection);
},
/**
* @return {?WebInspector.LayerView.Selection}
*/
selection: function()
{
return this._selectedObject;
},
/**
* @param {!WebInspector.ContextMenu} contextMenu
* @param {?WebInspector.LayerView.Selection} selection
*/
showContextMenu: function(contextMenu, selection)
{
contextMenu.appendCheckboxItem(WebInspector.UIString("Show internal layers"), this._toggleShowInternalLayers.bind(this), this._showInternalLayersSetting.get());
var node = selection && selection.layer() && selection.layer().nodeForSelfOrAncestor();
if (node)
contextMenu.appendApplicableItems(node);
contextMenu.show();
},
/**
* @return {!WebInspector.Setting}
*/
showInternalLayersSetting: function()
{
return this._showInternalLayersSetting;
},
_toggleShowInternalLayers: function()
{
this._showInternalLayersSetting.set(!this._showInternalLayersSetting.get());
},
/**
* @param {?WebInspector.DOMNode} node
*/
_toggleNodeHighlight: function(node)
{
if (node) {
node.highlightForTwoSeconds();
return;
}
WebInspector.DOMModel.hideDOMNodeHighlight();
}
}
```
|
```objective-c
/*++
Module Name:
pshpack8.h
Abstract:
This file turns 8 byte packing of structures on. (That is, it disables
automatic alignment of structure fields.) An include file is needed
because various compilers do this in different ways. For Microsoft
compatible compilers, this files uses the push option to the pack pragma
so that the poppack.h include file can restore the previous packing
reliably.
The file poppack.h is the complement to this file.
--*/
#if ! (defined(lint) || defined(RC_INVOKED))
#if ( _MSC_VER >= 800 && !defined(_M_I86)) || defined(_PUSHPOP_SUPPORTED)
#pragma warning(disable:4103)
#if !(defined( MIDL_PASS )) || defined( __midl )
#pragma pack(push,8)
#else
#pragma pack(8)
#endif
#else
#pragma pack(8)
#endif
#endif // ! (defined(lint) || defined(RC_INVOKED))
```
|
```haskell
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
-- | Testing that @PrettyBy config@ and @Pretty@ instances are in sync for types that have
-- peculiar default pretty-printing behavior (@Char@, @Maybe@, @[]@) and for types with regular
-- pretty-printing behavior (@Integer@, @(,)@, @Text@).
module Default
( test_default
) where
import Text.Pretty
import Text.PrettyBy
import Text.PrettyBy.Fixity
import Data.Proxy
import Data.Text qualified as Text
import Data.Text.Arbitrary
import Test.QuickCheck
import Test.Tasty
import Test.Tasty.QuickCheck
newtype OnlyType = OnlyType RenderContext
instance HasRenderContext OnlyType where
renderContext f (OnlyType context) = OnlyType <$> f context
instance PrettyBy OnlyType (Proxy a) => PrettyBy OnlyType (Proxy [a]) where
prettyBy = inContextM $ \_ ->
withPrettyAt ToTheRight botFixity $ \prettyBot ->
unitDocM . brackets . prettyBot $ Proxy @a
instance PrettyBy OnlyType (Proxy a) => PrettyBy OnlyType (Proxy (Maybe a)) where
prettyBy = inContextM $ \_ ->
sequenceDocM ToTheRight juxtFixity $ \prettyEl ->
"Maybe" <+> prettyEl (Proxy @a)
instance (PrettyBy OnlyType (Proxy a), PrettyBy OnlyType (Proxy b)) =>
PrettyBy OnlyType (Proxy (a, b)) where
prettyBy = inContextM $ \_ ->
withPrettyAt ToTheRight botFixity $ \prettyBot ->
unitDocM $ mconcat
[ "("
, prettyBot $ Proxy @a
, ", "
, prettyBot $ Proxy @b
, ")"
]
instance PrettyBy OnlyType (Proxy Integer) where
prettyBy = inContextM $ \_ ->
"Integer"
instance PrettyBy OnlyType (Proxy Char) where
prettyBy = inContextM $ \_ ->
"Char"
instance PrettyBy OnlyType (Proxy Text) where
prettyBy = inContextM $ \_ ->
"Text"
type TestCaseConstr a = (Show a, Pretty a, PrettyBy () a, PrettyBy OnlyType (Proxy a), Arbitrary a)
data TestCase = forall a. TestCaseConstr a => TestCase a
maybeOf :: Gen a -> Gen (Maybe a)
maybeOf genX = frequency
[ (1, pure Nothing)
, (3, Just <$> genX)
]
instance Arbitrary TestCase where
arbitrary = go 13 $ fmap TestCase where
go
:: Int
-> (forall a. TestCaseConstr a => Gen a -> Gen TestCase)
-> Gen TestCase
go i k = frequency $ filter ((> 0) . fst)
[ (i, go (i - 3) $ k . vectorOf (2 * i))
, (i, go (i - 3) $ k . maybeOf)
, (i, go (i `div` 2) $ \genX -> go (i `div` 2) $ \genY -> k $ (,) <$> genX <*> genY)
, (14 - i, k $ arbitrarySizedIntegral @Integer)
, (14 - i, k arbitraryPrintableChar)
, (14 - i, k $ Text.pack <$> listOf arbitraryPrintableChar)
]
-- We do not attempt to shrink types of generated expressions, only expressions themselves.
shrink (TestCase x) = map TestCase $ shrink x
prettyByRespectsDefaults :: Blind TestCase -> Property
prettyByRespectsDefaults (Blind (TestCase (x :: a))) =
label exprType $ counterexample err $ viaPretty == viaPrettyBy
where
exprType = show . prettyBy (OnlyType botRenderContext) $ Proxy @a
exprRepr = show x
viaPretty = show $ pretty x
viaPrettyBy = show $ prettyBy () x
err = unlines
[ "Mismatch for: " ++ exprRepr
, "Via Pretty: " ++ viaPretty
, "Via PrettyBy: " ++ viaPrettyBy
]
test_default :: TestTree
test_default = testProperty "default" $ withMaxSuccess 500 prettyByRespectsDefaults
```
|
```java
package com.example.jingbin.cloudreader.bean.wanandroid;
import android.text.Html;
import android.text.TextUtils;
import com.example.jingbin.cloudreader.utils.DataUtil;
/**
* @author jingbin
* @data 2018/10/8
* @description item bean
*/
public class ArticlesBean {
/**
* apkLink : path_to_url
* author : GcsSloop
* chapterId : 294
* chapterName :
* collect : false
* courseId : 13
* desc : Diycode ()bug beta
* envelopePic : path_to_url
* id : 2241
* link : path_to_url
* niceDate : 2018-01-29
* origin :
* projectLink : path_to_url
* publishTime : 1517236491000
* title : diycode
* visible : 1
* zan : 0
*/
private String apkLink;
private String author;
private int chapterId;
private String chapterName;
private boolean collect;
private int courseId;
private String desc;
private String envelopePic;
private int id;
private int userId;
private int originId = -1;// id
private String link;
private String niceDate;
private String origin;
private String projectLink;
private long publishTime;
private String title;
private int visible;
private int zan;
private boolean fresh;
private boolean isShowImage = true;
// name
private String navigationName;
// author shareUser
private String shareUser;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getShareUser() {
return shareUser;
}
public void setShareUser(String shareUser) {
this.shareUser = shareUser;
}
public String getNavigationName() {
return navigationName;
}
public void setNavigationName(String navigationName) {
this.navigationName = navigationName;
}
public boolean isShowImage() {
return isShowImage;
}
public void setShowImage(boolean showImage) {
isShowImage = showImage;
}
public boolean isFresh() {
return fresh;
}
public void setFresh(boolean fresh) {
this.fresh = fresh;
}
public int getOriginId() {
return originId;
}
public void setOriginId(int originId) {
this.originId = originId;
}
public String getApkLink() {
return apkLink;
}
public void setApkLink(String apkLink) {
this.apkLink = apkLink;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getChapterId() {
return chapterId;
}
public void setChapterId(int chapterId) {
this.chapterId = chapterId;
}
public String getChapterName() {
return chapterName;
}
public void setChapterName(String chapterName) {
this.chapterName = chapterName;
}
public boolean isCollect() {
return collect;
}
public void setCollect(boolean collect) {
this.collect = collect;
}
public int getCourseId() {
return courseId;
}
public void setCourseId(int courseId) {
this.courseId = courseId;
}
public String getDesc() {
if (!TextUtils.isEmpty(desc)) {
String desc1 = Html.fromHtml(desc).toString();
desc = DataUtil.removeAllBank(desc1, 2);
}
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getEnvelopePic() {
return envelopePic;
}
public void setEnvelopePic(String envelopePic) {
this.envelopePic = envelopePic;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
public String getNiceDate() {
if (!TextUtils.isEmpty(niceDate) && niceDate.endsWith("00:00")) {
niceDate = niceDate.replace("00:00", "");
}
return niceDate;
}
public void setNiceDate(String niceDate) {
this.niceDate = niceDate;
}
public String getOrigin() {
return origin;
}
public void setOrigin(String origin) {
this.origin = origin;
}
public String getProjectLink() {
return projectLink;
}
public void setProjectLink(String projectLink) {
this.projectLink = projectLink;
}
public long getPublishTime() {
return publishTime;
}
public void setPublishTime(long publishTime) {
this.publishTime = publishTime;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getVisible() {
return visible;
}
public void setVisible(int visible) {
this.visible = visible;
}
public int getZan() {
return zan;
}
public void setZan(int zan) {
this.zan = zan;
}
}
```
|
```python
from . import reactivetest, reactive_assert
from .testscheduler import TestScheduler
from .reactivetest import OnNextPredicate, OnErrorPredicate, ReactiveTest, is_prime
from .mockdisposable import MockDisposable
```
|
```go
package models
import (
"log"
"strings"
"github.com/jinzhu/gorm"
)
type InvoiceNumber struct {
InstanceID string `gorm:"primary_key"`
Number int64
}
// TableName returns the database table name for the LineItem model.
func (InvoiceNumber) TableName() string {
return tableName("invoice_numbers")
}
// NextInvoiceNumber updates and returns the next invoice number for the instance
func NextInvoiceNumber(tx *gorm.DB, instanceID string) (int64, error) {
number := InvoiceNumber{}
if instanceID == "" {
instanceID = "global-instance"
}
if result := tx.Where(InvoiceNumber{InstanceID: instanceID}).Attrs(InvoiceNumber{Number: 0}).FirstOrCreate(&number); result.Error != nil {
return 0, result.Error
}
numberTable := tx.NewScope(InvoiceNumber{}).QuotedTableName()
if result := tx.Raw("select number from "+numberTable+" where instance_id = ? for update", instanceID).Scan(&number); result.Error != nil {
if strings.Contains(result.Error.Error(), "syntax error") {
log.Println("This DB driver doesn't support select for update, hoping for the best...")
} else {
return 0, result.Error
}
}
if result := tx.Model(number).Update("number", gorm.Expr("number + 1")); result.Error != nil {
return 0, result.Error
}
return number.Number + 1, nil
}
```
|
```xml
import { screen } from '@testing-library/dom';
import { ApiImporterState, ApiReportRollbackState } from '@proton/activation/src/api/api.interface';
import { easySwitchRender } from '@proton/activation/src/tests/render';
import ReportRowStatus from './ReportRowStatus';
describe('ReportRowStatus', () => {
it('Should display paused status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.PAUSED} rollbackState={undefined} />);
screen.getByText('Paused');
});
it('Should display canceled status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.CANCELED} rollbackState={undefined} />);
screen.getByText('Canceled');
});
it('Should display Completed status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.DONE} rollbackState={undefined} />);
screen.getByText('Completed');
});
it('Should display FAILED status', () => {
easySwitchRender(<ReportRowStatus status={ApiImporterState.FAILED} rollbackState={undefined} />);
screen.getByText('Failed');
});
it('Should display ROLLED_BACK status', () => {
easySwitchRender(
<ReportRowStatus status={ApiImporterState.FAILED} rollbackState={ApiReportRollbackState.ROLLED_BACK} />
);
screen.getByText('Undo finished');
});
it('Should display ROLLING_BACK status', () => {
easySwitchRender(
<ReportRowStatus status={ApiImporterState.FAILED} rollbackState={ApiReportRollbackState.ROLLING_BACK} />
);
screen.getByText('Undo in progress');
});
});
```
|
Elvin Ibrisimovic (born 19 April 1999) is an Austrian professional footballer who plays as a forward for Liechtensteiner club Vaduz in the Swiss Challenge League.
Career
A youth product of Bregenz, Ibrisimovic started his career with the club before joining FC Hard for the 2017–18 season. He moved to Wacker Innsbruck in the summer of 2018. Ibrisimovic made his professional debut with Wacker Innsbruck II in a 0–0 Austrian 2. Liga tie with SKU Amstetten on 5 August 2018. He transferred to FC Vaduz in the Swiss Super League on 22 December 2020.
References
External links
SFL Profile
OEFB profile
1999 births
Living people
Sportspeople from Bregenz
Footballers from Vorarlberg
Austrian men's footballers
Austria men's youth international footballers
Men's association football forwards
FC Vaduz players
FC Wacker Innsbruck (2002) players
FC Dornbirn 1913 players
Swiss Super League players
2. Liga (Austria) players
Austrian Regionalliga players
Austrian Landesliga players
Swiss Challenge League players
Austrian expatriate men's footballers
Austrian expatriate sportspeople in Liechtenstein
Expatriate men's footballers in Liechtenstein
|
Saint-Genest-de-Contest (Languedocien: Sent Guinièis) is a commune in the Tarn department in southern France.
Geography
The Dadou forms the commune's northern border.
See also
Communes of the Tarn department
References
Communes of Tarn (department)
|
Julie Kathleen Payne is an American television, film and stage actress who, in a career lasting over four decades, has specialized primarily in comedy roles as well as voice acting. She was a cast member in three short-lived network sitcoms during 1983–1986, and appeared in about twenty feature films and over a hundred episodes of TV series as well as providing voices for scores of TV animated shows.
Early life
A native of Oregon, Julie Payne was born in Sweet Home, near the lake and river areas adjoining the Cascade Range. Growing up in the state's second-largest city, Eugene, she attended South Eugene High School, where she performed in a number of school productions, including The Music Man, The Madwoman of Chaillot, The Lark and Once Upon a Mattress. After graduating in 1964, she moved to California, where she studied drama at Santa Clara University and French at San Francisco State University.
Career
Leaving college without a degree, Payne traveled to Europe, where she hitchhiked through various locations and, upon returning to San Francisco during the 1967 Haight-Ashbury "Summer of Love", became a member of the improvisational comedy/satire group, The Committee, remaining with it, on and off, until 1974.
During her years with The Committee, she began appearing in films (her on-screen debut occurred as part of the group's performance at the September 1969 Big Sur Folk Festival, held a month after Woodstock, and is included in the 1971 concert film, Celebration at Big Sur).
At the start of the 1970s, she was seen in bit parts, without the group, in The Strawberry Statement and The Candidate, as well as on television (The Flip Wilson Show, The Tonight Show Starring Johnny Carson, The Midnight Special, The Streets of San Francisco and others).
In 1976, two years after leaving The Committee, she and another former member of the group, Ruth Silveira, wrote and starred in People Pie, their two-woman satirical revue which they premiered in Los Angeles and took on the road, including to Eugene, its initial stop, and her first visit to the city since leaving it in 1964.
Between February 1983 and June 1986, she was a regular in three network series, but each lasted less than three months. In CBS' hour-long 1983 humorous fantasy, Wizards and Warriors, she played good queen Lattinia, one of many characters in a large ensemble cast, but the special-effects-laden expensive series was a Saturday-night ratings failure, lasting only from February 26 to May 14. She also starred in "WKRP in Cincinnati" as Buffy, one of Johnny Fever's former girlfriends.
Starting in mid-1980s, Payne shifted her focus to television voice work. She was heard in the animated segments of The Tracey Ullman Show and provided various voices, primarily those of Dr. Liz Wilson and Lanolin in a series of specials based on the comic strip Garfield, as well as in the series Garfield and Friends and The Garfield Show.
In 1993, she played Embarcadero Bank worker Eleanor Cooke (AKA Former Smash Club cage dancer Ginger Snap) in the Full House episode "Smash Club: the Next Generation". Payne portrayed the recurring character of Larry David's mother-in-law on his HBO satirical comedy series, Curb Your Enthusiasm.
Filmography
Film
Television
References
External links
Living people
Actresses from Eugene, Oregon
American television actresses
American voice actresses
People from Sweet Home, Oregon
Santa Clara University alumni
South Eugene High School alumni
21st-century American actresses
Year of birth missing (living people)
|
Essertines-sur-Rolle (, literally Essertines on Rolle) is a municipality in the district of Nyon in the canton of Vaud in Switzerland.
History
Essertines-sur-Rolle is first mentioned in 1152 as Essartinis.
Geography
Essertines-sur-Rolle has an area, , of . Of this area, or 70.2% is used for agricultural purposes, while or 22.9% is forested. Of the rest of the land, or 7.6% is settled (buildings or roads).
Of the built up area, housing and buildings made up 3.9% and transportation infrastructure made up 2.2%. Out of the forested land, 20.0% of the total land area is heavily forested and 2.9% is covered with orchards or small clusters of trees. Of the agricultural land, 47.3% is used for growing crops and 12.9% is pastures, while 9.9% is used for orchards or vine crops.
The municipality was part of the Rolle District until it was dissolved on 31 August 2006, and Essertines-sur-Rolle became part of the new district of Nyon.
It consists of the village of Essertines-sur-Rolle and the hamlet of Bugnaux.
Coat of arms
The blazon of the municipal coat of arms is Or, three Annulets one and two interwoven Sable, in chief Vert a Saltire couped Or.
Demographics
Essertines-sur-Rolle has a population () of . , 20.9% of the population are resident foreign nationals. Over the last 10 years (1999–2009 ) the population has changed at a rate of 36.1%. It has changed at a rate of 23.2% due to migration and at a rate of 12.7% due to births and deaths.
Most of the population () speaks French (391 or 78.8%), with German being second most common (41 or 8.3%) and English being third (28 or 5.6%). There are 8 people who speak Italian.
The age distribution, , in Essertines-sur-Rolle is; 124 children or 18.7% of the population are between 0 and 9 years old and 80 teenagers or 12.0% are between 10 and 19. Of the adult population, 70 people or 10.5% of the population are between 20 and 29 years old. 117 people or 17.6% are between 30 and 39, 106 people or 16.0% are between 40 and 49, and 79 people or 11.9% are between 50 and 59. The senior population distribution is 59 people or 8.9% of the population are between 60 and 69 years old, 13 people or 2.0% are between 70 and 79, there are 14 people or 2.1% who are between 80 and 89, and there are 2 people or 0.3% who are 90 and older.
, there were 226 people who were single and never married in the municipality. There were 231 married individuals, 17 widows or widowers and 22 individuals who are divorced.
the average number of residents per living room was 0.56 which is about equal to the cantonal average of 0.61 per room. In this case, a room is defined as space of a housing unit of at least 4 m2 (43 sq ft) as normal bedrooms, dining rooms, living rooms, kitchens and habitable cellars and attics. About 46.8% of the total households were owner occupied, or in other words did not pay rent (though they may have a mortgage or a rent-to-own agreement).
, there were 179 private households in the municipality, and an average of 2.6 persons per household. There were 52 households that consist of only one person and 19 households with five or more people. Out of a total of 191 households that answered this question, 27.2% were households made up of just one person. Of the rest of the households, there are 44 married couples without children, 69 married couples with children There were 8 single parents with a child or children. There were 6 households that were made up of unrelated people and 12 households that were made up of some sort of institution or another collective housing.
there were 69 single family homes (or 50.7% of the total) out of a total of 136 inhabited buildings. There were 22 multi-family buildings (16.2%), along with 34 multi-purpose buildings that were mostly used for housing (25.0%) and 11 other use buildings (commercial or industrial) that also had some housing (8.1%).
, a total of 139 apartments (70.6% of the total) were permanently occupied, while 51 apartments (25.9%) were seasonally occupied and 7 apartments (3.6%) were empty. , the construction rate of new housing units was 0 new units per 1000 residents. The vacancy rate for the municipality, , was 3.36%.
The historical population is given in the following chart:
Sights
The entire hamlet of Bugnaux is designated as part of the Inventory of Swiss Heritage Sites.
Politics
In the 2007 federal election the most popular party was the SVP which received 22.52% of the vote. The next three most popular parties were the SP (18.09%), the Green Party (13.95%) and the FDP (12.3%). In the federal election, a total of 177 votes were cast, and the voter turnout was 48.2%.
Economy
, Essertines-sur-Rolle had an unemployment rate of 2.9%. , there were 83 people employed in the primary economic sector and about 14 businesses involved in this sector. 7 people were employed in the secondary sector and there were 4 businesses in this sector. 35 people were employed in the tertiary sector, with 11 businesses in this sector. There were 282 residents of the municipality who were employed in some capacity, of which females made up 48.2% of the workforce.
the total number of full-time equivalent jobs was 71. The number of jobs in the primary sector was 41, all of which were in agriculture. The number of jobs in the secondary sector was 6 of which 4 or (66.7%) were in manufacturing and 2 (33.3%) were in construction. The number of jobs in the tertiary sector was 24. In the tertiary sector; 5 or 20.8% were in wholesale or retail sales or the repair of motor vehicles, 3 or 12.5% were in a hotel or restaurant, 1 was a technical professional or scientist, 6 or 25.0% were in education.
, there were 24 workers who commuted into the municipality and 197 workers who commuted away. The municipality is a net exporter of workers, with about 8.2 workers leaving the municipality for every one entering. Of the working population, 10.3% used public transportation to get to work, and 62.1% used a private car.
Religion
From the , 126 or 25.4% were Roman Catholic, while 209 or 42.1% belonged to the Swiss Reformed Church. Of the rest of the population, there was 1 member of an Orthodox church, and there were 76 individuals (or about 15.32% of the population) who belonged to another Christian church. There were 5 (or about 1.01% of the population) who were Islamic. 101 (or about 20.36% of the population) belonged to no church, are agnostic or atheist, and 16 individuals (or about 3.23% of the population) did not answer the question.
Education
In Essertines-sur-Rolle about 158 or (31.9%) of the population have completed non-mandatory upper secondary education, and 128 or (25.8%) have completed additional higher education (either university or a Fachhochschule). Of the 128 who completed tertiary schooling, 38.3% were Swiss men, 31.3% were Swiss women, 15.6% were non-Swiss men and 14.8% were non-Swiss women.
In the 2009/2010 school year there were a total of 116 students in the Essertines-sur-Rolle school district. In the Vaud cantonal school system, two years of non-obligatory pre-school are provided by the political districts. During the school year, the political district provided pre-school care for a total of 1,249 children of which 563 children (45.1%) received subsidized pre-school care. The canton's primary school program requires students to attend for four years. There were 79 students in the municipal primary school program. The obligatory lower secondary school program lasts for six years and there were 36 students in those schools. There was also 1 student who was home schooled or attended another non-traditional school.
, there were 28 students in Essertines-sur-Rolle who came from another municipality, while 83 residents attended schools outside the municipality.
References
Municipalities of the canton of Vaud
Cultural property of national significance in the canton of Vaud
|
Kent Union Chapel and Cemetery is a historic building and cemetery located north of Brooklyn, Iowa, United States. They are named for the Kent family who moved to Poweshiek County from Putnam County, Indiana in 1853. They acquired property near Joseph Enochs who had arrived a year earlier. He and his wife Betsey donated a parcel of land for the cemetery in 1858. Moses Kent Sr. took possession of the land around the cemetery the following year and the area became identified with the Kent family after that. By 1870 a school was built next to the cemetery, and both took the Kent name. The schoolhouse was also a community center where a variety of local functions were held, including church services and Sunday school classes. Because of a reorganization of the county's public schools, it was relocated a mile to the northeast in 1907. The following year the Kent Cemetery Aid Society was established by area women. They were Protestants, Catholics, and some claimed no religious affiliation. They decided to replace the schoolhouse with a union chapel. They signed a 50-year lease for the land and held a variety of fundraisers to raise the money to build the chapel. Many Brooklyn businesses donated materials for the project. It was dedicated on May 23, 1909. The chapel and cemetery was listed on the National Register of Historic Places in 2009.
References
External links
Religious buildings and structures completed in 1909
Neoclassical architecture in Iowa
Chapels in the United States
Buildings and structures in Poweshiek County, Iowa
National Register of Historic Places in Poweshiek County, Iowa
Properties of religious function on the National Register of Historic Places in Iowa
Cemeteries on the National Register of Historic Places in Iowa
Neoclassical church buildings in the United States
|
The Microbotryomycetes are a class of fungi in the subdivision Pucciniomycotina of the Basidiomycota. The class currently contains eight orders, plus three additional, unassigned families (Chrysozymaceae, Colacogloeaceae, and Mycogloiocolacaceae), plus seven additional, unassigned genera (Oberwinklerozyma, Pseudohyphozyma, Reniforma, Spencerozyma, Trigonosporomyces, Vonarxula, and Yunzhangia). Many species are known only from their yeast states. Species with hyphal states typically produce auricularioid (laterally septate) basidia and are often parasitic on other fungi or plants. Several species in the genera Rhodotorula and Sporobolomyces are opportunistic human pathogens.
References
Basidiomycota classes
Pucciniomycotina
Taxa named by Franz Oberwinkler
Taxa described in 2006
|
Salariopsis is a genus of freshwater fish in the family Blenniidae. It was formerly included in Salaria which now contains only marine species.
Species
Following the marine/freshwater split, three species are recognized in this genus:
Salariopsis atlantica Doadrio, Perea & Yahyaoui, 2011
Salariopsis economidisi Kottelat, 2004 (Trichonis blenny)
Salariopsis fluviatilis (Asso, 1801) (Freshwater blenny)
References
Salarinae
|
```python
# coding=utf-8
# *** WARNING: this file was generated by test. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
__all__ = ['ProviderArgs', 'Provider']
@pulumi.input_type
class ProviderArgs:
def __init__(__self__):
"""
The set of arguments for constructing a Provider resource.
"""
pass
class Provider(pulumi.ProviderResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
__props__=None):
"""
Create a MyPkg resource with the given unique name, props, and options.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: Optional[ProviderArgs] = None,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Create a MyPkg resource with the given unique name, props, and options.
:param str resource_name: The name of the resource.
:param ProviderArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(ProviderArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
__props__=None):
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = ProviderArgs.__new__(ProviderArgs)
super(Provider, __self__).__init__(
'myPkg',
resource_name,
__props__,
opts)
```
|
is a 1995 Japan-exclusive Captain Tsubasa video game developed and published by Bandai and was the final Captain Tsubasa game for the Super Famicom.
References
External links
Game Reviews at GameFAQs
Captain Tsubasa J at superfamicom.org
1995 video games
Bandai games
The Way to World Youth
Japan-exclusive video games
Super Nintendo Entertainment System games
Super Nintendo Entertainment System-only games
Video games developed in Japan
Video games set in Japan
Multiplayer and single-player video games
|
Juan Francisco Guerra Piñero (born 16 February 1987) is a Venezuelan football coach and former player who is currently the head coach of Phoenix Rising FC in the USL Championship.
Guerra was the first signing made by the Rowdies' new general manager/head coach combo of Farrukh Quraishi and Thomas Rongen. Upon signing, coach Rongen praised Guerra's ability to read the pitch, as well as his leadership skills.
Guerra was named Oakland Roots SC's new head coach on December 30, 2021.
On August 18, 2022, Oakland Roots removed Guerra from his head coaching position following allegations he was in discussions with Phoenix Rising FC, a rival club, without permission while still under contract with Oakland.
Guerra was officially announced as the new Phoenix Rising manager on August 22, 2022.
Managerial statistics
External links
Tampa Bay Rowdies official profile
Notes
References
1987 births
Living people
Footballers from Caracas
Venezuelan men's footballers
Men's association football midfielders
FIU Panthers men's soccer players
Brooklyn Knights players
Monagas S.C. players
Caracas FC players
UD Las Palmas players
Carabobo F.C. players
Asociación Civil Deportivo Lara players
Tampa Bay Rowdies players
Indy Eleven players
Venezuela men's international footballers
Venezuelan expatriate men's footballers
Expatriate men's soccer players in the United States
Expatriate men's footballers in Spain
USL League Two players
North American Soccer League (2011–2017) players
USL Championship coaches
USL Championship players
Indy Eleven coaches
Venezuelan expatriate sportspeople in the United States
Venezuelan expatriate sportspeople in Spain
Phoenix Rising FC coaches
Oakland Roots SC coaches
|
```javascript
/*jshint eqeqeq:false */
/*global jQuery */
(function($){
/*
* jqGrid common function
* Tony Tomov tony@trirand.com
* path_to_url
* Dual licensed under the MIT and GPL licenses:
* path_to_url
* path_to_url
*/
"use strict";
$.extend($.jgrid,{
// Modal functions
showModal : function(h) {
h.w.show();
},
closeModal : function(h) {
h.w.hide().attr("aria-hidden","true");
if(h.o) {h.o.remove();}
},
hideModal : function (selector,o) {
o = $.extend({jqm : true, gb :''}, o || {});
if(o.onClose) {
var oncret = o.gb && typeof o.gb === "string" && o.gb.substr(0,6) === "#gbox_" ? o.onClose.call($("#" + o.gb.substr(6))[0], selector) : o.onClose(selector);
if (typeof oncret === 'boolean' && !oncret ) { return; }
}
if ($.fn.jqm && o.jqm === true) {
$(selector).attr("aria-hidden","true").jqmHide();
} else {
if(o.gb !== '') {
try {$(".jqgrid-overlay:first",o.gb).hide();} catch (e){}
}
$(selector).hide().attr("aria-hidden","true");
}
},
//Helper functions
findPos : function(obj) {
var curleft = 0, curtop = 0;
if (obj.offsetParent) {
do {
curleft += obj.offsetLeft;
curtop += obj.offsetTop;
} while (obj = obj.offsetParent);
//do not change obj == obj.offsetParent
}
return [curleft,curtop];
},
createModal : function(aIDs, content, p, insertSelector, posSelector, appendsel, css) {
p = $.extend(true, {}, $.jgrid.jqModal || {}, p);
var mw = document.createElement('div'), rtlsup, self = this;
css = $.extend({}, css || {});
rtlsup = $(p.gbox).attr("dir") === "rtl" ? true : false;
mw.className= "ui-widget ui-widget-content ui-corner-all ui-jqdialog";
mw.id = aIDs.themodal;
var mh = document.createElement('div');
mh.className = "ui-jqdialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix";
mh.id = aIDs.modalhead;
$(mh).append("<span class='ui-jqdialog-title'>"+p.caption+"</span>");
var ahr= $("<a href='javascript:void(0)' class='ui-jqdialog-titlebar-close ui-corner-all'></a>")
.hover(function(){ahr.addClass('ui-state-hover');},
function(){ahr.removeClass('ui-state-hover');})
.append("<span class='ui-icon ui-icon-closethick'></span>");
$(mh).append(ahr);
if(rtlsup) {
mw.dir = "rtl";
$(".ui-jqdialog-title",mh).css("float","right");
$(".ui-jqdialog-titlebar-close",mh).css("left",0.3+"em");
} else {
mw.dir = "ltr";
$(".ui-jqdialog-title",mh).css("float","left");
$(".ui-jqdialog-titlebar-close",mh).css("right",0.3+"em");
}
var mc = document.createElement('div');
$(mc).addClass("ui-jqdialog-content ui-widget-content").attr("id",aIDs.modalcontent);
$(mc).append(content);
mw.appendChild(mc);
$(mw).prepend(mh);
if(appendsel===true) { $('body').append(mw); } //append as first child in body -for alert dialog
else if (typeof appendsel === "string") {
$(appendsel).append(mw);
} else {$(mw).insertBefore(insertSelector);}
$(mw).css(css);
if(p.jqModal === undefined) {p.jqModal = true;} // internal use
var coord = {};
if ( $.fn.jqm && p.jqModal === true) {
if(p.left ===0 && p.top===0 && p.overlay) {
var pos = [];
pos = $.jgrid.findPos(posSelector);
p.left = pos[0] + 4;
p.top = pos[1] + 4;
}
coord.top = p.top+"px";
coord.left = p.left;
} else if(p.left !==0 || p.top!==0) {
coord.left = p.left;
coord.top = p.top+"px";
}
$("a.ui-jqdialog-titlebar-close",mh).click(function(){
var oncm = $("#"+$.jgrid.jqID(aIDs.themodal)).data("onClose") || p.onClose;
var gboxclose = $("#"+$.jgrid.jqID(aIDs.themodal)).data("gbox") || p.gbox;
self.hideModal("#"+$.jgrid.jqID(aIDs.themodal),{gb:gboxclose,jqm:p.jqModal,onClose:oncm});
return false;
});
if (p.width === 0 || !p.width) {p.width = 300;}
if(p.height === 0 || !p.height) {p.height =200;}
if(!p.zIndex) {
var parentZ = $(insertSelector).parents("*[role=dialog]").filter(':first').css("z-index");
if(parentZ) {
p.zIndex = parseInt(parentZ,10)+2;
} else {
p.zIndex = 950;
}
}
var rtlt = 0;
if( rtlsup && coord.left && !appendsel) {
rtlt = $(p.gbox).width()- (!isNaN(p.width) ? parseInt(p.width,10) :0) - 8; // to do
// just in case
coord.left = parseInt(coord.left,10) + parseInt(rtlt,10);
}
if(coord.left) { coord.left += "px"; }
$(mw).css($.extend({
width: isNaN(p.width) ? "auto": p.width+"px",
height:isNaN(p.height) ? "auto" : p.height + "px",
zIndex:p.zIndex,
overflow: 'hidden'
},coord))
.attr({tabIndex: "-1","role":"dialog","aria-labelledby":aIDs.modalhead,"aria-hidden":"true"});
if(p.drag === undefined) { p.drag=true;}
if(p.resize === undefined) {p.resize=true;}
if (p.drag) {
$(mh).css('cursor','move');
if($.fn.jqDrag) {
$(mw).jqDrag(mh);
} else {
try {
$(mw).draggable({handle: $("#"+$.jgrid.jqID(mh.id))});
} catch (e) {}
}
}
if(p.resize) {
if($.fn.jqResize) {
$(mw).append("<div class='jqResize ui-resizable-handle ui-resizable-se ui-icon ui-icon-gripsmall-diagonal-se'></div>");
$("#"+$.jgrid.jqID(aIDs.themodal)).jqResize(".jqResize",aIDs.scrollelm ? "#"+$.jgrid.jqID(aIDs.scrollelm) : false);
} else {
try {
$(mw).resizable({handles: 'se, sw',alsoResize: aIDs.scrollelm ? "#"+$.jgrid.jqID(aIDs.scrollelm) : false});
} catch (r) {}
}
}
if(p.closeOnEscape === true){
$(mw).keydown( function( e ) {
if( e.which == 27 ) {
var cone = $("#"+$.jgrid.jqID(aIDs.themodal)).data("onClose") || p.onClose;
self.hideModal("#"+$.jgrid.jqID(aIDs.themodal),{gb:p.gbox,jqm:p.jqModal,onClose: cone});
}
});
}
},
viewModal : function (selector,o){
o = $.extend({
toTop: true,
overlay: 10,
modal: false,
overlayClass : 'ui-widget-overlay',
onShow: $.jgrid.showModal,
onHide: $.jgrid.closeModal,
gbox: '',
jqm : true,
jqM : true
}, o || {});
if ($.fn.jqm && o.jqm === true) {
if(o.jqM) { $(selector).attr("aria-hidden","false").jqm(o).jqmShow(); }
else {$(selector).attr("aria-hidden","false").jqmShow();}
} else {
if(o.gbox !== '') {
$(".jqgrid-overlay:first",o.gbox).show();
$(selector).data("gbox",o.gbox);
}
$(selector).show().attr("aria-hidden","false");
try{$(':input:visible',selector)[0].focus();}catch(_){}
}
},
info_dialog : function(caption, content,c_b, modalopt) {
var mopt = {
width:290,
height:'auto',
dataheight: 'auto',
drag: true,
resize: false,
left:250,
top:170,
zIndex : 1000,
jqModal : true,
modal : false,
closeOnEscape : true,
align: 'center',
buttonalign : 'center',
buttons : []
// {text:'textbutt', id:"buttid", onClick : function(){...}}
// if the id is not provided we set it like info_button_+ the index in the array - i.e info_button_0,info_button_1...
};
$.extend(true, mopt, $.jgrid.jqModal || {}, {caption:"<b>"+caption+"</b>"}, modalopt || {});
var jm = mopt.jqModal, self = this;
if($.fn.jqm && !jm) { jm = false; }
// in case there is no jqModal
var buttstr ="", i;
if(mopt.buttons.length > 0) {
for(i=0;i<mopt.buttons.length;i++) {
if(mopt.buttons[i].id === undefined) { mopt.buttons[i].id = "info_button_"+i; }
buttstr += "<a href='javascript:void(0)' id='"+mopt.buttons[i].id+"' class='fm-button ui-state-default ui-corner-all'>"+mopt.buttons[i].text+"</a>";
}
}
var dh = isNaN(mopt.dataheight) ? mopt.dataheight : mopt.dataheight+"px",
cn = "text-align:"+mopt.align+";";
var cnt = "<div id='info_id'>";
cnt += "<div id='infocnt' style='margin:0px;padding-bottom:1em;width:100%;overflow:auto;position:relative;height:"+dh+";"+cn+"'>"+content+"</div>";
cnt += c_b ? "<div class='ui-widget-content ui-helper-clearfix' style='text-align:"+mopt.buttonalign+";padding-bottom:0.8em;padding-top:0.5em;background-image: none;border-width: 1px 0 0 0;'><a href='javascript:void(0)' id='closedialog' class='fm-button ui-state-default ui-corner-all'>"+c_b+"</a>"+buttstr+"</div>" :
buttstr !== "" ? "<div class='ui-widget-content ui-helper-clearfix' style='text-align:"+mopt.buttonalign+";padding-bottom:0.8em;padding-top:0.5em;background-image: none;border-width: 1px 0 0 0;'>"+buttstr+"</div>" : "";
cnt += "</div>";
try {
if($("#info_dialog").attr("aria-hidden") === "false") {
$.jgrid.hideModal("#info_dialog",{jqm:jm});
}
$("#info_dialog").remove();
} catch (e){}
$.jgrid.createModal({
themodal:'info_dialog',
modalhead:'info_head',
modalcontent:'info_content',
scrollelm: 'infocnt'},
cnt,
mopt,
'','',true
);
// attach onclick after inserting into the dom
if(buttstr) {
$.each(mopt.buttons,function(i){
$("#"+$.jgrid.jqID(this.id),"#info_id").bind('click',function(){mopt.buttons[i].onClick.call($("#info_dialog")); return false;});
});
}
$("#closedialog", "#info_id").click(function(){
self.hideModal("#info_dialog",{
jqm:jm,
onClose: $("#info_dialog").data("onClose") || mopt.onClose,
gb: $("#info_dialog").data("gbox") || mopt.gbox
});
return false;
});
$(".fm-button","#info_dialog").hover(
function(){$(this).addClass('ui-state-hover');},
function(){$(this).removeClass('ui-state-hover');}
);
if($.isFunction(mopt.beforeOpen) ) { mopt.beforeOpen(); }
$.jgrid.viewModal("#info_dialog",{
onHide: function(h) {
h.w.hide().remove();
if(h.o) { h.o.remove(); }
},
modal :mopt.modal,
jqm:jm
});
if($.isFunction(mopt.afterOpen) ) { mopt.afterOpen(); }
try{ $("#info_dialog").focus();} catch (m){}
},
bindEv: function (el, opt) {
var $t = this;
if($.isFunction(opt.dataInit)) {
opt.dataInit.call($t,el);
}
if(opt.dataEvents) {
$.each(opt.dataEvents, function() {
if (this.data !== undefined) {
$(el).bind(this.type, this.data, this.fn);
} else {
$(el).bind(this.type, this.fn);
}
});
}
},
// Form Functions
createEl : function(eltype,options,vl,autowidth, ajaxso) {
var elem = "", $t = this;
function setAttributes(elm, atr, exl ) {
var exclude = ['dataInit','dataEvents','dataUrl', 'buildSelect','sopt', 'searchhidden', 'defaultValue', 'attr', 'custom_element', 'custom_value'];
if(exl !== undefined && $.isArray(exl)) {
$.merge(exclude, exl);
}
$.each(atr, function(key, value){
if($.inArray(key, exclude) === -1) {
$(elm).attr(key,value);
}
});
if(!atr.hasOwnProperty('id')) {
$(elm).attr('id', $.jgrid.randId());
}
}
switch (eltype)
{
case "textarea" :
elem = document.createElement("textarea");
if(autowidth) {
if(!options.cols) { $(elem).css({width:"98%"});}
} else if (!options.cols) { options.cols = 20; }
if(!options.rows) { options.rows = 2; }
if(vl===' ' || vl===' ' || (vl.length===1 && vl.charCodeAt(0)===160)) {vl="";}
elem.value = vl;
setAttributes(elem, options);
$(elem).attr({"role":"textbox","multiline":"true"});
break;
case "checkbox" : //what code for simple checkbox
elem = document.createElement("input");
elem.type = "checkbox";
if( !options.value ) {
var vl1 = vl.toLowerCase();
if(vl1.search(/(false|f|0|no|n|off|undefined)/i)<0 && vl1!=="") {
elem.checked=true;
elem.defaultChecked=true;
elem.value = vl;
} else {
elem.value = "on";
}
$(elem).attr("offval","off");
} else {
var cbval = options.value.split(":");
if(vl === cbval[0]) {
elem.checked=true;
elem.defaultChecked=true;
}
elem.value = cbval[0];
$(elem).attr("offval",cbval[1]);
}
setAttributes(elem, options, ['value']);
$(elem).attr("role","checkbox");
break;
case "select" :
elem = document.createElement("select");
elem.setAttribute("role","select");
var msl, ovm = [];
if(options.multiple===true) {
msl = true;
elem.multiple="multiple";
$(elem).attr("aria-multiselectable","true");
} else { msl = false; }
if(options.dataUrl !== undefined) {
var rowid = options.name ? String(options.id).substring(0, String(options.id).length - String(options.name).length - 1) : String(options.id),
postData = options.postData || ajaxso.postData;
if ($t.p && $t.p.idPrefix) {
rowid = $.jgrid.stripPref($t.p.idPrefix, rowid);
} else {
postData = undefined; // don't use postData for searching from jqFilter. One can implement the feature in the future if required.
}
$.ajax($.extend({
url: options.dataUrl,
type : "GET",
dataType: "html",
data: $.isFunction(postData) ? postData.call($t, rowid, vl, String(options.name)) : postData,
context: {elem:elem, options:options, vl:vl},
success: function(data){
var ovm = [], elem = this.elem, vl = this.vl,
options = $.extend({},this.options),
msl = options.multiple===true,
a = $.isFunction(options.buildSelect) ? options.buildSelect.call($t,data) : data;
if(typeof a === 'string') {
a = $( $.trim( a ) ).html();
}
if(a) {
$(elem).append(a);
setAttributes(elem, options);
if(options.size === undefined) { options.size = msl ? 3 : 1;}
if(msl) {
ovm = vl.split(",");
ovm = $.map(ovm,function(n){return $.trim(n);});
} else {
ovm[0] = $.trim(vl);
}
//$(elem).attr(options);
setTimeout(function(){
$("option",elem).each(function(i){
//if(i===0) { this.selected = ""; }
// fix IE8/IE7 problem with selecting of the first item on multiple=true
if (i === 0 && elem.multiple) { this.selected = false; }
$(this).attr("role","option");
if($.inArray($.trim($(this).text()),ovm) > -1 || $.inArray($.trim($(this).val()),ovm) > -1 ) {
this.selected= "selected";
}
});
},0);
}
}
},ajaxso || {}));
} else if(options.value) {
var i;
if(options.size === undefined) {
options.size = msl ? 3 : 1;
}
if(msl) {
ovm = vl.split(",");
ovm = $.map(ovm,function(n){return $.trim(n);});
}
if(typeof options.value === 'function') { options.value = options.value(); }
var so,sv, ov,
sep = options.separator === undefined ? ":" : options.separator,
delim = options.delimiter === undefined ? ";" : options.delimiter;
if(typeof options.value === 'string') {
so = options.value.split(delim);
for(i=0; i<so.length;i++){
sv = so[i].split(sep);
if(sv.length > 2 ) {
sv[1] = $.map(sv,function(n,ii){if(ii>0) { return n;} }).join(sep);
}
ov = document.createElement("option");
ov.setAttribute("role","option");
ov.value = sv[0]; ov.innerHTML = sv[1];
elem.appendChild(ov);
if (!msl && ($.trim(sv[0]) === $.trim(vl) || $.trim(sv[1]) === $.trim(vl))) { ov.selected ="selected"; }
if (msl && ($.inArray($.trim(sv[1]), ovm)>-1 || $.inArray($.trim(sv[0]), ovm)>-1)) {ov.selected ="selected";}
}
} else if (typeof options.value === 'object') {
var oSv = options.value, key;
for (key in oSv) {
if (oSv.hasOwnProperty(key ) ){
ov = document.createElement("option");
ov.setAttribute("role","option");
ov.value = key; ov.innerHTML = oSv[key];
elem.appendChild(ov);
if (!msl && ( $.trim(key) === $.trim(vl) || $.trim(oSv[key]) === $.trim(vl)) ) { ov.selected ="selected"; }
if (msl && ($.inArray($.trim(oSv[key]),ovm)>-1 || $.inArray($.trim(key),ovm)>-1)) { ov.selected ="selected"; }
}
}
}
setAttributes(elem, options, ['value']);
}
break;
case "text" :
case "password" :
case "button" :
var role;
if(eltype==="button") { role = "button"; }
else { role = "textbox"; }
elem = document.createElement("input");
elem.type = eltype;
elem.value = vl;
setAttributes(elem, options);
if(eltype !== "button"){
if(autowidth) {
if(!options.size) { $(elem).css({width:"98%"}); }
} else if (!options.size) { options.size = 20; }
}
$(elem).attr("role",role);
break;
case "image" :
case "file" :
elem = document.createElement("input");
elem.type = eltype;
setAttributes(elem, options);
break;
case "custom" :
elem = document.createElement("span");
try {
if($.isFunction(options.custom_element)) {
var celm = options.custom_element.call($t,vl,options);
if(celm) {
celm = $(celm).addClass("customelement").attr({id:options.id,name:options.name});
$(elem).empty().append(celm);
} else {
throw "e2";
}
} else {
throw "e1";
}
} catch (e) {
if (e==="e1") { $.jgrid.info_dialog($.jgrid.errors.errcap,"function 'custom_element' "+$.jgrid.edit.msg.nodefined, $.jgrid.edit.bClose);}
if (e==="e2") { $.jgrid.info_dialog($.jgrid.errors.errcap,"function 'custom_element' "+$.jgrid.edit.msg.novalue,$.jgrid.edit.bClose);}
else { $.jgrid.info_dialog($.jgrid.errors.errcap,typeof e==="string"?e:e.message,$.jgrid.edit.bClose); }
}
break;
}
return elem;
},
// Date Validation Javascript
checkDate : function (format, date) {
var daysInFebruary = function(year){
// February has 29 days in any year evenly divisible by four,
// EXCEPT for centurial years which are not also divisible by 400.
return (((year % 4 === 0) && ( year % 100 !== 0 || (year % 400 === 0))) ? 29 : 28 );
},
tsp = {}, sep;
format = format.toLowerCase();
//we search for /,-,. for the date separator
if(format.indexOf("/") !== -1) {
sep = "/";
} else if(format.indexOf("-") !== -1) {
sep = "-";
} else if(format.indexOf(".") !== -1) {
sep = ".";
} else {
sep = "/";
}
format = format.split(sep);
date = date.split(sep);
if (date.length !== 3) { return false; }
var j=-1,yln, dln=-1, mln=-1, i;
for(i=0;i<format.length;i++){
var dv = isNaN(date[i]) ? 0 : parseInt(date[i],10);
tsp[format[i]] = dv;
yln = format[i];
if(yln.indexOf("y") !== -1) { j=i; }
if(yln.indexOf("m") !== -1) { mln=i; }
if(yln.indexOf("d") !== -1) { dln=i; }
}
if (format[j] === "y" || format[j] === "yyyy") {
yln=4;
} else if(format[j] ==="yy"){
yln = 2;
} else {
yln = -1;
}
var daysInMonth = [0,31,29,31,30,31,30,31,31,30,31,30,31],
strDate;
if (j === -1) {
return false;
}
strDate = tsp[format[j]].toString();
if(yln === 2 && strDate.length === 1) {yln = 1;}
if (strDate.length !== yln || (tsp[format[j]]===0 && date[j]!=="00")){
return false;
}
if(mln === -1) {
return false;
}
strDate = tsp[format[mln]].toString();
if (strDate.length<1 || tsp[format[mln]]<1 || tsp[format[mln]]>12){
return false;
}
if(dln === -1) {
return false;
}
strDate = tsp[format[dln]].toString();
if (strDate.length<1 || tsp[format[dln]]<1 || tsp[format[dln]]>31 || (tsp[format[mln]]===2 && tsp[format[dln]]>daysInFebruary(tsp[format[j]])) || tsp[format[dln]] > daysInMonth[tsp[format[mln]]]){
return false;
}
return true;
},
isEmpty : function(val)
{
if (val.match(/^\s+$/) || val === "") {
return true;
}
return false;
},
checkTime : function(time){
// checks only hh:ss (and optional am/pm)
var re = /^(\d{1,2}):(\d{2})([apAP][Mm])?$/,regs;
if(!$.jgrid.isEmpty(time))
{
regs = time.match(re);
if(regs) {
if(regs[3]) {
if(regs[1] < 1 || regs[1] > 12) { return false; }
} else {
if(regs[1] > 23) { return false; }
}
if(regs[2] > 59) {
return false;
}
} else {
return false;
}
}
return true;
},
checkValues : function(val, valref, customobject, nam) {
var edtrul,i, nm, dft, len, g = this, cm = g.p.colModel;
if(customobject === undefined) {
if(typeof valref==='string'){
for( i =0, len=cm.length;i<len; i++){
if(cm[i].name===valref) {
edtrul = cm[i].editrules;
valref = i;
if(cm[i].formoptions != null) { nm = cm[i].formoptions.label; }
break;
}
}
} else if(valref >=0) {
edtrul = cm[valref].editrules;
}
} else {
edtrul = customobject;
nm = nam===undefined ? "_" : nam;
}
if(edtrul) {
if(!nm) { nm = g.p.colNames != null ? g.p.colNames[valref] : cm[valref].label; }
if(edtrul.required === true) {
if( $.jgrid.isEmpty(val) ) { return [false,nm+": "+$.jgrid.edit.msg.required,""]; }
}
// force required
var rqfield = edtrul.required === false ? false : true;
if(edtrul.number === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(isNaN(val)) { return [false,nm+": "+$.jgrid.edit.msg.number,""]; }
}
}
if(edtrul.minValue !== undefined && !isNaN(edtrul.minValue)) {
if (parseFloat(val) < parseFloat(edtrul.minValue) ) { return [false,nm+": "+$.jgrid.edit.msg.minValue+" "+edtrul.minValue,""];}
}
if(edtrul.maxValue !== undefined && !isNaN(edtrul.maxValue)) {
if (parseFloat(val) > parseFloat(edtrul.maxValue) ) { return [false,nm+": "+$.jgrid.edit.msg.maxValue+" "+edtrul.maxValue,""];}
}
var filter;
if(edtrul.email === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
// taken from $ Validate plugin
filter = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i;
if(!filter.test(val)) {return [false,nm+": "+$.jgrid.edit.msg.email,""];}
}
}
if(edtrul.integer === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(isNaN(val)) { return [false,nm+": "+$.jgrid.edit.msg.integer,""]; }
if ((val % 1 !== 0) || (val.indexOf('.') !== -1)) { return [false,nm+": "+$.jgrid.edit.msg.integer,""];}
}
}
if(edtrul.date === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(cm[valref].formatoptions && cm[valref].formatoptions.newformat) {
dft = cm[valref].formatoptions.newformat;
if( $.jgrid.formatter.date.masks.hasOwnProperty(dft) ) {
dft = $.jgrid.formatter.date.masks[dft];
}
} else {
dft = cm[valref].datefmt || "Y-m-d";
}
if(!$.jgrid.checkDate (dft, val)) { return [false,nm+": "+$.jgrid.edit.msg.date+" - "+dft,""]; }
}
}
if(edtrul.time === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(!$.jgrid.checkTime (val)) { return [false,nm+": "+$.jgrid.edit.msg.date+" - hh:mm (am/pm)",""]; }
}
}
if(edtrul.url === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
filter = /^(((https?)|(ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i;
if(!filter.test(val)) {return [false,nm+": "+$.jgrid.edit.msg.url,""];}
}
}
if(edtrul.custom === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if($.isFunction(edtrul.custom_func)) {
var ret = edtrul.custom_func.call(g,val,nm,valref);
return $.isArray(ret) ? ret : [false,$.jgrid.edit.msg.customarray,""];
}
return [false,$.jgrid.edit.msg.customfcheck,""];
}
}
}
return [true,"",""];
}
});
})(jQuery);
```
|
Calotrophon hemmenorum is a species of sea snail, a marine gastropod mollusk in the family Muricidae, the murex snails or rock snails.
Description
The adult shell attains a length of 20 mm.
Distribution
This species is distributed in the Indian Ocean along Somalia.
References
Merle D., Garrigues B. & Pointier J.-P. (2011) Fossil and Recent Muricidae of the world. Part Muricinae. Hackenheim: Conchbooks. 648 pp. page(s): 196
External links
Endemic fauna of Somalia
Muricidae
Gastropods described in 1990
|
```prolog
#! /usr/bin/env perl
#
# in the file LICENSE in the source distribution or at
# path_to_url
package x86nasm;
*out=\@::out;
$::lbdecor="L\$"; # local label decoration
$nmdecor="_"; # external name decoration
$drdecor=$::mwerks?".":""; # directive decoration
$initseg="";
sub ::generic
{ my $opcode=shift;
my $tmp;
if (!$::mwerks)
{ if ($opcode =~ m/^j/o && $#_==0) # optimize jumps
{ $_[0] = "NEAR $_[0]"; }
elsif ($opcode eq "lea" && $#_==1) # wipe storage qualifier from lea
{ $_[1] =~ s/^[^\[]*\[/\[/o; }
elsif ($opcode eq "clflush" && $#_==0)
{ $_[0] =~ s/^[^\[]*\[/\[/o; }
}
&::emit($opcode,@_);
1;
}
#
# opcodes not covered by ::generic above, mostly inconsistent namings...
#
sub ::call { &::emit("call",(&::islabel($_[0]) or "$nmdecor$_[0]")); }
sub ::call_ptr { &::emit("call",@_); }
sub ::jmp_ptr { &::emit("jmp",@_); }
sub get_mem
{ my($size,$addr,$reg1,$reg2,$idx)=@_;
my($post,$ret);
if (!defined($idx) && 1*$reg2) { $idx=$reg2; $reg2=$reg1; undef $reg1; }
if ($size ne "")
{ $ret .= "$size";
$ret .= " PTR" if ($::mwerks);
$ret .= " ";
}
$ret .= "[";
$addr =~ s/^\s+//;
# prepend global references with optional underscore
$addr =~ s/^([^\+\-0-9][^\+\-]*)/::islabel($1) or "$nmdecor$1"/ige;
# put address arithmetic expression in parenthesis
$addr="($addr)" if ($addr =~ /^.+[\-\+].+$/);
if (($addr ne "") && ($addr ne 0))
{ if ($addr !~ /^-/) { $ret .= "$addr+"; }
else { $post=$addr; }
}
if ($reg2 ne "")
{ $idx!=0 or $idx=1;
$ret .= "$reg2*$idx";
$ret .= "+$reg1" if ($reg1 ne "");
}
else
{ $ret .= "$reg1"; }
$ret .= "$post]";
$ret =~ s/\+\]/]/; # in case $addr was the only argument
$ret;
}
sub ::BP { &get_mem("BYTE",@_); }
sub ::DWP { &get_mem("DWORD",@_); }
sub ::WP { &get_mem("WORD",@_); }
sub ::QWP { &get_mem("",@_); }
sub ::BC { (($::mwerks)?"":"BYTE ")."@_"; }
sub ::DWC { (($::mwerks)?"":"DWORD ")."@_"; }
sub ::file
{ if ($::mwerks) { push(@out,".section\t.text,64\n"); }
else
{ my $tmp=<<___;
%ifidn __OUTPUT_FORMAT__,obj
section code use32 class=code align=64
%elifidn __OUTPUT_FORMAT__,win32
\$\@feat.00 equ 1
section .text code align=64
%else
section .text code
%endif
___
push(@out,$tmp);
}
}
sub ::function_begin_B
{ my $func=shift;
my $global=($func !~ /^_/);
my $begin="${::lbdecor}_${func}_begin";
$begin =~ s/^\@/./ if ($::mwerks); # the torture never stops
&::LABEL($func,$global?"$begin":"$nmdecor$func");
$func=$nmdecor.$func;
push(@out,"${drdecor}global $func\n") if ($global);
push(@out,"${drdecor}align 16\n");
push(@out,"$func:\n");
push(@out,"$begin:\n") if ($global);
$::stack=4;
}
sub ::function_end_B
{ $::stack=0;
&::wipe_labels();
}
sub ::file_end
{ if (grep {/\b${nmdecor}OPENSSL_ia32cap_P\b/i} @out)
{ my $comm=<<___;
${drdecor}segment .bss
${drdecor}common ${nmdecor}OPENSSL_ia32cap_P 16
___
# comment out OPENSSL_ia32cap_P declarations
grep {s/(^extern\s+${nmdecor}OPENSSL_ia32cap_P)/\;$1/} @out;
push (@out,$comm)
}
push (@out,$initseg) if ($initseg);
}
sub ::comment { foreach (@_) { push(@out,"\t; $_\n"); } }
sub ::external_label
{ foreach(@_)
{ push(@out,"${drdecor}extern\t".&::LABEL($_,$nmdecor.$_)."\n"); }
}
sub ::public_label
{ push(@out,"${drdecor}global\t".&::LABEL($_[0],$nmdecor.$_[0])."\n"); }
sub ::data_byte
{ push(@out,(($::mwerks)?".byte\t":"db\t").join(',',@_)."\n"); }
sub ::data_short
{ push(@out,(($::mwerks)?".word\t":"dw\t").join(',',@_)."\n"); }
sub ::data_word
{ push(@out,(($::mwerks)?".long\t":"dd\t").join(',',@_)."\n"); }
sub ::align
{ push(@out,"${drdecor}align\t$_[0]\n"); }
sub ::picmeup
{ my($dst,$sym)=@_;
&::lea($dst,&::DWP($sym));
}
sub ::initseg
{ my $f=$nmdecor.shift;
if ($::win32)
{ $initseg=<<___;
segment .CRT\$XCU data align=4
extern $f
dd $f
___
}
}
sub ::dataseg
{ if ($mwerks) { push(@out,".section\t.data,4\n"); }
else { push(@out,"section\t.data align=4\n"); }
}
sub ::safeseh
{ my $nm=shift;
push(@out,"%if __NASM_VERSION_ID__ >= 0x02030000\n");
push(@out,"safeseh ".&::LABEL($nm,$nmdecor.$nm)."\n");
push(@out,"%endif\n");
}
sub ::preprocessor_ifdef
{ my($define)=@_;
push(@out,"%ifdef ${define}\n");
}
sub ::preprocessor_endif
{ push(@out,"%endif\n"); }
1;
```
|
```javascript
var baseIsSet = require('./_baseIsSet'),
baseUnary = require('./_baseUnary'),
nodeUtil = require('./_nodeUtil');
/* Node.js helper references. */
var nodeIsSet = nodeUtil && nodeUtil.isSet;
/**
* Checks if `value` is classified as a `Set` object.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a set, else `false`.
* @example
*
* _.isSet(new Set);
* // => true
*
* _.isSet(new WeakSet);
* // => false
*/
var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
module.exports = isSet;
```
|
Mamadou Traoré may refer to:
Mamadou Traoré (murderer) (born 1973), Senegalese-born French serial rapist and murderer
Mamadou Traoré (footballer, born 1994), Malian footballer
Mamadou Traoré (footballer, born 2002), Malian footballer
Mamadou Lamine Traoré (1947–2007), Malian politician
Mamadou Namory Traoré, Malian politician
|
```scilab
\S[300]\s[80]OUT=$(smenu -k -U "b|d" -N "a|b" -c t0005.in)
\S[300]\s[200]\r
\S[300]\s[80]echo ":$\s[80]OUT:"
exit 0
```
|
```hcl
terraform {
required_version = ">= 1.0.0, < 2.0.0"
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 4.0"
}
}
}
resource "aws_launch_configuration" "example" {
image_id = var.ami
instance_type = var.instance_type
security_groups = [aws_security_group.instance.id]
user_data = var.user_data
# Required when using a launch configuration with an auto scaling group.
lifecycle {
create_before_destroy = true
}
}
resource "aws_autoscaling_group" "example" {
name = var.cluster_name
launch_configuration = aws_launch_configuration.example.name
vpc_zone_identifier = var.subnet_ids
# Configure integrations with a load balancer
target_group_arns = var.target_group_arns
health_check_type = var.health_check_type
min_size = var.min_size
max_size = var.max_size
# Use instance refresh to roll out changes to the ASG
instance_refresh {
strategy = "Rolling"
preferences {
min_healthy_percentage = 50
}
}
tag {
key = "Name"
value = var.cluster_name
propagate_at_launch = true
}
dynamic "tag" {
for_each = {
for key, value in var.custom_tags:
key => upper(value)
if key != "Name"
}
content {
key = tag.key
value = tag.value
propagate_at_launch = true
}
}
}
resource "aws_autoscaling_schedule" "scale_out_during_business_hours" {
count = var.enable_autoscaling ? 1 : 0
scheduled_action_name = "${var.cluster_name}-scale-out-during-business-hours"
min_size = 2
max_size = 10
desired_capacity = 10
recurrence = "0 9 * * *"
autoscaling_group_name = aws_autoscaling_group.example.name
}
resource "aws_autoscaling_schedule" "scale_in_at_night" {
count = var.enable_autoscaling ? 1 : 0
scheduled_action_name = "${var.cluster_name}-scale-in-at-night"
min_size = 2
max_size = 10
desired_capacity = 2
recurrence = "0 17 * * *"
autoscaling_group_name = aws_autoscaling_group.example.name
}
resource "aws_security_group" "instance" {
name = "${var.cluster_name}-instance"
}
resource "aws_security_group_rule" "allow_server_http_inbound" {
type = "ingress"
security_group_id = aws_security_group.instance.id
from_port = var.server_port
to_port = var.server_port
protocol = local.tcp_protocol
cidr_blocks = local.all_ips
}
resource "aws_cloudwatch_metric_alarm" "high_cpu_utilization" {
alarm_name = "${var.cluster_name}-high-cpu-utilization"
namespace = "AWS/EC2"
metric_name = "CPUUtilization"
dimensions = {
AutoScalingGroupName = aws_autoscaling_group.example.name
}
comparison_operator = "GreaterThanThreshold"
evaluation_periods = 1
period = 300
statistic = "Average"
threshold = 90
unit = "Percent"
}
resource "aws_cloudwatch_metric_alarm" "low_cpu_credit_balance" {
count = format("%.1s", var.instance_type) == "t" ? 1 : 0
alarm_name = "${var.cluster_name}-low-cpu-credit-balance"
namespace = "AWS/EC2"
metric_name = "CPUCreditBalance"
dimensions = {
AutoScalingGroupName = aws_autoscaling_group.example.name
}
comparison_operator = "LessThanThreshold"
evaluation_periods = 1
period = 300
statistic = "Minimum"
threshold = 10
unit = "Count"
}
locals {
tcp_protocol = "tcp"
all_ips = ["0.0.0.0/0"]
}
```
|
, (May 27, 1868 – March 27, 1904) was a career officer in the Imperial Japanese Navy. He commanded the cargo vessel Fukui Maru during the Battle of Port Arthur in the Russo-Japanese War. The ship was hit by coastal artillery, and despite being wounded, he drowned while looking for other survivors of the sinking, going down with his ship. His selfless sacrifice elevated him to the status of a deified national hero.
Biography
Born in what is now Taketa, Ōita, his father Hirose Shigetake was a judge, while his elder brother Hirose Katsuhiko was a rear admiral. He studied at the Imperial Japanese Naval Academy in Etajima, graduating from the 15th class in 1889. He served aboard the ironclad warship during the First Sino-Japanese War and saw action at the Battle of Yalu River on September 17, 1894.
From 1897 to 1899 Hirose was sent to study in Russia and stayed on as the resident military attaché in St. Petersburg until 1902. During his time as attaché he went on a tour of Germany, France and Great Britain. He was promoted to lieutenant commander in 1900.
When Japan went to war against Russia in the Russo-Japanese War in 1904, Hirose was assigned to the battleship as torpedo officer. However, during the Battle of Port Arthur he volunteered to command the Fukui Maru, an old cargo vessel which was used as a blockship during the second unsuccessful attempt to blockade the entrance to Port Arthur on the night of March 26. As the ship was about to reach the channel, it was hit by Russian coastal artillery and exploded. Hirose was fatally wounded while searching for survivors and went down with the ship.
Because of his heroism, he was posthumously promoted to commander, and deified as a "martial spirit" (軍神 gunshin), and a Shinto shrine was built in his honor in Taketa, Oita. A statue of him was also erected outside the Manseibashi Railway Station in Tokyo until 1947.
Cultural references
Song of Commander Hirose was a Monbusho Shoka, or a song authorized by the Ministry of Education, a predecessor of the current Ministry of Education, Culture, Sports, Science and Technology.
Hirose was the subject of the epic historical novel Saka no Ue no Kumo, by author Ryōtarō Shiba. The novel became the basis for the NHK television drama Saka no Ue no Kumo, in which Hirose portrayed by ex-Olympic swimmer and actor Takahiro Fujimoto.
See also
Tachibana Shūta - the Imperial Japanese Army equivalent to Hirose, who was also deified as a gunshin.
References
Connaughton, R.M (1988). The War of the Rising Sun and the Tumbling Bear—A Military History of the Russo-Japanese War 1904–5, London, .
Jukes, Geoffry. The Russo-Japanese War 1904–1905. Osprey Essential Histories. (2002). .
External links
Portrait of Takeo Hirose
Short biography of Takeo Hirose
art random - 人生のセイムスケール - age 35-: Takeo Hirose (in Japanese)
1868 births
1904 deaths
Japanese military personnel of the First Sino-Japanese War
Japanese military personnel of the Russo-Japanese War
People from Ōita Prefecture
Imperial Japanese Navy officers
Japanese military personnel killed in the Russo-Japanese War
Captains who went down with the ship
Deified Japanese people
|
Montmorency Township is located in Whiteside County, Illinois. As of the 2010 census, its population was 2,612 and it contained 1,027 housing units. It is located south of the city of Rock Falls.
Geography
According to the 2010 census, the township has a total area of , of which (or 99.86%) is land and (or 0.14%) is water.
Demographics
References
External links
City-data.com
Whiteside County Official Site
Townships in Whiteside County, Illinois
Townships in Illinois
|
The 2008–09 season was the 98th season in Hajduk Split's history and their eighteenth in the Prva HNL. Their 5th-place finish in the 2007–08 season meant it was their 18th successive season playing in the Prva HNL.
First-team squad
Squad at end of season
Competitions
Overall record
Prva HNL
Classification
Results summary
Results by round
Results by opponent
Source: 2008–09 Croatian First Football League article
Matches
Prva HNL
Source: HRnogomet.com
Croatian Football Cup
Source: HRnogomet.com
UEFA Cup
First qualifying round
Second qualifying round
Source: uefa.com
Player seasonal records
Competitive matches only. Updated to games played 31 May 2009.
Top scorers
Source: Competitive matches
See also
2008–09 Croatian First Football League
2008–09 Croatian Football Cup
References
External links
2008–09 Prva HNL at HRnogomet.com
2008–09 Croatian Cup at HRnogomet.com
2008–09 UEFA Cup at rsssf.com
Hajduk Split
HNK Hajduk Split seasons
|
Stephen Niblett D.D. (1697–1766) was an English academic administrator at the University of Oxford.
Niblett was elected Warden (head) of All Souls College, Oxford in 1726, a post he held until 1766.
During his time as Warden of All Souls College, he was also Vice-Chancellor of Oxford University from 1735 until 1738.
A monument to Niblett and his wife Elizabeth was erected at All Souls College, Oxford in 1766, being sculpted by Nicholas Read.
References
1697 births
1766 deaths
Wardens of All Souls College, Oxford
Vice-Chancellors of the University of Oxford
|
Konstantin Konstantinovich Markov (; 20 May 1905, Vyborg – 18 September 1980, Moscow) was a Soviet geomorphologist and Quaternary geologist. As a geomorphologist Markov theorized on planation surfaces. His geographical research of arid areas outside the Soviet Union led to publications on Morocco, Lake Chad and the Dead Sea. Markov was professor at the Moscow State University.
Markov created the concept of geomorphological levels. In this idealization geomorphic processes on Earth are distributed vertically in the form of concentric spheres, this if there is no tectonic disturbances. The in each sphere a specific kind of process dominates. At sea level abrasion and accretion will dominate landscape, surfaces above this level would be dominated by erosion and peneplanation. Further up mountain tops would form their level.
Cape Markov in Antarctica is named after him.
References
1905 births
1980 deaths
20th-century geographers
20th-century geologists
Scientists from Vyborg
Academic staff of Moscow State University
Full Members of the USSR Academy of Sciences
Saint Petersburg State University alumni
Communist Party of the Soviet Union members
Recipients of the Order of the October Revolution
Recipients of the Order of the Red Banner of Labour
Recipients of the USSR State Prize
Quaternary geologists
Soviet geographers
Soviet geologists
Soviet geomorphologists
Soviet paleogeographers
Burials at Kuntsevo Cemetery
|
```smalltalk
using UnityEngine;
namespace MyBox
{
public static class MyLayers
{
// Toggle layers lock
//Tools.lockedLayers = 1 << LayerMask.NameToLayer("LayerName"); // Replace the whole value of lockedLayers.
//Tools.lockedLayers |= 1 << LayerMask.NameToLayer("LayerName"); // Add a value to lockedLayers.
//Tools.lockedLayers &= ~(1 << LayerMask.NameToLayer("LayerName")); // Remove a value from lockedLayers.
//Tools.lockedLayers ^= 1 << LayerMask.NameToLayer("LayerName")); // Toggle a value in lockedLayers.
public static LayerMask ToLayerMask(int layer)
{
return 1 << layer;
}
public static bool LayerInMask(this LayerMask mask, int layer)
{
return ((1 << layer) & mask) != 0;
}
}
}
```
|
David George Wilson (born 9 April 1985) is a former English rugby union player. A tighthead prop, he played for Newcastle Falcons and Bath and represented England at two World Cups.
Club career
Wilson made his debut for Newcastle Falcons in a 2003 League fixture against Bath Rugby. After struggling to displace teammate Carl Hayman, Wilson joined Bath for the 2009–10 season. On 22 May 2014 Wilson started for the side that lost to Northampton Saints in the final of the EPCR Challenge Cup at Cardiff Arms Park. The following season saw Bath finish runners up to Saracens in the 2015 Premiership final. He made over 100 appearances during his spell at the Rec.
In September 2016 Wilson re-signed with Newcastle Falcons. The Falcons reached the Premiership play-off stage during the 2017–18 season and Wilson played in their semi-final defeat against Exeter Chiefs. In 2019 he retired from Rugby due to injuries and is a student.
International career
Wilson represented England at the 2006 Under 21 Rugby World Championship. He made his debut for the England Saxons side that defeated Ireland A on 1 February 2008.
On 6 June 2009 Wilson made his full England debut in England's 37–15 victory over Argentina at Old Trafford. He was selected for the 2010 tour of Australia and played in the second test victory against the Wallabies to draw the series.
Wilson was a member of the side that won the 2011 Six Nations Championship. Later that year he was chosen for the 2011 Rugby World Cup and made his only appearance of the tournament during the pool stage against Romania.
New England coach Stuart Lancaster retained Wilson and in December 2012 he played in a victory over New Zealand. He scored his only international try on 15 November 2014 in a defeat against South Africa. Wilson was included in the squad for the 2015 Rugby World Cup as the hosts failed to reach the knockout phase. His only appearance of the tournament occurred during their ultimate pool fixture against Uruguay which proved to be his last cap for England.
International tries
Honours
England
Six Nations Championship: 2011
Bath
Premiership runner up: 2014–15
EPCR Challenge Cup runner up: 2013–14
References
External links
David Wilson profile at Bath Rugby
David Wilson profile at the RFU
David Wilson profile at ESPN Scrum
1985 births
Living people
Rugby union players from South Shields
English rugby union players
England international rugby union players
Rugby union props
Newcastle Falcons players
Bath Rugby players
2011 Rugby World Cup players
2015 Rugby World Cup players
|
```c
/*
* Bitfield
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "includes.h"
#include "common.h"
#include "bitfield.h"
struct bitfield {
u8 *bits;
size_t max_bits;
};
struct bitfield * bitfield_alloc(size_t max_bits)
{
struct bitfield *bf;
bf = os_zalloc(sizeof(*bf) + (max_bits + 7) / 8);
if (bf == NULL)
return NULL;
bf->bits = (u8 *) (bf + 1);
bf->max_bits = max_bits;
return bf;
}
void bitfield_free(struct bitfield *bf)
{
os_free(bf);
}
void bitfield_set(struct bitfield *bf, size_t bit)
{
if (bit >= bf->max_bits)
return;
bf->bits[bit / 8] |= BIT(bit % 8);
}
void bitfield_clear(struct bitfield *bf, size_t bit)
{
if (bit >= bf->max_bits)
return;
bf->bits[bit / 8] &= ~BIT(bit % 8);
}
int bitfield_is_set(struct bitfield *bf, size_t bit)
{
if (bit >= bf->max_bits)
return 0;
return !!(bf->bits[bit / 8] & BIT(bit % 8));
}
static int first_zero(u8 val)
{
int i;
for (i = 0; i < 8; i++) {
if (!(val & 0x01))
return i;
val >>= 1;
}
return -1;
}
int bitfield_get_first_zero(struct bitfield *bf)
{
size_t i;
for (i = 0; i < (bf->max_bits + 7) / 8; i++) {
if (bf->bits[i] != 0xff)
break;
}
if (i == (bf->max_bits + 7) / 8)
return -1;
i = i * 8 + first_zero(bf->bits[i]);
if (i >= bf->max_bits)
return -1;
return i;
}
```
|
```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 resolve = require( 'path' ).resolve;
var exec = require( 'child_process' ).exec;
var tape = require( 'tape' );
var IS_BROWSER = require( '@stdlib/assert/is-browser' );
var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
var EOL = require( '@stdlib/regexp/eol' ).REGEXP;
var readFileSync = require( '@stdlib/fs/read-file' ).sync;
var EXEC_PATH = require( '@stdlib/process/exec-path' );
var rootDir = require( '@stdlib/_tools/utils/root-dir' );
// VARIABLES //
var ROOT_DIR = rootDir();
var fpath = resolve( __dirname, '..', 'bin', 'cli' );
var opts = {
'skip': IS_BROWSER || IS_WINDOWS
};
// FIXTURES //
var PKG_VERSION = require( './../package.json' ).version;
// TESTS //
tape( 'command-line interface', function test( t ) {
t.ok( true, __filename );
t.end();
});
tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
var expected;
var cmd;
expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
'encoding': 'utf8'
});
cmd = [
EXEC_PATH,
fpath,
'--help'
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
}
t.end();
}
});
tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
var expected;
var cmd;
expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
'encoding': 'utf8'
});
cmd = [
EXEC_PATH,
fpath,
'-h'
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
}
t.end();
}
});
tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
var cmd = [
EXEC_PATH,
fpath,
'--version'
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
}
t.end();
}
});
tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
var cmd = [
EXEC_PATH,
fpath,
'-V'
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
}
t.end();
}
});
tape( 'the command-line interface prints a list of packages', opts, function test( t ) {
var cmd = [
EXEC_PATH,
fpath,
resolve( ROOT_DIR, 'lib', 'node_modules', '@stdlib', 'assert' )
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
t.strictEqual( stdout.toString().split( EOL ).length > 1, true, 'prints a newline-delimited list' );
t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
}
t.end();
}
});
tape( 'the command-line interface supports searching based on a pattern', opts, function test( t ) {
var cmd = [
EXEC_PATH,
fpath,
resolve( ROOT_DIR, 'lib', 'node_modules', '@stdlib', 'assert' ),
'--pattern \'**/is-string/package.json\''
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
// Includes trailing newline...
t.strictEqual( stdout.toString().split( EOL ).length, 2, 'prints a newline-delimited list' );
t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
}
t.end();
}
});
tape( 'the command-line interface supports providing an exclusion pattern', opts, function test( t ) {
var cmd;
var dir;
dir = resolve( ROOT_DIR, 'lib', 'node_modules', '@stdlib' );
cmd = [
EXEC_PATH,
fpath,
dir,
'--ignore \''+dir+'/**\'' // the same directory we are searching!
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
// Only prints a linebreak...
t.strictEqual( stdout.toString().split( EOL ).length, 1, 'excludes matches' );
t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
}
t.end();
}
});
tape( 'the command-line interface supports providing multiple exclusion patterns', opts, function test( t ) {
var cmd;
var dir;
dir = resolve( ROOT_DIR, 'lib', 'node_modules', '@stdlib' );
cmd = [
EXEC_PATH,
fpath,
dir,
'--ignore \''+dir+'/**\'', // the same directory we are searching!
'--ignore build/**'
];
exec( cmd.join( ' ' ), done );
function done( error, stdout, stderr ) {
if ( error ) {
t.fail( error.message );
} else {
// Only prints a linebreak...
t.strictEqual( stdout.toString().split( EOL ).length, 1, 'excludes matches' );
t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
}
t.end();
}
});
```
|
Robert "Robbie" Williams (born 12 April 1979 in Liverpool, Merseyside) is an English footballer playing for Warrington Town.
Accrington Stanley
Williams signed for Accrington Stanley in July 1999 from Liverpool County Football Combination side St Dominics. He played for the club for ten years, making 238 league appearances for the club, and picking up championship winning medals for the Northern Premier Division One in 2000, the Northern Premier League in 2003 and the Conference National in 2006, seeing the club promoted to the Football League.
Illegal betting and subsequent ban
In April 2009, Williams, who at the time was the club's longest serving player, along Stanley teammates Peter Cavanagh, Jay Harris and David Mannix and Bury player Andy Mangan were charged with breaching the Football Association's betting rules, with some accused of gambling thousands of pounds on their team to lose. The scandal related to Accrington Stanley's last game of the last League Two season, at home to Bury.
In July 2009, the players (except Cavanagh, whose case was to be heard at a later date) were banned for varying lengths after being found guilty of being involved in betting on a Bury win when the Shakers visited the Crown Ground at the end of the 2007/08 season – a game that Bury went on to win. Williams was suspended from professional football for eight months and received a £3,500 fine, and was released by Stanley. The players appealed against their bans but lost their cases.
Southport
In March 2010 he agreed to join Southport and finally joined up with the club in May.
Warrington Town
In October 2012 he signed for Warrington Town making his club debut on 13 October in a 1–1 draw with Salford City.
Honours
Northern Premier Division One (VII): 2000
Northern Premier League (VI): 2003
Conference National (V): 2006
References
External links
Living people
1979 births
English men's footballers
Men's association football defenders
Accrington Stanley F.C. players
Southport F.C. players
English Football League players
National League (English football) players
Footballers from Liverpool
Warrington Town F.C. players
Northern Premier League players
Sportspeople involved in betting scandals
|
Polaribacter is a genus in the family Flavobacteriaceae. They are gram-negative, aerobic bacteria that can be heterotrophic, psychrophilic or mesophilic. Most species are non-motile and species range from ovoid to rod-shaped. Polaribacter forms yellow- to orange-pigmented colonies. They have been mostly adapted to cool marine ecosystems, and their optimal growth range is at a temperature between 10 and 32 °C and at a pH of 7.0 to 8.0. They are oxidase and catalase-positive and are able to grow using carbohydrates, amino acids, and organic acids.
There is evidence of two life strategies for members of the genus, Polaribacter. Some Polaribacter species are free-living and consume amino acids and carbohydrates, as well as have proteorhodopsin that enhances living in oligotrophic seawaters. Other species of Polaribacter attach to substrates in search of protein polymers.
In the context of climate change, algal blooms are becoming increasingly prevalent. Members of the genus Polaribacter decompose algal cells and thus may be important in biogeochemical cycling, as well as influence seawater chemistry and the composition of microbial communities as temperatures continue to rise. This may impact the efficiency of the biological pump in sequestering atmospheric carbon.
Polaribacter is a genus that is being continuously researched and to date there are 25 species that have been validly published under the International Code of Nomenclature of Prokaryotes (ICNP): P. aquimarinus, P. atrinae, P. butkevichii, P. dokdonensis, P. filamentus, P. franzmannii, P. gangjinensis, P. glomeratus, P. haliotis, P. huanghezhanensis, P. insulae, P. irgensii, P. lacunae, P. litorisediminis, P. marinaquae, P. marinivivus, P. pacificus, P. porphyrae, P. reichenbachii, P. sejongensis, P. septentrionalilitoris, P. staleyi, P. tangerinus, P. undariae, P. vadi.
The genus is sometimes incorrectly referred to as Polaribacer; Polarobacter or Polaribacteria.
Phylogeny
This phylogeny is based on rRNA gene sequencing.
Distribution and Abundance
Members in the genus Polaribacter are abundant in polar oceans and are important in the export of dissolved organic matter (DOM). A small percentage of the bacterial community is responsible for the DOM uptake rate.
In northern latitude waters, the fraction of cells using glucose (fraction of active cells) is higher in summer than winter, and high abundances may occur after phytoplankton blooms, although a study in southern high-latitude waters found lower abundances of Polaribacter after an in situ diatom bloom.
Within the Arctic Ocean, there is no obvious pattern in the relative abundance between summer and winter. In the Chukchi Sea, the fraction of cells using leucine is higher in the winter than in summer. In the Beaufort Sea, the fraction of cells using leucine does not differ between seasons. In the coastal waters of Fildes Peninsula, Polaribacter dominated cells in the phylum Bacteriodetes.
Habitat
Microorganisms in the genus Polaribacter are widely distributed and various species are capable of living in a plethora of different environments. Some Polaribacter species have been isolated from brine pools in the Arctic Ocean. in addition to hypersaline environments, numerous Polaribacter species inhabit extreme environments ranging from -20 °C to 22 °C. In the past, it was thought that Polaribacter only flourished in cold waters as the members of the species that were first discovered (P. irgensii, P. filamentus, and P. franzmannii) in the Arctic and Southern Oceans could only survive in water with temperatures ranging from -20 °C to 10 °C. Subsequently, members of the genus Polaribacter have been shown to be very versatile microorganisms and can survive in oligotrophic and in copiotrophic environments. Polaribacter have also been found in sediments. For example, SM1202T, a phylogenetically close strain to Polaribacter was isolated from marine sediment in Kongsfjorden, Svalbard. Polaribacter have also been experimentally isolated from red macroalgae (Porphyra yezoensis) and green macroalgae (Ulva fenestrate).
Role in ecosystem
Isolates of related Flavobacteria are able to degrade High-Molecular Weight (HMW) DOM. and Polaribacter may be among the first organisms to degrade particulate organic matter and break-down polymers into smaller particles that can be used by free-living bacterial heterotrophs. This suggests that they likely remineralize primary production matter within the food web.
In the Southern Ocean
The Antarctic Peninsula exhibits strong seasonal changes, which influences how bacteria respond to and live in these environmental conditions. The Antarctic spring is especially important as it brings about significant changes, including sea ice melting, thermal stratification due to warming surface waters, and increased dissolved organic matter (DOM) production. All these physical changes also result in phytoplankton blooms which are important in supporting higher trophic levels.
In the Southern Ocean, flavobacteria dominate bacterial activity, particularly flavobacteria in the genus Polaribacter. Typically, these bacteria are prevalent in sea ice; however, during seasonal melting in the summer, they dominate coastal waters as sea ice retreats. In the Southern Ocean, when phytoplankton blooms occur, Flavobacteria, and particularly members in the genus Polaribacter, are among the first bacterial taxa to respond to phytoplankton blooms, breaking down organic matter by direct attachment and the use of exoenzymes. Both particle-attached and free-living members of the family Rhodobacteraceae were also found in close association with phytoplankton blooms; however, bacteria in this family were found to use lower molecular weight substrates. This suggests that they're secondary in the microbial succession of substrates, using the byproducts of degradation by flavobacteria, which also includes members of the genus Polaribacter. The relative abundance of free-living bacteria belonging to the genus Polaribacter and in the family Rhodobacteraceae peaked at different points during phytoplankton blooms, suggesting a niche specialization contributing to successive degradation of phytoplankton-derived organic matter. Bacteria in the genus Polaribacter and family Rhodobacteraceae were found in clusters, with Polaribacter clusters forming earlier in the bloom, which further suggests a successive ecological interaction between various bacterial taxa.
For both the Arctic Ocean and the North Sea, Polaribacter exhibited similar trends pertaining to phytoplankton blooms in the summertime as well as assuming particular niches for organic matter degradation.
Metabolism
Members of the genus Polaribacter are metabolically flexible depending on their physiology, lifestyle and seasonality of the region they inhabit. Many research studies have found that Polaribacter can alternate between two lifestyles as a mechanism for adaptation in surface waters where nutrient concentrations are low and light exposure is high. Sequenced strains of the genus Polaribacter show a high prevalence of peptidase and glycoside hydrolase genes in comparison to other bacteria in the Flavobacteriaceae, indicating they contribute to degradation and uptake of external proteins and oligopeptides.
In the pelagic water column, some species are well equipped to attach to particles and substrates to search for and degrade polymers. They are amongst the first organisms to degrade particulate organic matter and break-down polymers into smaller particles. Studies have shown that they will colonize and attach to particles, glide to search for substrates, and degrade them for carbon and nutrients. Once they've degraded these molecules, the bacterium may then search for new particles to colonize, forcing them to freely-swim in environments where nutrients and organic carbon is not easily available.
CAZymes
Genetic sequencing found that strains contain numerous genes which encode for CAZymes that are involved in polysaccharide degradation. For example, strain DSW-5 (a strain genetically very similar to strain MED-152), contains 85 genes encoding to CAZymes and 203 peptidases, which suggests its role as a free-living heterotrophs. However, the ratio of peptidases to glycoside hydrolase genes varies depending on the environmental conditions the strain is subjected to. For example, Polaribacter sp. MED134 lives in environmental conditions with extended starvation conditions and expresses twice as many peptidases as CAZymes. On the other hand, macroalgae-colonizing species that live in stable, eutrophic environments may express greater proportions of CAZymes than peptidases.
Proteorhodopsin
"Free-living" species have the proteorhodopsin gene, which allows them to complete inorganic-carbon fixation using light as an energy source. By utilizing their proteorhodopsin to use light energy, Polaribacter can grow in oligotrophic environmental conditions.
Genome
General Genome Characteristics
The genome of bacteria in the genus Polaribacter vary in size from 2.76 Mb (P. irgensii) to 4.10 Mb (P. reichenbachii) and the number of genes ranging from 2446 in P. irgensii to 3500 in P. reichenbachii, but have a fairly constant G+C content of approximately 30 mol%. Some notable features of the genome include genes for agar, alginate, and carrageenan degrading enzymes in Polaribacter species which colonize the surface of macroalgae. Agar degrading enzymes have also been found in strains of Polaribacter that colonize the gut of the comb pen shell. Proteases are also commonly found in the genomes of species that preferentially grow on solid substrates and degrade protein instead of using free amino acids and living a pelagic lifestyle. Some members of the genus encode proteorhodopsin, which has been implicated in supporting their central metabolism through photophosphorylation.
DNA Sequencing of Polaribacter
DNA sequencing has commonly been used to identify new strains of Polaribacter and help place species on a phylogenetic tree. DNA sequencing has also been used to help understand, or predict a species role in an environment due to the presence of certain genes. Members of the family Flavobacteriaceae can be identified through the specific quinone, Menaquinone 6, also known as Vitamin K2; however, differentiating species can be much more difficult. Species such as Polaribacter vadi and Polaribacter atrinae were identified as new species based on their similar but unique genome when compared to other members of the genus Polaribacter. New species can be identified through DNA hybridization or through the sequencing and comparison of a common gene such as 16S rRNA. This has allowed scientists to create phylogenetic trees of the genus based on genomic similarity, as seen in the phylogeny section, as well as identify common features in the genome.
Life Strategies of Polaribacter Based on Genome Analysis
Genomic analysis has allowed scientists to examine the relationships between different species of Polaribacter. However, by combining genomic analysis with other analytical techniques such as chemotaxonomic and biochemical, scientists can theorize how a species might fit into an environment or how they believe a species is adapted to survive. A genomic analysis of the Polaribacter strain MED152, found a considerable amount of genes that allow for surface or particle attachment, gliding motility and polymer degradation. These genes fit with the current understanding of how marine bacteroidetes survive through attaching to a surface and moving over it to look for nutrients. However the researchers also noticed that the organism had a proteorhodopsin gene as well as other genes which could be used to sense light and found that under light the species increased carbon dioxide fixation. This led the researchers to theorize that Polaribacter strain MED152 has two different life strategies, one where it acts like other marine bacteroidetes, attaching to surfaces and searching for nutrients and, another life strategy where, if the strain was in a well lit, low nutrient area of the ocean, it would use carbon fixation to synthesize intermediates of metabolic pathways.
Another example of this comes from the Polaribacter strains Hel1_33_49 and Hel1_85. The strain Hel1_33_49 has a genome which contains proteorhodopsin, fewer polysaccharide utilization loci and no mannitol dehydrogenase, which the researchers associate with a pelagic lifestyle. Hel1_85 on the other hand, has a genome which contains twice as many polysaccharide utilization loci, a mannitol dehydrogenase and no proteorhodopsin, pointing to a lifestyle with lower oxygen availability such as a biofilm.
Species
Viral pathogens
Only two species of lytic phage are known to infect members of this genus, and both have double stranded DNA with virions that include isometric heads and non-contractile tails (class Caudoviricetes, morphotype: siphoviruses). Viral lysis has been implicated as a major driver of changes in genus-level composition of microbial communities.
Applications/uses
Cold water enzymes contained in psychrophilic bacteria like Polaribacter are valuable for biotechnology applications since they do not require high temperatures that may other enzyme systems do.
Psychrophilic enzymes
Polaribacter is a psychrophilic bacterium that lends itself to a variety of applications in both academic and industrial settings. These cold dwelling bacteria are an abundant source of psychrophilic enzymes which have an interesting ability to retain higher catalytic activity at temperatures below 25 °C. This is due to the highly malleable nature of these enzymes as this allows for better substrate - active site binding at colder temperatures. This is important as enzymes that operate at lower temperatures not only make the industrial processes more efficient, but they also minimize the chance of side reactions occurring. More of the substrate can directly be converted into the desired product all the while requiring less energy to do so. Psychrophilic enzymes can also aid with heat labile or volatile compounds, allowing reactions to occur without significant product loss. Another unique application for these enzymes is the ability to be inhibited without the need of external reagents. Usually to stop enzyme activity, chemical inhibitors are required which then require subsequent purification steps. With psychrophilic enzymes you can add slight heat to prevent any further reaction from occurring. Psychrophilic proteases derived from Polaribacter can be added to detergents allowing the washing of fabric at room temperature.
An example of this is the enzyme carrageenase, which has been shown to have anti-tumor, antiviral, antioxidant and immunomodulatory activities. However, carrageenase isolated from bacteria has historically had low enzyme activity and poor stability. Recently researchers have isolated and cloned the carrageenase gene from the Polaribacter sp. NJDZ03, which shows better thermostability, and the ability to be active at lower temperatures, making it a better choice for industrial uses.
Exopolysaccharide
EPS is a secreted exopolysaccharide which protects the cells, stabilizes membranes, and serve and carbon stores. Most EPS is similar but it is found that in extremophiles, the composition may be distinct. Specifically in Polaribacter sp. SM1127, where the EPS has antioxidant activity and has shown to protect human fibroblast cells at lower temperatures. Studies by Sun et al. were done to determine whether this can be utilized to protect and repair damage caused by frostbite. It was found that Polaribacter derived EPS helps facilitate the dermal fibroblast cell movement to the site of injury. This not only promotes healing during frostbite injury but other cutaneous wounds as well/
References
Further reading
Flavobacteria
Bacteria genera
Psychrophiles
Marine microorganisms
|
```python
#
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
#
# 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.
#
"""UnitTests for Batched DoFn (process_batch) API."""
# pytype: skip-file
import unittest
from typing import Iterator
from typing import List
from typing import Tuple
from typing import no_type_check
from parameterized import parameterized_class
import apache_beam as beam
class ElementDoFn(beam.DoFn):
def process(self, element: int, *args, **kwargs) -> Iterator[float]:
yield element / 2
class BatchDoFn(beam.DoFn):
def process_batch(self, batch: List[int], *args,
**kwargs) -> Iterator[List[float]]:
yield [element / 2 for element in batch]
class NoReturnAnnotation(beam.DoFn):
def process_batch(self, batch: List[int], *args, **kwargs):
yield [element * 2 for element in batch]
class OverrideTypeInference(beam.DoFn):
def process_batch(self, batch, *args, **kwargs):
yield [element * 2 for element in batch]
def get_input_batch_type(self, input_element_type):
return List[input_element_type]
def get_output_batch_type(self, input_element_type):
return List[input_element_type]
class EitherDoFn(beam.DoFn):
def process(self, element: int, *args, **kwargs) -> Iterator[float]:
yield element / 2
def process_batch(self, batch: List[int], *args,
**kwargs) -> Iterator[List[float]]:
yield [element / 2 for element in batch]
class ElementToBatchDoFn(beam.DoFn):
@beam.DoFn.yields_batches
def process(self, element: int, *args, **kwargs) -> Iterator[List[int]]:
yield [element] * element
def infer_output_type(self, input_element_type):
return input_element_type
class BatchToElementDoFn(beam.DoFn):
@beam.DoFn.yields_elements
def process_batch(self, batch: List[int], *args,
**kwargs) -> Iterator[Tuple[int, int]]:
yield (sum(batch), len(batch))
def get_test_class_name(cls, num, params_dict):
return "%s_%s" % (cls.__name__, params_dict['dofn'].__class__.__name__)
@parameterized_class([
{
"dofn": ElementDoFn(),
"input_element_type": int,
"expected_process_defined": True,
"expected_process_batch_defined": False,
"expected_input_batch_type": None,
"expected_output_batch_type": None
},
{
"dofn": BatchDoFn(),
"input_element_type": int,
"expected_process_defined": False,
"expected_process_batch_defined": True,
"expected_input_batch_type": beam.typehints.List[int],
"expected_output_batch_type": beam.typehints.List[float]
},
{
"dofn": NoReturnAnnotation(),
"input_element_type": int,
"expected_process_defined": False,
"expected_process_batch_defined": True,
"expected_input_batch_type": beam.typehints.List[int],
"expected_output_batch_type": beam.typehints.List[int]
},
{
"dofn": OverrideTypeInference(),
"input_element_type": int,
"expected_process_defined": False,
"expected_process_batch_defined": True,
"expected_input_batch_type": beam.typehints.List[int],
"expected_output_batch_type": beam.typehints.List[int]
},
{
"dofn": EitherDoFn(),
"input_element_type": int,
"expected_process_defined": True,
"expected_process_batch_defined": True,
"expected_input_batch_type": beam.typehints.List[int],
"expected_output_batch_type": beam.typehints.List[float]
},
{
"dofn": ElementToBatchDoFn(),
"input_element_type": int,
"expected_process_defined": True,
"expected_process_batch_defined": False,
"expected_input_batch_type": None,
"expected_output_batch_type": beam.typehints.List[int]
},
{
"dofn": BatchToElementDoFn(),
"input_element_type": int,
"expected_process_defined": False,
"expected_process_batch_defined": True,
"expected_input_batch_type": beam.typehints.List[int],
"expected_output_batch_type": None,
},
],
class_name_func=get_test_class_name)
class BatchDoFnParameterizedTest(unittest.TestCase):
def test_process_defined(self):
self.assertEqual(self.dofn._process_defined, self.expected_process_defined)
def test_process_batch_defined(self):
self.assertEqual(
self.dofn._process_batch_defined, self.expected_process_batch_defined)
def test_get_input_batch_type(self):
self.assertEqual(
self.dofn._get_input_batch_type_normalized(self.input_element_type),
self.expected_input_batch_type)
def test_get_output_batch_type(self):
self.assertEqual(
self.dofn._get_output_batch_type_normalized(self.input_element_type),
self.expected_output_batch_type)
def test_can_yield_batches(self):
expected = self.expected_output_batch_type is not None
self.assertEqual(self.dofn._can_yield_batches, expected)
class NoInputAnnotation(beam.DoFn):
def process_batch(self, batch, *args, **kwargs):
yield [element * 2 for element in batch]
class MismatchedBatchProducingDoFn(beam.DoFn):
"""A DoFn that produces batches from both process and process_batch, with
mismatched return types (one yields floats, the other ints). Should yield
a construction time error when applied."""
@beam.DoFn.yields_batches
def process(self, element: int, *args, **kwargs) -> Iterator[List[int]]:
yield [element]
def process_batch(self, batch: List[int], *args,
**kwargs) -> Iterator[List[float]]:
yield [element / 2 for element in batch]
class MismatchedElementProducingDoFn(beam.DoFn):
"""A DoFn that produces elements from both process and process_batch, with
mismatched return types (one yields floats, the other ints). Should yield
a construction time error when applied."""
def process(self, element: int, *args, **kwargs) -> Iterator[float]:
yield element / 2
@beam.DoFn.yields_elements
def process_batch(self, batch: List[int], *args, **kwargs) -> Iterator[int]:
yield batch[0]
class NoElementOutputAnnotation(beam.DoFn):
def process_batch(self, batch: List[int], *args,
**kwargs) -> Iterator[List[int]]:
yield [element * 2 for element in batch]
class BatchDoFnTest(unittest.TestCase):
def test_map_pardo(self):
# verify batch dofn accessors work well with beam.Map generated DoFn
# checking this in parameterized test causes a circular reference issue
dofn = beam.Map(lambda x: x * 2).dofn
self.assertTrue(dofn._process_defined)
self.assertFalse(dofn._process_batch_defined)
self.assertEqual(dofn._get_input_batch_type_normalized(int), None)
self.assertEqual(dofn._get_output_batch_type_normalized(int), None)
def test_no_input_annotation_raises(self):
p = beam.Pipeline()
pc = p | beam.Create([1, 2, 3])
with self.assertRaisesRegex(TypeError, r'NoInputAnnotation.process_batch'):
_ = pc | beam.ParDo(NoInputAnnotation())
def test_unsupported_dofn_param_raises(self):
class BadParam(beam.DoFn):
@no_type_check
def process_batch(self, batch: List[int], key=beam.DoFn.KeyParam):
yield batch * key
p = beam.Pipeline()
pc = p | beam.Create([1, 2, 3])
with self.assertRaisesRegex(NotImplementedError, r'BadParam.*KeyParam'):
_ = pc | beam.ParDo(BadParam())
def test_mismatched_batch_producer_raises(self):
p = beam.Pipeline()
pc = p | beam.Create([1, 2, 3])
# Note (?ms) makes this a multiline regex, where . matches newlines.
# See (?aiLmsux) at
# path_to_url#regular-expression-syntax
with self.assertRaisesRegex(
TypeError,
(r'(?ms)MismatchedBatchProducingDoFn.*'
r'process: List\[<class \'int\'>\].*process_batch: '
r'List\[<class \'float\'>\]')):
_ = pc | beam.ParDo(MismatchedBatchProducingDoFn())
def test_mismatched_element_producer_raises(self):
p = beam.Pipeline()
pc = p | beam.Create([1, 2, 3])
# Note (?ms) makes this a multiline regex, where . matches newlines.
# See (?aiLmsux) at
# path_to_url#regular-expression-syntax
with self.assertRaisesRegex(
TypeError,
r'(?ms)MismatchedElementProducingDoFn.*process:.*process_batch:'):
_ = pc | beam.ParDo(MismatchedElementProducingDoFn())
def test_cant_infer_batchconverter_input_raises(self):
p = beam.Pipeline()
pc = p | beam.Create(['a', 'b', 'c'])
with self.assertRaisesRegex(
TypeError,
# Error should mention "input", and the name of the DoFn
r'input.*BatchDoFn.*'):
_ = pc | beam.ParDo(BatchDoFn())
def test_cant_infer_batchconverter_output_raises(self):
p = beam.Pipeline()
pc = p | beam.Create([1, 2, 3])
with self.assertRaisesRegex(
TypeError,
# Error should mention "output", the name of the DoFn, and suggest
# overriding DoFn.infer_output_type
r'output.*NoElementOutputAnnotation.*DoFn\.infer_output_type'):
_ = pc | beam.ParDo(NoElementOutputAnnotation())
def test_element_to_batch_dofn_typehint(self):
# Verify that element to batch DoFn sets the correct typehint on the output
# PCollection.
p = beam.Pipeline()
pc = (p | beam.Create([1, 2, 3]) | beam.ParDo(ElementToBatchDoFn()))
self.assertEqual(pc.element_type, int)
def test_batch_to_element_dofn_typehint(self):
# Verify that batch to element DoFn sets the correct typehint on the output
# PCollection.
p = beam.Pipeline()
pc = (p | beam.Create([1, 2, 3]) | beam.ParDo(BatchToElementDoFn()))
self.assertEqual(pc.element_type, beam.typehints.Tuple[int, int])
if __name__ == '__main__':
unittest.main()
```
|
Pontgouin () is a commune in the Eure-et-Loir department in northern France.
Population
See also
Communes of the Eure-et-Loir department
References
Communes of Eure-et-Loir
|
```javascript
'use strict';
const _ = require('lodash');
const BbPromise = require('bluebird');
const fse = require('fs-extra');
module.exports = {
cleanup() {
const webpackOutputPath = this.webpackOutputPath;
const keepOutputDirectory = this.keepOutputDirectory || this.configuration.keepOutputDirectory;
const cli = this.options.verbose ? this.serverless.cli : { log: _.noop };
if (!keepOutputDirectory) {
if (this.log) {
this.log.verbose(`Remove ${webpackOutputPath}`);
} else {
cli.log(`Remove ${webpackOutputPath}`);
}
if (this.serverless.utils.dirExistsSync(webpackOutputPath)) {
// Remove async to speed up process
fse
.remove(webpackOutputPath)
.then(() => {
if (this.log) {
this.log.verbose(`Removing ${webpackOutputPath} done`);
} else {
cli.log(`Removing ${webpackOutputPath} done`);
}
return null;
})
.catch(error => {
if (this.log) {
this.log.error(`Error occurred while removing ${webpackOutputPath}: ${error}`);
} else {
cli.log(`Error occurred while removing ${webpackOutputPath}: ${error}`);
}
});
}
} else {
if (!this.log) {
cli.log(`Keeping ${webpackOutputPath}`);
}
}
return BbPromise.resolve();
}
};
```
|
WPHI-FM (103.9 MHz) is a commercial radio station licensed to Jenkintown, Pennsylvania, and serving the Philadelphia metropolitan area. The station is owned by Audacy, Inc., simulcasting an all-news radio format with co-owned KYW 1060 AM. The radio studios are in Audacy's corporate headquarters in Center City, Philadelphia.
WPHI-FM has an effective radiated power (ERP) of 270 watts, as a Class A station. The transmitter tower is in the Roxborough neighborhood of Philadelphia (). The station is short-spaced due to adjacent channel interference from WMGM in Atlantic City, WXCY-FM in Havre de Grace, Maryland, and WNNJ in Newton, New Jersey (all located on 103.7 FM) and WAEB-FM in Allentown and WNNK in Harrisburg (both located on 104.1 FM).
History
1960-1992: Early years
On , the station signed on the air. Its original call sign was WIBF-FM and it was owned by Fox Broadcasting, not related to the more recent Fox Broadcasting Company television network. The call letters stood for the station's owners, brothers William and Irwin Fox and their father Benjamin Fox, a local real estate developer.
In the 1960s and 1970s, the station featured a format of MOR, big bands, Dixieland jazz and the area's first FM country music show, plus religious and ethnic programs. By the mid-1970s, the station switched to Christian radio and ethnic programming during the day and Spanish-language tropical music at night. The Barry Reisman Show, featuring Jewish music and talk, was broadcast during the afternoon drive time from 1969 through the station's sale in 1992. In 1965, the station picked up a television sister in WIBF-TV, channel 29 (now WTXF-TV, a station coincidentally owned by the Fox Broadcasting Company).
1992-1997: Modern rock
The station was sold by the Fox family in October 1992 to Jarad Broadcasting. On November 9, 1992, at midnight, co-owned WDRE from Garden City, New York, started simulcasting its modern rock programming with WIBF-FM. WIBF's branding was changed to "103.9 WDRE" to match the New York station. The simulcasting was part of a large effort by Jarad called "The Underground Network", a group of seven stations from across the country simulcasting WDRE. In 1995, the network ceased operations. WDRE in New York changed its call letters back to WLIR. That made WIBF-FM in Philadelphia an independent, local modern rock station. WIBF-FM then changed its own call sign to WDRE - "We DaRE to be Different" - to match its branding.
WDRE used the slogan "Philly's Modern Rock". "Alive" by Pearl Jam was the first song played on WDRE.
The station helped launch the careers of several famous disc jockeys and broadcasters. They include Preston Elliot and Steve Morrison of the Preston and Steve morning show on WMMR, Bret Hamilton of WCAU-TV, Marilyn Russell (formerly of Y100, WXPN, WMGK, now on WOGL), Jim McGuinn (also known as Rumor Boy), the former Program Director of WPLY, and Mel "Toxic" Taylor, who went on to WYSP. Taylor (formerly of WPST and WIFI) was the first DJ hired for the only two shows that were live from Philadelphia each week.
When WDRE Philadelphia became a local radio station in 1995, talent was hired from within the city (e.g. Bret Hamilton, formerly of WIOQ) and outside of the city. While WDRE never became a true mainstream radio station in the Philadelphia radio market due to its weak signal, the station gained a cult status. As a result, events like the station's music festival (known as "DREfest") sold out to a crowd of over 25,000 people.
In December 1996, Radio One bought WDRE from Jarad, and on the 16th of that month, WDRE announced that the station would flip to a then-undisclosed format in February 1997.
With the pending format flip, the staff at WDRE organized a concert called "Bitterfest", which was to be held at The Electric Factory. The concert featured local acts G Love and the Fun Lovin' Criminals, and was created to celebrate the life of WDRE as a local institution for modern rock. On February 7, 1997, "Bitterfest" was held to a sold-out crowd of over 3,000 people, with all of the WDRE staff present at the event. At midnight on February 8, 1997, as the crowd at "Bitterfest" chanted "'D-R-E! 'D-R-E! 'D-R-E!", a lucky (or unlucky) listener was selected to "pull the plug" on WDRE, with the station ending with the first song that started the format: Pearl Jam's "Alive". Two of the WDRE disc jockeys (Preston Eliot, Bret Hamilton) went to Y100, as did 'DRE Program Director Jim McGuinn, and midday and Sunday night DJ Marilyn Russell (as Promotions Director for Y100). Y100 was also bought out by Radio One in 2000, and flipped in 2005 to urban contemporary.
1997-2005: Urban contemporary
On February 10, 1997, after a weekend of stunting with classic soul music, the station flipped to urban contemporary, branded as "Philly 103-9." The call letters were soon changed to WPHI. When the station rebranded as "The Beat" in April 2002, it shifted to rhythmic top 40. By 2006, Radio & Records/Nielsen BDS moved it to the urban contemporary panel. Mediabase followed suit in 2011, completing the rhythmic to urban shift.
2005-2016: Gospel
On February 27, 2005, Radio One moved the "Beat" format to the 100.3 frequency, which was formerly Y100. 103.9 then flipped to urban gospel, branded as "Praise 103.9". The call sign was changed to WPPZ-FM on March 3.
Except for "The Yolanda Adams Morning Show" and CeCe McGhee weekday afternoons, the station ran without DJs throughout the day until August 2007. In late August, the addition of performer Lonnie Hunter from Chicago was named the midday personality along with Sheik Meah. Motivational speaker Les Brown was added on Sundays from 7–9pm. In September, Pastor Alan E. Waller joined the staff to do a Saturday morning show from 10–11:00 and two more weekend shows were added. The "Holy Hip-Hop Show" was added on Saturdays from 7–9pm and a Christian dating show was added on Sundays from 9–11pm.
WPPZ's staff includes Lonnie Hunter, Brother Marcus, and CeCe Magee. Former DJs include Church Lady (2007–2008), Ed Long (2005–2007), CoCo Brother (2011–2013), and Les Brown and B.I.G. C.I.T.Y. (2008–2009; 2009–present).
2016-2019: Classic hip-hop
On September 27, 2016, at midnight, WPPZ and WPHI swapped frequencies, with "Praise" moving to 107.9 FM, and "Boom" moving to 103.9 FM. It also marked the return of the WPHI call letters to the frequency that originated the call letters. With the change, WPHI's classic hip hop format shifted to urban contemporary; the classic hip hop songs were reduced to just a few per hour, with the station now emphasizing currents and recurrents. This marks the fourth attempt by Radio One to compete against long dominant WUSL.
Eight months after WPHI's format switch, WISX flipped to a classic hip hop-leaning rhythmic AC on June 30, 2017.
2019-2021: Rhythmic contemporary
On December 24, 2019, WPHI rebranded as "Hip Hop 103.9".
2021-present: All news simulcast
On November 5, 2020, Urban One announced that it would swap WPHI-FM, WHHL and the intellectual property of WFUN-FM in St. Louis, and WTEM in Washington, D.C. to Entercom, in exchange for WBT/WBT-FM, WFNZ and WLNK in Charlotte, North Carolina. Under the terms of the deal, Entercom would take over operations of WPHI-FM under a local marketing agreement (LMA) on November 23, and flip it to a simulcast of KYW. Ahead of the change, the "Hip Hop" format and branding moved to WRNB on November 16, and the two stations simulcast for a week. The change in ownership and format took place at midnight on the 23rd. The swap was consummated on April 20, 2021. The WPHI call letters were retained to prevent competitor re-use (Nielsen's measurement systems no longer require specific callsign verification by panelists).
See also
WLIR — the original "WDRE" from 1987 to 1996, at 92.7 FM in Garden City, New York
WXPN-HD2
References
External links
WDRE era
"103.9 WDRE Philadelphia, The Birth 1992" — studio footage of "WIBF" format to "WDRE" format switch at midnight; press parties, including a press event with Joey Ramone; photos of staff and guests
WDRE Reunion — articles and footage about WDRE on the University of Pennsylvania WXPN website
WDRE 103.9 FM — archived copy of the original WDRE website
— follow-up on WDRE popularity after end of format
— short letter to the editor with WDRE end date given
Philadelphia FM Radio History — timeline of 103.9
103.9 WDRE...Philly's Modern Rock — page on Angelfire, with DJ locations
Radio stations established in 1960
Audacy, Inc. radio stations
PHI-FM
1960 establishments in Pennsylvania
All-news radio stations in the United States
|
```c
extern void abort(void);
extern void exit(int);
int bar(void);
int baz(void);
struct foo {
struct foo *next;
};
struct foo *test(struct foo *node)
{
while (node) {
if (bar() && !baz())
break;
node = node->next;
}
return node;
}
int bar (void)
{
return 0;
}
int baz (void)
{
return 0;
}
int main(void)
{
struct foo a, b, *c;
a.next = &b;
b.next = (struct foo *)0;
c = test(&a);
if (c)
abort();
exit (0);
}
```
|
```objective-c
/*
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
* * The WHITECAT logotype cannot be changed, you can remove it, but you
* cannot change it in any way. The WHITECAT logotype is:
*
* /\ /\
* / \_____/ \
* /_____________\
* W H I T E C A T
*
* * Redistributions in binary form must retain all copyright notices printed
* to any local or remote output device. This include any reference to
* Lua RTOS, whitecatboard.org, Lua, and other copyright notices that may
* appear in the future.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 <COPYRIGHT HOLDER> 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.
*
* Lua RTOS, RMII ethernet driver
*
*/
#ifndef DRIVERS_ETH_H_
#define DRIVERS_ETH_H_
#include <sys/driver.h>
#include <drivers/net.h>
// SPI ethernet errors
#define ETH_ERR_CANT_INIT (DRIVER_EXCEPTION_BASE(ETH_DRIVER_ID) | 0)
#define ETH_ERR_NOT_INIT (DRIVER_EXCEPTION_BASE(ETH_DRIVER_ID) | 1)
#define ETH_ERR_NOT_START (DRIVER_EXCEPTION_BASE(ETH_DRIVER_ID) | 2)
#define ETH_ERR_CANT_CONNECT (DRIVER_EXCEPTION_BASE(ETH_DRIVER_ID) | 3)
#define ETH_ERR_INVALID_ARGUMENT (DRIVER_EXCEPTION_BASE(ETH_DRIVER_ID) | 4)
extern const int eth_errors;
extern const int eth_error_map;
driver_error_t *eth_setup(uint32_t ip, uint32_t mask, uint32_t gw, uint32_t dns1, uint32_t dns2);
driver_error_t *eth_start(uint8_t async);
driver_error_t *eth_stop();
driver_error_t *eth_stat(ifconfig_t *info);
#endif /* DRIVERS_ETH_H_ */
```
|
```python
# your_sha256_hash---------------
#
#
# 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.
# your_sha256_hash---------------
import os
class Package(object):
def __init__(self, group_id, artifact_id, version):
if not group_id:
raise ValueError("group_id must be set")
if not artifact_id:
raise ValueError("artifact_id must be set")
self.group_id = group_id
self.artifact_id = artifact_id
self.version = version
self.uri = None
def path(self, with_version=True):
base = self.group_id.replace(".", "/") + "/" + self.artifact_id
if with_version:
return base + "/" + self.version
else:
return base
def getUri(self, base, resolved_version=None):
if self.uri:
return self.uri
if not resolved_version:
resolved_version = self.version
return base + "/" + self.path() + "/" + self.artifact_id + "-" + resolved_version + ".jar"
def _generateFileName(self):
s = self.artifact_id
if self.version:
s = s + "-" + self.version
return s + ".jar"
def getFilePath(self, filename=None):
if self.uri:
return os.path.join(filename, self.uri.split("/")[-1])
if not filename:
filename = self._generateFileName()
elif os.path.isdir(filename):
filename = os.path.join(filename, self._generateFileName())
return filename
def __str__(self):
if self.uri:
return self.uri
return "{0}:{1}:{2}".format(self.group_id, self.artifact_id, self.version)
@staticmethod
def clone(package, version=None):
return Package(
package.group_id,
package.artifact_id,
version if version is not None else package.version)
@staticmethod
def fromPackageIdentifier(package):
#check if the user wants a direct download
if package.startswith("http://") or package.startswith("https://") or package.startswith("file://"):
retPackage = Package( "direct.download", package, "1.0" )
retPackage.uri = package
return retPackage
parts = package.split(":")
if len(parts) >= 3:
g = parts[0]
a = parts[1]
v = parts[len(parts) - 1]
return Package(g, a, v)
return None
```
|
Jafarabad (, also Romanized as Ja‘farābād) is a village in Pirsalman Rural District, in the Central District of Asadabad County, Hamadan Province, Iran. At the 2006 census, its population was 195, in 43 families.
References
Populated places in Asadabad County
|
```javascript
var func = function () {
return true;
};
var test = 1;
```
|
Imaduwa Divisional Secretariat is a Divisional Secretariat of Galle District, of Southern Province, Sri Lanka.
References
Divisional Secretariats Portal
Divisional Secretariats of Galle District
|
```javascript
'use strict';
module.exports = function (grunt) {
require('jit-grunt')(grunt, {
simplemocha: 'grunt-simple-mocha',
browserify: 'grunt-browserify'
});
// Project Configuration
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
simplemocha: {
options: {
reporter: 'spec',
timeout: '5000'
},
full: {
src: [
'test/mocha/**/*.spec.js'
]
}
},
browserify: {
dist: {
files: {
'dist/numjs.js': 'src/index.js'
}
},
options: {
browserifyOptions: {
standalone: 'nj'
}
}
},
// karma: {
// options: {
// frameworks: ['mocha', 'chai'],
// reporters: ['dots'],
// // web server port
// port: 9876,
// colors: true,
// logLevel: 'WARN',
// autoWatch: false,
// browsers: ['PhantomJS'],
// singleRun: true
// },
// min: {
// options: {
// files: [
// 'test/karma/phantom.js',
// // tested files
// 'dist/numjs.min.js',
// // tests files
// 'test/karma/*.spec.js',
// {pattern: 'data/**/*.png', watched: false, included: false, served: true}
// ]
// }
// },
// dist: {
// options: {
// files: [
// 'test/karma/phantom.js',
// 'dist/numjs.js',
// 'test/karma/*.spec.js',
// {pattern: 'data/**/*.png', watched: false, included: false, served: true}
// ]
// }
// }
// },
uglify: {
dist: {
options: {
banner: '/*! <%= pkg.name %> */\n'
},
files: {
'dist/numjs.min.js': 'dist/numjs.js'
}
}
},
jsdoc: {
dist: {
src: ['src/**/*.js', 'README.md'],
options: {
destination: 'doc'
// template : "node_modules/ink-docstrap/template",
// configure : "node_modules/ink-docstrap/template/jsdoc.conf.json"
}
}
},
'gh-pages': {
options: {
base: 'doc'
},
src: ['**']
}
});
grunt.registerTask('mocha', ['simplemocha:full']);
grunt.registerTask('build', ['browserify', 'uglify']);
grunt.registerTask('test', ['simplemocha:full', 'build']); //, 'karma:dist', 'karma:min']);
grunt.registerTask('travis', ['simplemocha:full', 'karma:dist', 'karma:min']);
grunt.registerTask('doc', ['jsdoc', 'gh-pages']);
};
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.