text stringlengths 1 22.8M |
|---|
Kawabata Bōsha (川端 茅舎; August 17, 1897 – ) was a Japanese haiku poet.
Life
Kawabata Bōsha was born on August 17, 1897, in Nihonbashi, Tokyo. He was the son of an amateur haiku poet, painter, and calligrapher, and the younger brother or half-brother of the painter Kawabata Ryūshi. His parents ran a geisha house when he was a child, prompting Kawabata to develop puritanical and reclusive tendencies.
When his family home was destroyed in the 1923 Great Kantō earthquake, Kawabata took up residence in the Tōfuku-ji in Kyoto, where he studied Zen Buddhism for four years. He also studied painting under Kishida Ryūsei until the latter's death in 1929. He eventually gave up both Buddhism and painting due to illness. In 1931 he developed tuberculosis of the spine and was bedridden for the remainder of his life.
Kawabata Bōsha died on 17 July 1941.
Poetry
Kawabata began publishing haiku in magazines while he was still a teenager. In 1915, he was first published in Hototogisu ("Cuckoo"), the magazine of the haiku school centered on Kyoshi Takahama, a conservative movement focused on the natural world. While many adherents later broke with Kyoshi, Kawabata's devotion to the Hototogisu school's principles was such that one critic labeled him a "martyr" to "flowers and birds." (In 1929, Hototogisu published Kyoshi's famous dictum that the subject matter of haiku was "flowers and birds.") Kawabata's work was also noted for its use of onomatopoeia and its religious imagery, both Buddhist and Christian.
In 1934, he published his first collection of poetry, Kawabata Bōsha Kushū. It began with 26 haiku about dew, whose transitory nature was a particular focus of Kawabata's work. His second collection, Kegon, featured an introduction by Kyoshi, where he praised Kawabata as the leading figure "in the mysteries of nature poetry."
The Haiku of Kawabata Bōsha, a Definitive Edition was published posthumously in 1946.
References
Created via preloaddraft
1897 births
1941 deaths
Writers from Tokyo
20th-century Japanese poets
Japanese haiku poets |
Michael Walker is a Paralympic athlete who won five gold medals representing Great Britain. Walker won gold in four category C4 track and field events at the 1988 Summer Paralympics in Seoul, South Korea: the shot put, the discus, the club throw and the javelin. He retained the shot put title in Barcelona 1992.
References
Paralympic gold medalists for Great Britain
Medalists at the 1988 Summer Paralympics
Medalists at the 1992 Summer Paralympics
Paralympic medalists in athletics (track and field)
Athletes (track and field) at the 1988 Summer Paralympics
Athletes (track and field) at the 1992 Summer Paralympics
Paralympic athletes for Great Britain
British male discus throwers
British male javelin throwers
British male shot putters |
Knockrome is a hamlet on the island of Jura, in the civil parish of Jura, in the council area of Argyll and Bute, Scotland. On the 1982 OS 1:10000 map, there were 20 buildings. Knockrome is located about 3.5 miles from Craighouse, on lower lying ground between Knockrome Hill and Cnocan Soilleir. Knockrome is located on the southeast coast of Jura. It is north of Jura Airfield and a prehistoric standing stone.
History
The name "Knockrome" means "The crooked hill".
References
Hamlets in Argyll and Bute
Villages on Jura, Scotland |
```makefile
xcl2_SRCS:=${COMMON_REPO}/common/includes/xcl2/xcl2.cpp
xcl2_HDRS:=${COMMON_REPO}/common/includes/xcl2/xcl2.hpp
xcl2_CXXFLAGS:=-I${COMMON_REPO}/common/includes/xcl2
``` |
```c++
///////////////////////////////////////////////////////////////////////////////
// LICENSE_1_0.txt or copy at path_to_url
#ifndef BOOST_MP_NO_ET_OPS_HPP
#define BOOST_MP_NO_ET_OPS_HPP
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable : 4714)
#endif
namespace boost {
namespace multiprecision {
//
// Operators for non-expression template enabled number.
// NOTE: this is not a complete header - really just a suffix to default_ops.hpp.
// NOTE: these operators have to be defined after the methods in default_ops.hpp.
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(const number<B, et_off>& v)
{
static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(v);
number<B, et_off> result(v);
result.backend().negate();
return result;
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator~(const number<B, et_off>& v)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(v);
number<B, et_off> result;
eval_complement(result.backend(), v.backend());
return result;
}
//
// Addition:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_add;
eval_add(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator+(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_add;
eval_add(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator+(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_add;
eval_add(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// Subtraction:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator-(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator-(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_subtract;
eval_subtract(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
//
// Multiply:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_multiply;
eval_multiply(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator*(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_multiply;
eval_multiply(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator*(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_multiply;
eval_multiply(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// divide:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator/(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_divide;
eval_divide(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator/(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_divide;
eval_divide(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator/(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b, a);
number<B, et_off> result;
using default_ops::eval_divide;
eval_divide(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
//
// modulus:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator%(const number<B, et_off>& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
number<B, et_off> result;
using default_ops::eval_modulus;
eval_modulus(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator%(const number<B, et_off>& a, const V& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a);
number<B, et_off> result;
using default_ops::eval_modulus;
eval_modulus(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator%(const V& a, const number<B, et_off>& b)
{
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(b);
number<B, et_off> result;
using default_ops::eval_modulus;
eval_modulus(result.backend(), number<B, et_off>::canonical_value(a), b.backend());
return result;
}
//
// Bitwise or:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_or;
eval_bitwise_or(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator|(const number<B, et_off>& a, const V& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_or;
eval_bitwise_or(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator|(const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_or;
eval_bitwise_or(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// Bitwise xor:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator^(const number<B, et_off>& a, const V& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator^(const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// Bitwise and:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(const number<B, et_off>& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_and;
eval_bitwise_and(result.backend(), a.backend(), b.backend());
return result;
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator&(const number<B, et_off>& a, const V& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_and;
eval_bitwise_and(result.backend(), a.backend(), number<B, et_off>::canonical_value(b));
return result;
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator&(const V& a, const number<B, et_off>& b)
{
number<B, et_off> result;
using default_ops::eval_bitwise_and;
eval_bitwise_and(result.backend(), b.backend(), number<B, et_off>::canonical_value(a));
return result;
}
//
// shifts:
//
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator<<(const number<B, et_off>& a, const I& b)
{
number<B, et_off> result(a);
using default_ops::eval_left_shift;
detail::check_shift_range(b, std::integral_constant<bool, (sizeof(I) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<I>::value>());
eval_left_shift(result.backend(), b);
return result;
}
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator>>(const number<B, et_off>& a, const I& b)
{
number<B, et_off> result(a);
using default_ops::eval_right_shift;
detail::check_shift_range(b, std::integral_constant<bool, (sizeof(I) > sizeof(std::size_t))>(), std::integral_constant<bool, boost::multiprecision::detail::is_signed<I>::value>());
eval_right_shift(result.backend(), b);
return result;
}
//
// If we have rvalue references go all over again with rvalue ref overloads and move semantics.
// Note that while it would be tempting to implement these so they return an rvalue reference
// (and indeed this would be optimally efficient), this is unsafe due to users propensity to
// write:
//
// const T& t = a * b;
//
// which would lead to a dangling reference if we didn't return by value. Of course move
// semantics help a great deal in return by value, so performance is still pretty good...
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& v)
{
static_assert(is_signed_number<B>::value, "Negating an unsigned type results in ill-defined behavior.");
v.backend().negate();
return std::move(v);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator~(number<B, et_off>&& v)
{
eval_complement(v.backend(), v.backend());
return std::move(v);
}
//
// Addition:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator+(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator+(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator+(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_add;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_add(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// Subtraction:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_signed_number<B>::value, number<B, et_off> >::type operator-(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(b.backend(), a.backend());
b.backend().negate();
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator-(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator-(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<(is_compatible_arithmetic_type<V, number<B, et_off> >::value && is_signed_number<B>::value) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator-(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_subtract;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_subtract(b.backend(), number<B, et_off>::canonical_value(a));
b.backend().negate();
return std::move(b);
}
//
// Multiply:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator*(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator*(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator*(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_multiply;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_multiply(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// divide:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR number<B, et_off> operator/(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_divide;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_divide(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value, number<B, et_off> >::type
operator/(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_divide;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_divide(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
//
// modulus:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator%(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_modulus;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_modulus(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator%(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_modulus;
detail::scoped_default_precision<multiprecision::number<B, et_off> > precision_guard(a, b);
eval_modulus(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
//
// Bitwise or:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator|(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator|(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator|(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_or;
eval_bitwise_or(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// Bitwise xor:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator^(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator^(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator^(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_xor;
eval_bitwise_xor(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// Bitwise and:
//
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(number<B, et_off>&& a, const number<B, et_off>& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(a.backend(), b.backend());
return std::move(a);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(const number<B, et_off>& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(b.backend(), a.backend());
return std::move(b);
}
template <class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<number_category<B>::value == number_kind_integer, number<B, et_off> >::type operator&(number<B, et_off>&& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(a.backend(), b.backend());
return std::move(a);
}
template <class B, class V>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator&(number<B, et_off>&& a, const V& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(a.backend(), number<B, et_off>::canonical_value(b));
return std::move(a);
}
template <class V, class B>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<is_compatible_arithmetic_type<V, number<B, et_off> >::value && (number_category<B>::value == number_kind_integer) && !is_equivalent_number_type<V, B>::value, number<B, et_off> >::type
operator&(const V& a, number<B, et_off>&& b)
{
using default_ops::eval_bitwise_and;
eval_bitwise_and(b.backend(), number<B, et_off>::canonical_value(a));
return std::move(b);
}
//
// shifts:
//
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator<<(number<B, et_off>&& a, const I& b)
{
using default_ops::eval_left_shift;
eval_left_shift(a.backend(), b);
return std::move(a);
}
template <class B, class I>
BOOST_MP_FORCEINLINE BOOST_MP_CXX14_CONSTEXPR typename std::enable_if<boost::multiprecision::detail::is_integral<I>::value && (number_category<B>::value == number_kind_integer), number<B, et_off> >::type
operator>>(number<B, et_off>&& a, const I& b)
{
using default_ops::eval_right_shift;
eval_right_shift(a.backend(), b);
return std::move(a);
}
}
} // namespace boost::multiprecision
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#endif // BOOST_MP_NO_ET_OPS_HPP
``` |
```swift
// swift-tools-version:5.9
import PackageDescription
let package = Package(
name: "fluent",
platforms: [
.macOS(.v10_15),
.iOS(.v13),
.watchOS(.v6),
.tvOS(.v13),
],
products: [
.library(name: "Fluent", targets: ["Fluent"]),
],
dependencies: [
.package(url: "path_to_url", from: "1.48.4"),
.package(url: "path_to_url", from: "4.101.0"),
],
targets: [
.target(
name: "Fluent",
dependencies: [
.product(name: "FluentKit", package: "fluent-kit"),
.product(name: "Vapor", package: "vapor"),
],
swiftSettings: swiftSettings
),
.testTarget(
name: "FluentTests",
dependencies: [
.target(name: "Fluent"),
.product(name: "XCTFluent", package: "fluent-kit"),
.product(name: "XCTVapor", package: "vapor"),
],
swiftSettings: swiftSettings
),
]
)
var swiftSettings: [SwiftSetting] { [
.enableUpcomingFeature("ExistentialAny"),
.enableUpcomingFeature("ConciseMagicFile"),
.enableUpcomingFeature("ForwardTrailingClosures"),
.enableUpcomingFeature("ImportObjcForwardDeclarations"),
.enableUpcomingFeature("DisableOutwardActorInference"),
.enableExperimentalFeature("StrictConcurrency=complete"),
] }
``` |
Austin Valley is a small ice-filled valley at the east side of Avalanche Ridge, in the Jones Mountains of Antarctica. It was mapped by the University of Minnesota Jones Mountains Party, 1960–61, and named by the Advisory Committee on Antarctic Names for Jerry W. Austin, aviation machinist's mate of U.S. Navy Squadron VX-6, a crew member on pioneering flights of LC-47 Dakota aircraft from Byrd Station to the Eights Coast area in November 1961.
References
Valleys of Antarctica
Landforms of Ellsworth Land |
Felix Smetana (1907 – 1968) was a German art director. He designed the sets for many Austrian and German films during the postwar era.
Selected filmography
Wedding in the Hay (1951)
Hello Porter (1952)
Ideal Woman Sought (1952)
Voices of Spring (1952)
The Immortal Vagabond (1953)
Lavender (1953)
The Bird Seller (1953)
The Sun of St. Moritz (1954)
Espionage (1955)
And Who Is Kissing Me? (1956)
The Beggar Student (1956)
Scandal in Bad Ischl (1957)
Almenrausch and Edelweiss (1957)
The Street (1958)
Girls for the Mambo-Bar (1959)
Beloved Augustin (1960)
Our Crazy Aunts (1961)
References
Bibliography
Fritsche, Maria. Homemade Men in Postwar Austrian Cinema: Nationhood, Genre and Masculinity. Berghahn Books, 2013.
External links
1907 births
1968 deaths
German art directors
Film people from Dresden |
Eduardo Sánchez de Fuentes (3 April 1874, in Havana – 7 September 1944) was a Cuban composer, and an author of books on the history of Cuban folk music.
The outstanding habanera Tú, written when he was sixteen, was his best-known composition. As an adult, he composed the scores for the opera Yumurí, the ballet Dioné, the oratorio Navidad and the cantata Anacaona.
His writings are still charming and informative today, though their standing has suffered from an accurate criticism by later musicologists. They realized that he had systematically underestimated the contribution of the Africans in Cuba. He insisted, instead, on the supposed contribution of Cuba's original aboriginal population, which was subsequently disproved.
"It is a shame that a succession of errors should have spoilt the greatest work of a man who had carried his musicianship for almost half a century with rare dignity. Because in the end...Sanchez de Fuentes will remain, above all, a composer of habaneras and songs. In a hundred years his Cuban melodies will occupy a place of honor in our traditions..."
His books
El folklore en la música cubana
Cuba y sus músicos
Influencia de los ritmos africanos en nuestro cancionero
La contradanza y la habanera
Ignacio Cervantes
Consideraciones sobre la música cubana
Viejos ritmos cubanos
La última firma de Brindis de Sala
La música aborigen de América
Foklorismo
References
External links
1874 births
1944 deaths
Contradanza
Cuban composers
Male composers
Cuban songwriters
Male songwriters
Cuban non-fiction writers
Cuban male writers
Male non-fiction writers
Cuban male musicians |
```python
from time import sleep
import pytest
import ray
from ray import workflow
from ray.workflow.http_event_provider import HTTPListener
from ray.tests.conftest import * # noqa
from ray import serve
from ray.workflow import common
from ray._private.test_utils import wait_for_condition
import requests
@pytest.mark.parametrize(
"workflow_start_regular_shared_serve",
[
{
"num_cpus": 4, # TODO (Alex): When we switch to the efficient event
# implementation we shouldn't need these extra cpus.
}
],
indirect=True,
)
def test_multiple_events_by_http(workflow_start_regular_shared_serve):
"""If a workflow has multiple event arguments, it should wait for them at the
same time.
"""
def send_event1():
resp = requests.post(
"path_to_url"
+ "workflow_test_multiple_event_by_http",
json={"event_key": "e1", "event_payload": "hello"},
)
return resp
def send_event2():
sleep(0.5)
resp = requests.post(
"path_to_url"
+ "workflow_test_multiple_event_by_http",
json={"event_key": "e2", "event_payload": "world"},
)
return resp
@ray.remote
def trivial_task(arg1, arg2):
return f"{arg1[1]} {arg2[1]}"
event1_promise = workflow.wait_for_event(HTTPListener, event_key="e1")
event2_promise = workflow.wait_for_event(HTTPListener, event_key="e2")
workflow.run_async(
trivial_task.bind(event1_promise, event2_promise),
workflow_id="workflow_test_multiple_event_by_http",
)
# wait until HTTPEventProvider is ready
def check_app_running():
status = serve.status().applications[common.HTTP_EVENT_PROVIDER_NAME]
assert status.status == "RUNNING"
return True
wait_for_condition(check_app_running)
# repeat send_event1() until the returned status code is not 404
while True:
res = send_event1()
if res.status_code == 404:
sleep(0.5)
else:
break
while True:
res = send_event2()
if res.status_code == 404:
sleep(0.5)
else:
break
event_msg = workflow.get_output(workflow_id="workflow_test_multiple_event_by_http")
assert event_msg == "hello world"
if __name__ == "__main__":
import sys
sys.exit(pytest.main(["-v", __file__]))
``` |
CTI Electronics Corporation is a manufacturer of industrial computer peripherals such as rugged keyboards, pointing devices, motion controllers, analog joysticks, USB keypads and many other industrial, military, medical, or aerospace grade input devices. CTI Electronics Corporation products are made in the United States and it is a well-known supplier of input devices to some of the most notable private defense contractors in the world, including Lockheed Martin, DRS Technologies, Computer Sciences Corporation, General Dynamics, BAE Systems, L3 Communications, AAI, Northrop Grumman, Raytheon, Boeing, Thales Group and many more companies that provide security and defense around the world. CTI also supplies Homeland Security and United States Department of Defense supporting their efforts in protecting and serving the country and military personnel of the United States.
Background
CTI Electronics Corporation was started in 1986 and is currently located in Stratford, Connecticut.
Industries
CTI's products are used all over the world in a variety of industries and specialize in highly reliable industrial-grade input devices for use harsh environments. Its products are currently being used in the control systems of UAVs, UUVs, and UGVs. CTI has also donated industrial joysticks to students of UW-Madison to for research into the Standing Paraplegic Omni-directional Transport (SPOT)
These products are not only used for military but are also used in the medical, industrial, and aerospace industries all over the world.
Product certifications
NEMA 4
NEMA 4X
NEMA 12
IP54
IP66
RoHS
CE
ISO 9001:2008
References
External links
CTI Electronics Home Page
Computer companies of the United States
Computer peripheral companies
Computer companies established in 1986
Electronics companies established in 1986
Companies based in Stratford, Connecticut
American companies established in 1986 |
Joseph Gallo may refer to:
Joseph Edward Gallo (1919–2007), cheese producer, brother of winemakers Ernest and Julio Gallo
Joseph N. Gallo (1912–1995), American gangster, consigliere of the Gambino crime family
Joe Gallo (1929–1972), also known as "Crazy Joe", American gangster, captain in the Colombo crime family
Joe Gallo (basketball) (born 1980), American basketball coach
Joey Gallo (born 1993), baseball player |
The Ca n'Oliver Iberian settlement is a very large Iberian settlement found in the Collserola mountain range, in the territory formerly known as Laietania, in present-day Cerdanyola del Vallès. It is an archaeological site that was inhabited between the 6th century and 50 BC and, later on, in the Middle Ages.
History
The settlement was inhabited during the time of the Iberians. Initially it was just rows of simple houses grouped together and built within a large plot of land. During the full Iberian period, the houses grew larger and diversified, and the settlement was at its most prosperous with the construction of an access road, moat, and a field of silos for storing leftover farm products, which were later sold to other Mediterranean towns.
The settlement was destroyed at the end of the 3rd or the beginning of the 2nd century BC, a result of the Punic Wars (218-206 BC), but it was rebuilt during the end of the Iberian period. Years later, with the arrival of the new territorial organisation imposed by the Romans, the Iberians abandoned the settlement for good.
During the 9th and 10th centuries, in the high Middle Ages, the settlement was once again inhabited, taking advantage of some of the Iberian buildings and silos.
Museumization
On 1 October 2010, the Ca n’Oliver Iberian Settlement and Museum was opened, located in the settlement's old quarry, which puts on display a wider selection of the large volume objects recovered during excavations and places the settlement on 'The Route of the Iberians', a cultural tourism project of the Archaeology Museum of Catalonia.
The museum is provided with a modern Interpretation Center intended to disseminate Iberian culture in Catalonia.
See also
Cerdanyola Art Museum. Can Domènech
Cerdanyola Museum
References
External links
Museum site
Local Museum Network site
Barcelona Provincial Council Local Museum Network
Archaeological sites in Catalonia
Cerdanyola del Vallès
Iberians
Archaeological museums in Catalonia |
The Association of Psychiatric Social Workers (APSW) was the main professional body for social workers looking after the welfare of mentally ill people in the United Kingdom from 1929 to 1970.
In 1970 the association merged with six other social workers' organisations to form the British Association of Social Workers, having been a member of the Standing Conference of Organisations of Social Workers since 1962.
The archives of the Association are held at Warwick University.
References
External links
Catalogue of the APSW archives, held at the Modern Records Centre, University of Warwick
Social work organisations in the United Kingdom
Former mental health organisations in the United Kingdom
History of mental health in the United Kingdom
Organizations established in 1929
Organizations disestablished in 1970 |
```java
//
//
// 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 google.registry.tools.params;
import static com.google.common.truth.Truth.assertThat;
import static google.registry.tools.params.NameserversParameter.splitNameservers;
import static org.junit.jupiter.api.Assertions.assertThrows;
import com.beust.jcommander.ParameterException;
import org.junit.jupiter.api.Test;
/** Unit tests for {@link NameserversParameter}. */
class NameserversParameterTest {
private final NameserversParameter instance = new NameserversParameter();
@Test
void testConvert_singleBasicNameserver() {
assertThat(instance.convert("ns11.goes.to")).containsExactly("ns11.goes.to");
}
@Test
void testConvert_multipleBasicNameservers() {
assertThat(instance.convert("ns1.tim.buktu, ns2.tim.buktu, ns3.tim.buktu"))
.containsExactly("ns1.tim.buktu", "ns2.tim.buktu", "ns3.tim.buktu");
}
@Test
void testConvert_kitchenSink() {
assertThat(instance.convert(" ns1.foo.bar, ,ns2.foo.bar,, ns[1-3].range.baz "))
.containsExactly(
"ns1.foo.bar", "ns2.foo.bar", "ns1.range.baz", "ns2.range.baz", "ns3.range.baz");
}
@Test
void testConvert_invalid() {
assertThat(instance.convert("ns1.foo.bar,ns2.foo.baz,ns3.foo.bar"))
.containsExactly("ns1.foo.bar", "ns3.foo.bar", "ns2.foo.baz");
}
@Test
void testValidate_sillyString_throws() {
ParameterException thrown =
assertThrows(ParameterException.class, () -> instance.validate("nameservers", "[[ns]]"));
assertThat(thrown).hasMessageThat().contains("Must be a comma-delimited list of nameservers");
assertThat(thrown).hasCauseThat().hasMessageThat().contains("Could not parse square brackets");
}
@Test
void testConvert_empty_returnsEmpty() {
assertThat(instance.convert("")).isEmpty();
}
@Test
void testConvert_nullString_returnsNull() {
assertThat(instance.convert(null)).isEmpty();
}
@Test
void testSplitNameservers_noopWithNoBrackets() {
assertThat(splitNameservers("ns9.fake.example")).containsExactly("ns9.fake.example");
}
@Test
void testSplitNameservers_worksWithBrackets() {
assertThat(splitNameservers("ns[1-4].zan.zibar"))
.containsExactly("ns1.zan.zibar", "ns2.zan.zibar", "ns3.zan.zibar", "ns4.zan.zibar");
}
@Test
void testSplitNameservers_worksWithBrackets_soloRange() {
assertThat(splitNameservers("ns[1-1].zan.zibar")).containsExactly("ns1.zan.zibar");
}
@Test
void testSplitNameservers_throwsOnInvalidRange() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("ns[9-2].foo.bar"));
assertThat(thrown).hasMessageThat().isEqualTo("Number range [9-2] is invalid");
}
@Test
void testSplitNameservers_throwsOnInvalidHostname_missingPrefix() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("[1-4].foo.bar"));
assertThat(thrown)
.hasMessageThat()
.isEqualTo("Could not parse square brackets in [1-4].foo.bar");
}
@Test
void testSplitNameservers_throwsOnInvalidHostname_missingDomainName() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("this.is.ns[1-5]"));
assertThat(thrown)
.hasMessageThat()
.isEqualTo("Could not parse square brackets in this.is.ns[1-5]");
}
@Test
void testSplitNameservers_throwsOnInvalidRangeSyntax() {
IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, () -> splitNameservers("ns[1-4[.foo.bar"));
assertThat(thrown).hasMessageThat().contains("Could not parse square brackets");
}
}
``` |
Tom Cotter (born June 29, 1972) is an American conservationist, entrepreneur, renewable energy advocate, and ordained evangelical minister living in Clovis, California.
Biography
Early life and inspiration
Tom Cotter grew up in Napa Valley, California, United States. A significant influence of his work was the Boy Scouts of America. In 1988, Cotter was awarded the title of Eagle Scout.
Professional career
In 1997, he was ordained clergy at First Christian Church in Napa, California. He served as a pastor at Clovis Christian Church in Clovis, California, from 1996 to 2006.
From 2006 to 2015, Cotter worked in sales leadership in the U.S. Photovoltaic Industry, starting at ReGrid Power, which was later acquired by Real Goods Solar. He also worked at Sunrun.
From 2015 to 2017, he worked as Regional Sales Manager at Renew Financial for the California counties of Fresno, Madera, Tulare, and Kings.
Cotter has worked as an adjunct professor of Theological Ethics and the Environment at Fresno Pacific University.
Personal life
Cotter resides in Clovis, California, with his wife, Christi Gaither, and their three children. The family has a lar power and solar thermal system in their home. Mr. Cotter drives a Nissan Leaf. Mrs. Cotter drives an alternative fuel VW Jetta TDI. The Cotter family uses vermiposting to turn kitchen scraps, junk mail, and paper packing materials into nutrient-rich soil for their garden and yard.
Cotter is a part of the California Climate Ride, a 320-mile bicycle benefit ride for bicycle advocacy and renewable energy down the coast of California from Eureka, California to San Francisco, California.
Sustainability education and advocacy
Community
In 2007, Cotter and Socient CEO, Victor Ramayrat, co-founded Green Fresno, a free online community and information portal (in 2012 it was relaunched as Green Central Valley).
Cotter is the organizer and curator of the annual Fresno Solar Tour part of the American Solar Energy Society's National Solar Tour.
Cotter is an Organizer of Fresno Earth Day, purposed to inspire and mobilize individuals and organizations to demonstrate their commitment to environmental protection and sustainability.
Cotter is the creator and organizer of Fresno Green Drinks, a monthly informal gathering of environmental field experts, educators, public servants, activists, and individuals looking to learn from and encourage one another toward broader ecological stewardship in the Fresno metro area. As of May 2012, Green Drinks was active in 642 cities worldwide.
In 2012, Cotter became a Climate Leader in the Climate Leadership Corps with the Climate Reality Project.
Cotter served as a Technical Advisory Committee Member for Energize Fresno in the Private Business, Development, and Finance Sector in 2017.
Board of directors
Cotter serves on the Board of Directors of the Solar Living Institute.
Cotter is the past president and chairman of the board of directors at the International Green Industry Hall of Fame, which promotes ecological sustainability worldwide by recognizing individuals and organizations for outstanding achievement(s) in the Green Industry and provides an educational forum for the international public.
Cotter is a past member of the board of directors at Restore Hetch Hetchy.
Film
Cotter is a producer of the short documentary film, Forest Man. The film chronicles the story of Jadav Payeng, an Indian man who single-handedly planted nearly 1,400 acres of forest to save his island, Majuli, India. The film is directed by William D. McMaster of Toronto, Ontario, Canada. The film was released in the summer, of 2013.
Political
In 2010, Cotter worked with California's No on Prop 23 Campaign. This proposition would have suspended AB 32, a law enacted in 2006 legally referred to as the Global Warming Solutions Act of 2006. Prop 23 was defeated by California voters during the statewide election by a 23% margin.
In 2012, Cotter worked to get the California Public Utilities Commission (CPUC) to expand net metering in California.
In 2012, Cotter worked to get the passing of Proposition 39 - California Clean Energy Jobs Act.
References
1972 births
Living people
People from Clovis, California
People from Napa County, California
People associated with renewable energy
Christianity and environmentalism
21st-century Protestant religious leaders
Renewable energy in the United States
American motivational speakers
Activists from California
American conservationists |
Plouguenast-Langast (; ) is a commune in the Côtes-d'Armor department of Brittany in northwestern France. It was established on 1 January 2019 by merger of the former communes of Plouguenast (the seat) and Langast.
Geography
Climate
Plouguenast-Langast has a oceanic climate (Köppen climate classification Cfb). The average annual temperature in Plouguenast-Langast is . The average annual rainfall is with January as the wettest month. The temperatures are highest on average in August, at around , and lowest in January, at around . The highest temperature ever recorded in Plouguenast-Langast was on 9 August 2003; the coldest temperature ever recorded was on 2 January 1997.
Population
See also
Communes of the Côtes-d'Armor department
References
Communes of Côtes-d'Armor
Communes nouvelles of Côtes-d'Armor
Populated places established in 2019
2019 establishments in France |
```smalltalk
// This file is part of Core WF which is licensed under the MIT license.
// See LICENSE file in the project root for full license information.
using System.Threading;
namespace System.Activities.Runtime.DurableInstancing;
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
internal class SignalGate
{
[Fx.Tag.SynchronizationObject(Blocking = false, Kind = Fx.Tag.SynchronizationKind.InterlockedNoSpin)]
private int _state;
public SignalGate() { }
internal bool IsLocked => _state == GateState.Locked;
internal bool IsSignalled => _state == GateState.Signalled;
// Returns true if this brings the gate to the Signalled state.
// Transitions - Locked -> SignalPending | Completed before it was unlocked
// Unlocked -> Signaled
public bool Signal()
{
int lastState = _state;
if (lastState == GateState.Locked)
{
lastState = Interlocked.CompareExchange(ref _state, GateState.SignalPending, GateState.Locked);
}
if (lastState == GateState.Unlocked)
{
_state = GateState.Signalled;
return true;
}
if (lastState != GateState.Locked)
{
ThrowInvalidSignalGateState();
}
return false;
}
// Returns true if this brings the gate to the Signalled state.
// Transitions - SignalPending -> Signaled | return the AsyncResult since the callback already
// | completed and provided the result on its thread
// Locked -> Unlocked
public bool Unlock()
{
int lastState = _state;
if (lastState == GateState.Locked)
{
lastState = Interlocked.CompareExchange(ref _state, GateState.Unlocked, GateState.Locked);
}
if (lastState == GateState.SignalPending)
{
_state = GateState.Signalled;
return true;
}
if (lastState != GateState.Locked)
{
ThrowInvalidSignalGateState();
}
return false;
}
// This is factored out to allow Signal and Unlock to be inlined.
private static void ThrowInvalidSignalGateState() => throw Fx.Exception.AsError(new InvalidOperationException(SR.InvalidSemaphoreExit));
private static class GateState
{
public const int Locked = 0;
public const int SignalPending = 1;
public const int Unlocked = 2;
public const int Signalled = 3;
}
}
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
internal class SignalGate<T> : SignalGate
{
private T _result;
public SignalGate()
: base() { }
public bool Signal(T result)
{
_result = result;
return Signal();
}
public bool Unlock(out T result)
{
if (Unlock())
{
result = _result;
return true;
}
result = default;
return false;
}
}
``` |
The Florida Entomologist is an quarterly open access scientific journal published by the Florida Entomological Society. Founded in 1917 as “The Florida Buggist” and in 1920 was renamed, into “The Florida Entomologist.” Manuscripts from all disciplines of entomology are accepted for consideration. The chief editor is James Nation of the University of Florida. According to the 2013 Journal Citation Reports, the impact factor of The Florida Entomologist is 0.975 which ranks it 50/94 in "Entomology".
It is notable as the first journal to experiment with a hybrid open access business model.
References
Bibliography
Denmark H. A. 1993. An overview of the history of the Florida Entomological Society on its diamond or seventy-fifth anniversary (1916–1992). Florida Entomologist 76: 407–416.
Tissot A.N., Murphey Jr. M., Waites R.E. 1954. A brief history of entomology in Florida. Florida Entomologist 37: 51–71.
External links
Entomology journals and magazines |
Saint Julian the Hospitaller is a fresco fragment of 1454–1458 by Piero della Francesca, originally in the former church of Sant'Agostino in Sansepolcro, Tuscany, and now in that city's Museo Civico alongside other works by the artist such as the Resurrection and Saint Louis of Toulouse.
The work dates to the same period as the artist's The History of the True Cross frescoes in Arezzo. It depicts Julian the Hospitaller as an unarmed knight in a red robe over a contemporary green costume. The saint's legs, waist, hands and one shoulder were lost during the work's detachment from its original wall.
References
Piero
Paintings by Piero della Francesca
Fresco paintings in Sansepolcro
1458 paintings
Paintings in the Museo Civico di Sansepolcro |
Amjad Ali may refer to:
Amjad Ali (Fijian politician), Fiji Indian politician
Amjad Ali (cricketer) (born 1979), United Arab Emirates cricketer
Amjad Ali (civil servant) (1907–1997), Pakistani civil servant
Amjad Ali (Pakistani politician) (born 1973), Pakistani politician
Amjad Ali (Assam politician) (born 1903), Indian parliament member
Amjad Ali Khan (politician) (born 1972), Pakistani politician
See also
Nawab Ali Amjad Khan (1871–1905), Bengali politician |
The was an infantry division of the Imperial Japanese Army. Its call sign was the , after Kikuchi, Kumamoto. It was formed on 2 April 1945 in Kurume as a triangular division. It was one of a batch of eight divisions composed of the 201st, 202nd, 205th, 206th, 209th, 212th, 214th and 216th Divisions created as part of the reaction to the Battle of Okinawa.
History
On 11 June 1945, the 212th Division organization and deployment was complete. The 516th and 518th Infantry Regiments, together with service units, were in Tsuno, Miyazaki, while the 517th infantry regiment was in Kurume It did not see any combat by the time of the surrender of Japan on 15 August 1945.
See also
List of Japanese Infantry Divisions
Notes and references
This article incorporates material from Japanese Wikipedia page 第212師団 (日本軍), accessed 20 July 2016
Madej, W. Victor, Japanese Armed Forces Order of Battle, 1937–1945 [2 vols], Allentown, PA: 1981.
Japanese World War II divisions
Infantry divisions of Japan
Military units and formations established in 1945
Military units and formations disestablished in 1945
1945 establishments in Japan
1945 disestablishments in Japan |
```go
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/genomics/v1alpha2/pipelines.proto
package genomics
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
duration "github.com/golang/protobuf/ptypes/duration"
empty "github.com/golang/protobuf/ptypes/empty"
timestamp "github.com/golang/protobuf/ptypes/timestamp"
_ "google.golang.org/genproto/googleapis/api/annotations"
longrunning "google.golang.org/genproto/googleapis/longrunning"
code "google.golang.org/genproto/googleapis/rpc/code"
math "math"
)
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// The types of disks that may be attached to VMs.
type PipelineResources_Disk_Type int32
const (
// Default disk type. Use one of the other options below.
PipelineResources_Disk_TYPE_UNSPECIFIED PipelineResources_Disk_Type = 0
// Specifies a Google Compute Engine persistent hard disk. See
// path_to_url#pdspecs for details.
PipelineResources_Disk_PERSISTENT_HDD PipelineResources_Disk_Type = 1
// Specifies a Google Compute Engine persistent solid-state disk. See
// path_to_url#pdspecs for details.
PipelineResources_Disk_PERSISTENT_SSD PipelineResources_Disk_Type = 2
// Specifies a Google Compute Engine local SSD.
// See path_to_url for details.
PipelineResources_Disk_LOCAL_SSD PipelineResources_Disk_Type = 3
)
var PipelineResources_Disk_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "PERSISTENT_HDD",
2: "PERSISTENT_SSD",
3: "LOCAL_SSD",
}
var PipelineResources_Disk_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"PERSISTENT_HDD": 1,
"PERSISTENT_SSD": 2,
"LOCAL_SSD": 3,
}
func (x PipelineResources_Disk_Type) String() string {
return proto.EnumName(PipelineResources_Disk_Type_name, int32(x))
}
func (PipelineResources_Disk_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{16, 0, 0}
}
// Describes a Compute Engine resource that is being managed by a running
// [pipeline][google.genomics.v1alpha2.Pipeline].
type ComputeEngine struct {
// The instance on which the operation is running.
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
// The availability zone in which the instance resides.
Zone string `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
// The machine type of the instance.
MachineType string `protobuf:"bytes,3,opt,name=machine_type,json=machineType,proto3" json:"machine_type,omitempty"`
// The names of the disks that were created for this pipeline.
DiskNames []string `protobuf:"bytes,4,rep,name=disk_names,json=diskNames,proto3" json:"disk_names,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ComputeEngine) Reset() { *m = ComputeEngine{} }
func (m *ComputeEngine) String() string { return proto.CompactTextString(m) }
func (*ComputeEngine) ProtoMessage() {}
func (*ComputeEngine) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{0}
}
func (m *ComputeEngine) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ComputeEngine.Unmarshal(m, b)
}
func (m *ComputeEngine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ComputeEngine.Marshal(b, m, deterministic)
}
func (m *ComputeEngine) XXX_Merge(src proto.Message) {
xxx_messageInfo_ComputeEngine.Merge(m, src)
}
func (m *ComputeEngine) XXX_Size() int {
return xxx_messageInfo_ComputeEngine.Size(m)
}
func (m *ComputeEngine) XXX_DiscardUnknown() {
xxx_messageInfo_ComputeEngine.DiscardUnknown(m)
}
var xxx_messageInfo_ComputeEngine proto.InternalMessageInfo
func (m *ComputeEngine) GetInstanceName() string {
if m != nil {
return m.InstanceName
}
return ""
}
func (m *ComputeEngine) GetZone() string {
if m != nil {
return m.Zone
}
return ""
}
func (m *ComputeEngine) GetMachineType() string {
if m != nil {
return m.MachineType
}
return ""
}
func (m *ComputeEngine) GetDiskNames() []string {
if m != nil {
return m.DiskNames
}
return nil
}
// Runtime metadata that will be populated in the
// [runtimeMetadata][google.genomics.v1.OperationMetadata.runtime_metadata]
// field of the Operation associated with a RunPipeline execution.
type RuntimeMetadata struct {
// Execution information specific to Google Compute Engine.
ComputeEngine *ComputeEngine `protobuf:"bytes,1,opt,name=compute_engine,json=computeEngine,proto3" json:"compute_engine,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RuntimeMetadata) Reset() { *m = RuntimeMetadata{} }
func (m *RuntimeMetadata) String() string { return proto.CompactTextString(m) }
func (*RuntimeMetadata) ProtoMessage() {}
func (*RuntimeMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{1}
}
func (m *RuntimeMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RuntimeMetadata.Unmarshal(m, b)
}
func (m *RuntimeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RuntimeMetadata.Marshal(b, m, deterministic)
}
func (m *RuntimeMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_RuntimeMetadata.Merge(m, src)
}
func (m *RuntimeMetadata) XXX_Size() int {
return xxx_messageInfo_RuntimeMetadata.Size(m)
}
func (m *RuntimeMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_RuntimeMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_RuntimeMetadata proto.InternalMessageInfo
func (m *RuntimeMetadata) GetComputeEngine() *ComputeEngine {
if m != nil {
return m.ComputeEngine
}
return nil
}
// The pipeline object. Represents a transformation from a set of input
// parameters to a set of output parameters. The transformation is defined
// as a docker image and command to run within that image. Each pipeline
// is run on a Google Compute Engine VM. A pipeline can be created with the
// `create` method and then later run with the `run` method, or a pipeline can
// be defined and run all at once with the `run` method.
type Pipeline struct {
// Required. The project in which to create the pipeline. The caller must have
// WRITE access.
ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
// Required. A user specified pipeline name that does not have to be unique.
// This name can be used for filtering Pipelines in ListPipelines.
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// User-specified description.
Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
// Input parameters of the pipeline.
InputParameters []*PipelineParameter `protobuf:"bytes,8,rep,name=input_parameters,json=inputParameters,proto3" json:"input_parameters,omitempty"`
// Output parameters of the pipeline.
OutputParameters []*PipelineParameter `protobuf:"bytes,9,rep,name=output_parameters,json=outputParameters,proto3" json:"output_parameters,omitempty"`
// Required. The executor indicates in which environment the pipeline runs.
//
// Types that are valid to be assigned to Executor:
// *Pipeline_Docker
Executor isPipeline_Executor `protobuf_oneof:"executor"`
// Required. Specifies resource requirements for the pipeline run.
// Required fields:
//
// *
// [minimumCpuCores][google.genomics.v1alpha2.PipelineResources.minimum_cpu_cores]
//
// *
// [minimumRamGb][google.genomics.v1alpha2.PipelineResources.minimum_ram_gb]
Resources *PipelineResources `protobuf:"bytes,6,opt,name=resources,proto3" json:"resources,omitempty"`
// Unique pipeline id that is generated by the service when CreatePipeline
// is called. Cannot be specified in the Pipeline used in the
// CreatePipelineRequest, and will be populated in the response to
// CreatePipeline and all subsequent Get and List calls. Indicates that the
// service has registered this pipeline.
PipelineId string `protobuf:"bytes,7,opt,name=pipeline_id,json=pipelineId,proto3" json:"pipeline_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Pipeline) Reset() { *m = Pipeline{} }
func (m *Pipeline) String() string { return proto.CompactTextString(m) }
func (*Pipeline) ProtoMessage() {}
func (*Pipeline) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{2}
}
func (m *Pipeline) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Pipeline.Unmarshal(m, b)
}
func (m *Pipeline) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Pipeline.Marshal(b, m, deterministic)
}
func (m *Pipeline) XXX_Merge(src proto.Message) {
xxx_messageInfo_Pipeline.Merge(m, src)
}
func (m *Pipeline) XXX_Size() int {
return xxx_messageInfo_Pipeline.Size(m)
}
func (m *Pipeline) XXX_DiscardUnknown() {
xxx_messageInfo_Pipeline.DiscardUnknown(m)
}
var xxx_messageInfo_Pipeline proto.InternalMessageInfo
func (m *Pipeline) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *Pipeline) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Pipeline) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Pipeline) GetInputParameters() []*PipelineParameter {
if m != nil {
return m.InputParameters
}
return nil
}
func (m *Pipeline) GetOutputParameters() []*PipelineParameter {
if m != nil {
return m.OutputParameters
}
return nil
}
type isPipeline_Executor interface {
isPipeline_Executor()
}
type Pipeline_Docker struct {
Docker *DockerExecutor `protobuf:"bytes,5,opt,name=docker,proto3,oneof"`
}
func (*Pipeline_Docker) isPipeline_Executor() {}
func (m *Pipeline) GetExecutor() isPipeline_Executor {
if m != nil {
return m.Executor
}
return nil
}
func (m *Pipeline) GetDocker() *DockerExecutor {
if x, ok := m.GetExecutor().(*Pipeline_Docker); ok {
return x.Docker
}
return nil
}
func (m *Pipeline) GetResources() *PipelineResources {
if m != nil {
return m.Resources
}
return nil
}
func (m *Pipeline) GetPipelineId() string {
if m != nil {
return m.PipelineId
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Pipeline) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Pipeline_OneofMarshaler, _Pipeline_OneofUnmarshaler, _Pipeline_OneofSizer, []interface{}{
(*Pipeline_Docker)(nil),
}
}
func _Pipeline_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Pipeline)
// executor
switch x := m.Executor.(type) {
case *Pipeline_Docker:
b.EncodeVarint(5<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Docker); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("Pipeline.Executor has unexpected type %T", x)
}
return nil
}
func _Pipeline_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Pipeline)
switch tag {
case 5: // executor.docker
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(DockerExecutor)
err := b.DecodeMessage(msg)
m.Executor = &Pipeline_Docker{msg}
return true, err
default:
return false, nil
}
}
func _Pipeline_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Pipeline)
// executor
switch x := m.Executor.(type) {
case *Pipeline_Docker:
s := proto.Size(x.Docker)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// The request to create a pipeline. The pipeline field here should not have
// `pipelineId` populated, as that will be populated by the server.
type CreatePipelineRequest struct {
// The pipeline to create. Should not have `pipelineId` populated.
Pipeline *Pipeline `protobuf:"bytes,1,opt,name=pipeline,proto3" json:"pipeline,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreatePipelineRequest) Reset() { *m = CreatePipelineRequest{} }
func (m *CreatePipelineRequest) String() string { return proto.CompactTextString(m) }
func (*CreatePipelineRequest) ProtoMessage() {}
func (*CreatePipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{3}
}
func (m *CreatePipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreatePipelineRequest.Unmarshal(m, b)
}
func (m *CreatePipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreatePipelineRequest.Marshal(b, m, deterministic)
}
func (m *CreatePipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreatePipelineRequest.Merge(m, src)
}
func (m *CreatePipelineRequest) XXX_Size() int {
return xxx_messageInfo_CreatePipelineRequest.Size(m)
}
func (m *CreatePipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreatePipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreatePipelineRequest proto.InternalMessageInfo
func (m *CreatePipelineRequest) GetPipeline() *Pipeline {
if m != nil {
return m.Pipeline
}
return nil
}
// The pipeline run arguments.
type RunPipelineArgs struct {
// Required. The project in which to run the pipeline. The caller must have
// WRITER access to all Google Cloud services and resources (e.g. Google
// Compute Engine) will be used.
ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
// Pipeline input arguments; keys are defined in the pipeline documentation.
// All input parameters that do not have default values must be specified.
// If parameters with defaults are specified here, the defaults will be
// overridden.
Inputs map[string]string `protobuf:"bytes,2,rep,name=inputs,proto3" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Pipeline output arguments; keys are defined in the pipeline
// documentation. All output parameters of without default values
// must be specified. If parameters with defaults are specified
// here, the defaults will be overridden.
Outputs map[string]string `protobuf:"bytes,3,rep,name=outputs,proto3" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The Google Cloud Service Account that will be used to access data and
// services. By default, the compute service account associated with
// `projectId` is used.
ServiceAccount *ServiceAccount `protobuf:"bytes,4,opt,name=service_account,json=serviceAccount,proto3" json:"service_account,omitempty"`
// This field is deprecated. Use `labels` instead. Client-specified pipeline
// operation identifier.
ClientId string `protobuf:"bytes,5,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
// Specifies resource requirements/overrides for the pipeline run.
Resources *PipelineResources `protobuf:"bytes,6,opt,name=resources,proto3" json:"resources,omitempty"`
// Required. Logging options. Used by the service to communicate results
// to the user.
Logging *LoggingOptions `protobuf:"bytes,7,opt,name=logging,proto3" json:"logging,omitempty"`
// How long to keep the VM up after a failure (for example docker command
// failed, copying input or output files failed, etc). While the VM is up, one
// can ssh into the VM to debug. Default is 0; maximum allowed value is 1 day.
KeepVmAliveOnFailureDuration *duration.Duration `protobuf:"bytes,8,opt,name=keep_vm_alive_on_failure_duration,json=keepVmAliveOnFailureDuration,proto3" json:"keep_vm_alive_on_failure_duration,omitempty"`
// Labels to apply to this pipeline run. Labels will also be applied to
// compute resources (VM, disks) created by this pipeline run. When listing
// operations, operations can [filtered by labels]
// [google.longrunning.ListOperationsRequest.filter].
// Label keys may not be empty; label values may be empty. Non-empty labels
// must be 1-63 characters long, and comply with [RFC1035]
// (path_to_url
// Specifically, the name must be 1-63 characters long and match the regular
// expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first
// character must be a lowercase letter, and all following characters must be
// a dash, lowercase letter, or digit, except the last character, which cannot
// be a dash.
Labels map[string]string `protobuf:"bytes,9,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RunPipelineArgs) Reset() { *m = RunPipelineArgs{} }
func (m *RunPipelineArgs) String() string { return proto.CompactTextString(m) }
func (*RunPipelineArgs) ProtoMessage() {}
func (*RunPipelineArgs) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{4}
}
func (m *RunPipelineArgs) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RunPipelineArgs.Unmarshal(m, b)
}
func (m *RunPipelineArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RunPipelineArgs.Marshal(b, m, deterministic)
}
func (m *RunPipelineArgs) XXX_Merge(src proto.Message) {
xxx_messageInfo_RunPipelineArgs.Merge(m, src)
}
func (m *RunPipelineArgs) XXX_Size() int {
return xxx_messageInfo_RunPipelineArgs.Size(m)
}
func (m *RunPipelineArgs) XXX_DiscardUnknown() {
xxx_messageInfo_RunPipelineArgs.DiscardUnknown(m)
}
var xxx_messageInfo_RunPipelineArgs proto.InternalMessageInfo
func (m *RunPipelineArgs) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *RunPipelineArgs) GetInputs() map[string]string {
if m != nil {
return m.Inputs
}
return nil
}
func (m *RunPipelineArgs) GetOutputs() map[string]string {
if m != nil {
return m.Outputs
}
return nil
}
func (m *RunPipelineArgs) GetServiceAccount() *ServiceAccount {
if m != nil {
return m.ServiceAccount
}
return nil
}
func (m *RunPipelineArgs) GetClientId() string {
if m != nil {
return m.ClientId
}
return ""
}
func (m *RunPipelineArgs) GetResources() *PipelineResources {
if m != nil {
return m.Resources
}
return nil
}
func (m *RunPipelineArgs) GetLogging() *LoggingOptions {
if m != nil {
return m.Logging
}
return nil
}
func (m *RunPipelineArgs) GetKeepVmAliveOnFailureDuration() *duration.Duration {
if m != nil {
return m.KeepVmAliveOnFailureDuration
}
return nil
}
func (m *RunPipelineArgs) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
// The request to run a pipeline. If `pipelineId` is specified, it
// refers to a saved pipeline created with CreatePipeline and set as
// the `pipelineId` of the returned Pipeline object. If
// `ephemeralPipeline` is specified, that pipeline is run once
// with the given args and not saved. It is an error to specify both
// `pipelineId` and `ephemeralPipeline`. `pipelineArgs`
// must be specified.
type RunPipelineRequest struct {
// Types that are valid to be assigned to Pipeline:
// *RunPipelineRequest_PipelineId
// *RunPipelineRequest_EphemeralPipeline
Pipeline isRunPipelineRequest_Pipeline `protobuf_oneof:"pipeline"`
// The arguments to use when running this pipeline.
PipelineArgs *RunPipelineArgs `protobuf:"bytes,3,opt,name=pipeline_args,json=pipelineArgs,proto3" json:"pipeline_args,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RunPipelineRequest) Reset() { *m = RunPipelineRequest{} }
func (m *RunPipelineRequest) String() string { return proto.CompactTextString(m) }
func (*RunPipelineRequest) ProtoMessage() {}
func (*RunPipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{5}
}
func (m *RunPipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RunPipelineRequest.Unmarshal(m, b)
}
func (m *RunPipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RunPipelineRequest.Marshal(b, m, deterministic)
}
func (m *RunPipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_RunPipelineRequest.Merge(m, src)
}
func (m *RunPipelineRequest) XXX_Size() int {
return xxx_messageInfo_RunPipelineRequest.Size(m)
}
func (m *RunPipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_RunPipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_RunPipelineRequest proto.InternalMessageInfo
type isRunPipelineRequest_Pipeline interface {
isRunPipelineRequest_Pipeline()
}
type RunPipelineRequest_PipelineId struct {
PipelineId string `protobuf:"bytes,1,opt,name=pipeline_id,json=pipelineId,proto3,oneof"`
}
type RunPipelineRequest_EphemeralPipeline struct {
EphemeralPipeline *Pipeline `protobuf:"bytes,2,opt,name=ephemeral_pipeline,json=ephemeralPipeline,proto3,oneof"`
}
func (*RunPipelineRequest_PipelineId) isRunPipelineRequest_Pipeline() {}
func (*RunPipelineRequest_EphemeralPipeline) isRunPipelineRequest_Pipeline() {}
func (m *RunPipelineRequest) GetPipeline() isRunPipelineRequest_Pipeline {
if m != nil {
return m.Pipeline
}
return nil
}
func (m *RunPipelineRequest) GetPipelineId() string {
if x, ok := m.GetPipeline().(*RunPipelineRequest_PipelineId); ok {
return x.PipelineId
}
return ""
}
func (m *RunPipelineRequest) GetEphemeralPipeline() *Pipeline {
if x, ok := m.GetPipeline().(*RunPipelineRequest_EphemeralPipeline); ok {
return x.EphemeralPipeline
}
return nil
}
func (m *RunPipelineRequest) GetPipelineArgs() *RunPipelineArgs {
if m != nil {
return m.PipelineArgs
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*RunPipelineRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _RunPipelineRequest_OneofMarshaler, _RunPipelineRequest_OneofUnmarshaler, _RunPipelineRequest_OneofSizer, []interface{}{
(*RunPipelineRequest_PipelineId)(nil),
(*RunPipelineRequest_EphemeralPipeline)(nil),
}
}
func _RunPipelineRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*RunPipelineRequest)
// pipeline
switch x := m.Pipeline.(type) {
case *RunPipelineRequest_PipelineId:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.PipelineId)
case *RunPipelineRequest_EphemeralPipeline:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.EphemeralPipeline); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("RunPipelineRequest.Pipeline has unexpected type %T", x)
}
return nil
}
func _RunPipelineRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*RunPipelineRequest)
switch tag {
case 1: // pipeline.pipeline_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Pipeline = &RunPipelineRequest_PipelineId{x}
return true, err
case 2: // pipeline.ephemeral_pipeline
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Pipeline)
err := b.DecodeMessage(msg)
m.Pipeline = &RunPipelineRequest_EphemeralPipeline{msg}
return true, err
default:
return false, nil
}
}
func _RunPipelineRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*RunPipelineRequest)
// pipeline
switch x := m.Pipeline.(type) {
case *RunPipelineRequest_PipelineId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.PipelineId)))
n += len(x.PipelineId)
case *RunPipelineRequest_EphemeralPipeline:
s := proto.Size(x.EphemeralPipeline)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A request to get a saved pipeline by id.
type GetPipelineRequest struct {
// Caller must have READ access to the project in which this pipeline
// is defined.
PipelineId string `protobuf:"bytes,1,opt,name=pipeline_id,json=pipelineId,proto3" json:"pipeline_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetPipelineRequest) Reset() { *m = GetPipelineRequest{} }
func (m *GetPipelineRequest) String() string { return proto.CompactTextString(m) }
func (*GetPipelineRequest) ProtoMessage() {}
func (*GetPipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{6}
}
func (m *GetPipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetPipelineRequest.Unmarshal(m, b)
}
func (m *GetPipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetPipelineRequest.Marshal(b, m, deterministic)
}
func (m *GetPipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetPipelineRequest.Merge(m, src)
}
func (m *GetPipelineRequest) XXX_Size() int {
return xxx_messageInfo_GetPipelineRequest.Size(m)
}
func (m *GetPipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetPipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetPipelineRequest proto.InternalMessageInfo
func (m *GetPipelineRequest) GetPipelineId() string {
if m != nil {
return m.PipelineId
}
return ""
}
// A request to list pipelines in a given project. Pipelines can be
// filtered by name using `namePrefix`: all pipelines with names that
// begin with `namePrefix` will be returned. Uses standard pagination:
// `pageSize` indicates how many pipelines to return, and
// `pageToken` comes from a previous ListPipelinesResponse to
// indicate offset.
type ListPipelinesRequest struct {
// Required. The name of the project to search for pipelines. Caller
// must have READ access to this project.
ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
// Pipelines with names that match this prefix should be
// returned. If unspecified, all pipelines in the project, up to
// `pageSize`, will be returned.
NamePrefix string `protobuf:"bytes,2,opt,name=name_prefix,json=namePrefix,proto3" json:"name_prefix,omitempty"`
// Number of pipelines to return at once. Defaults to 256, and max
// is 2048.
PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Token to use to indicate where to start getting results.
// If unspecified, returns the first page of results.
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListPipelinesRequest) Reset() { *m = ListPipelinesRequest{} }
func (m *ListPipelinesRequest) String() string { return proto.CompactTextString(m) }
func (*ListPipelinesRequest) ProtoMessage() {}
func (*ListPipelinesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{7}
}
func (m *ListPipelinesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListPipelinesRequest.Unmarshal(m, b)
}
func (m *ListPipelinesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListPipelinesRequest.Marshal(b, m, deterministic)
}
func (m *ListPipelinesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListPipelinesRequest.Merge(m, src)
}
func (m *ListPipelinesRequest) XXX_Size() int {
return xxx_messageInfo_ListPipelinesRequest.Size(m)
}
func (m *ListPipelinesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListPipelinesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListPipelinesRequest proto.InternalMessageInfo
func (m *ListPipelinesRequest) GetProjectId() string {
if m != nil {
return m.ProjectId
}
return ""
}
func (m *ListPipelinesRequest) GetNamePrefix() string {
if m != nil {
return m.NamePrefix
}
return ""
}
func (m *ListPipelinesRequest) GetPageSize() int32 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListPipelinesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
// The response of ListPipelines. Contains at most `pageSize`
// pipelines. If it contains `pageSize` pipelines, and more pipelines
// exist, then `nextPageToken` will be populated and should be
// used as the `pageToken` argument to a subsequent ListPipelines
// request.
type ListPipelinesResponse struct {
// The matched pipelines.
Pipelines []*Pipeline `protobuf:"bytes,1,rep,name=pipelines,proto3" json:"pipelines,omitempty"`
// The token to use to get the next page of results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListPipelinesResponse) Reset() { *m = ListPipelinesResponse{} }
func (m *ListPipelinesResponse) String() string { return proto.CompactTextString(m) }
func (*ListPipelinesResponse) ProtoMessage() {}
func (*ListPipelinesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{8}
}
func (m *ListPipelinesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListPipelinesResponse.Unmarshal(m, b)
}
func (m *ListPipelinesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListPipelinesResponse.Marshal(b, m, deterministic)
}
func (m *ListPipelinesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListPipelinesResponse.Merge(m, src)
}
func (m *ListPipelinesResponse) XXX_Size() int {
return xxx_messageInfo_ListPipelinesResponse.Size(m)
}
func (m *ListPipelinesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListPipelinesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListPipelinesResponse proto.InternalMessageInfo
func (m *ListPipelinesResponse) GetPipelines() []*Pipeline {
if m != nil {
return m.Pipelines
}
return nil
}
func (m *ListPipelinesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
// The request to delete a saved pipeline by ID.
type DeletePipelineRequest struct {
// Caller must have WRITE access to the project in which this pipeline
// is defined.
PipelineId string `protobuf:"bytes,1,opt,name=pipeline_id,json=pipelineId,proto3" json:"pipeline_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeletePipelineRequest) Reset() { *m = DeletePipelineRequest{} }
func (m *DeletePipelineRequest) String() string { return proto.CompactTextString(m) }
func (*DeletePipelineRequest) ProtoMessage() {}
func (*DeletePipelineRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{9}
}
func (m *DeletePipelineRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeletePipelineRequest.Unmarshal(m, b)
}
func (m *DeletePipelineRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeletePipelineRequest.Marshal(b, m, deterministic)
}
func (m *DeletePipelineRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeletePipelineRequest.Merge(m, src)
}
func (m *DeletePipelineRequest) XXX_Size() int {
return xxx_messageInfo_DeletePipelineRequest.Size(m)
}
func (m *DeletePipelineRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeletePipelineRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeletePipelineRequest proto.InternalMessageInfo
func (m *DeletePipelineRequest) GetPipelineId() string {
if m != nil {
return m.PipelineId
}
return ""
}
// Request to get controller configuation. Should only be used
// by VMs created by the Pipelines Service and not by end users.
type GetControllerConfigRequest struct {
// The operation to retrieve controller configuration for.
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"`
ValidationToken uint64 `protobuf:"varint,2,opt,name=validation_token,json=validationToken,proto3" json:"validation_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetControllerConfigRequest) Reset() { *m = GetControllerConfigRequest{} }
func (m *GetControllerConfigRequest) String() string { return proto.CompactTextString(m) }
func (*GetControllerConfigRequest) ProtoMessage() {}
func (*GetControllerConfigRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{10}
}
func (m *GetControllerConfigRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetControllerConfigRequest.Unmarshal(m, b)
}
func (m *GetControllerConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetControllerConfigRequest.Marshal(b, m, deterministic)
}
func (m *GetControllerConfigRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetControllerConfigRequest.Merge(m, src)
}
func (m *GetControllerConfigRequest) XXX_Size() int {
return xxx_messageInfo_GetControllerConfigRequest.Size(m)
}
func (m *GetControllerConfigRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetControllerConfigRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetControllerConfigRequest proto.InternalMessageInfo
func (m *GetControllerConfigRequest) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *GetControllerConfigRequest) GetValidationToken() uint64 {
if m != nil {
return m.ValidationToken
}
return 0
}
// Stores the information that the controller will fetch from the
// server in order to run. Should only be used by VMs created by the
// Pipelines Service and not by end users.
type ControllerConfig struct {
Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
Cmd string `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
GcsLogPath string `protobuf:"bytes,3,opt,name=gcs_log_path,json=gcsLogPath,proto3" json:"gcs_log_path,omitempty"`
MachineType string `protobuf:"bytes,4,opt,name=machine_type,json=machineType,proto3" json:"machine_type,omitempty"`
Vars map[string]string `protobuf:"bytes,5,rep,name=vars,proto3" json:"vars,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Disks map[string]string `protobuf:"bytes,6,rep,name=disks,proto3" json:"disks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
GcsSources map[string]*ControllerConfig_RepeatedString `protobuf:"bytes,7,rep,name=gcs_sources,json=gcsSources,proto3" json:"gcs_sources,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
GcsSinks map[string]*ControllerConfig_RepeatedString `protobuf:"bytes,8,rep,name=gcs_sinks,json=gcsSinks,proto3" json:"gcs_sinks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ControllerConfig) Reset() { *m = ControllerConfig{} }
func (m *ControllerConfig) String() string { return proto.CompactTextString(m) }
func (*ControllerConfig) ProtoMessage() {}
func (*ControllerConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{11}
}
func (m *ControllerConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ControllerConfig.Unmarshal(m, b)
}
func (m *ControllerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ControllerConfig.Marshal(b, m, deterministic)
}
func (m *ControllerConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_ControllerConfig.Merge(m, src)
}
func (m *ControllerConfig) XXX_Size() int {
return xxx_messageInfo_ControllerConfig.Size(m)
}
func (m *ControllerConfig) XXX_DiscardUnknown() {
xxx_messageInfo_ControllerConfig.DiscardUnknown(m)
}
var xxx_messageInfo_ControllerConfig proto.InternalMessageInfo
func (m *ControllerConfig) GetImage() string {
if m != nil {
return m.Image
}
return ""
}
func (m *ControllerConfig) GetCmd() string {
if m != nil {
return m.Cmd
}
return ""
}
func (m *ControllerConfig) GetGcsLogPath() string {
if m != nil {
return m.GcsLogPath
}
return ""
}
func (m *ControllerConfig) GetMachineType() string {
if m != nil {
return m.MachineType
}
return ""
}
func (m *ControllerConfig) GetVars() map[string]string {
if m != nil {
return m.Vars
}
return nil
}
func (m *ControllerConfig) GetDisks() map[string]string {
if m != nil {
return m.Disks
}
return nil
}
func (m *ControllerConfig) GetGcsSources() map[string]*ControllerConfig_RepeatedString {
if m != nil {
return m.GcsSources
}
return nil
}
func (m *ControllerConfig) GetGcsSinks() map[string]*ControllerConfig_RepeatedString {
if m != nil {
return m.GcsSinks
}
return nil
}
type ControllerConfig_RepeatedString struct {
Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ControllerConfig_RepeatedString) Reset() { *m = ControllerConfig_RepeatedString{} }
func (m *ControllerConfig_RepeatedString) String() string { return proto.CompactTextString(m) }
func (*ControllerConfig_RepeatedString) ProtoMessage() {}
func (*ControllerConfig_RepeatedString) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{11, 0}
}
func (m *ControllerConfig_RepeatedString) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ControllerConfig_RepeatedString.Unmarshal(m, b)
}
func (m *ControllerConfig_RepeatedString) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ControllerConfig_RepeatedString.Marshal(b, m, deterministic)
}
func (m *ControllerConfig_RepeatedString) XXX_Merge(src proto.Message) {
xxx_messageInfo_ControllerConfig_RepeatedString.Merge(m, src)
}
func (m *ControllerConfig_RepeatedString) XXX_Size() int {
return xxx_messageInfo_ControllerConfig_RepeatedString.Size(m)
}
func (m *ControllerConfig_RepeatedString) XXX_DiscardUnknown() {
xxx_messageInfo_ControllerConfig_RepeatedString.DiscardUnknown(m)
}
var xxx_messageInfo_ControllerConfig_RepeatedString proto.InternalMessageInfo
func (m *ControllerConfig_RepeatedString) GetValues() []string {
if m != nil {
return m.Values
}
return nil
}
// Stores the list of events and times they occured for major events in job
// execution.
type TimestampEvent struct {
// String indicating the type of event
Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
// The time this event occured.
Timestamp *timestamp.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TimestampEvent) Reset() { *m = TimestampEvent{} }
func (m *TimestampEvent) String() string { return proto.CompactTextString(m) }
func (*TimestampEvent) ProtoMessage() {}
func (*TimestampEvent) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{12}
}
func (m *TimestampEvent) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_TimestampEvent.Unmarshal(m, b)
}
func (m *TimestampEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TimestampEvent.Marshal(b, m, deterministic)
}
func (m *TimestampEvent) XXX_Merge(src proto.Message) {
xxx_messageInfo_TimestampEvent.Merge(m, src)
}
func (m *TimestampEvent) XXX_Size() int {
return xxx_messageInfo_TimestampEvent.Size(m)
}
func (m *TimestampEvent) XXX_DiscardUnknown() {
xxx_messageInfo_TimestampEvent.DiscardUnknown(m)
}
var xxx_messageInfo_TimestampEvent proto.InternalMessageInfo
func (m *TimestampEvent) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *TimestampEvent) GetTimestamp() *timestamp.Timestamp {
if m != nil {
return m.Timestamp
}
return nil
}
// Request to set operation status. Should only be used by VMs
// created by the Pipelines Service and not by end users.
type SetOperationStatusRequest struct {
OperationId string `protobuf:"bytes,1,opt,name=operation_id,json=operationId,proto3" json:"operation_id,omitempty"`
TimestampEvents []*TimestampEvent `protobuf:"bytes,2,rep,name=timestamp_events,json=timestampEvents,proto3" json:"timestamp_events,omitempty"`
ErrorCode code.Code `protobuf:"varint,3,opt,name=error_code,json=errorCode,proto3,enum=google.rpc.Code" json:"error_code,omitempty"`
ErrorMessage string `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
ValidationToken uint64 `protobuf:"varint,5,opt,name=validation_token,json=validationToken,proto3" json:"validation_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetOperationStatusRequest) Reset() { *m = SetOperationStatusRequest{} }
func (m *SetOperationStatusRequest) String() string { return proto.CompactTextString(m) }
func (*SetOperationStatusRequest) ProtoMessage() {}
func (*SetOperationStatusRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{13}
}
func (m *SetOperationStatusRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetOperationStatusRequest.Unmarshal(m, b)
}
func (m *SetOperationStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetOperationStatusRequest.Marshal(b, m, deterministic)
}
func (m *SetOperationStatusRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetOperationStatusRequest.Merge(m, src)
}
func (m *SetOperationStatusRequest) XXX_Size() int {
return xxx_messageInfo_SetOperationStatusRequest.Size(m)
}
func (m *SetOperationStatusRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetOperationStatusRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetOperationStatusRequest proto.InternalMessageInfo
func (m *SetOperationStatusRequest) GetOperationId() string {
if m != nil {
return m.OperationId
}
return ""
}
func (m *SetOperationStatusRequest) GetTimestampEvents() []*TimestampEvent {
if m != nil {
return m.TimestampEvents
}
return nil
}
func (m *SetOperationStatusRequest) GetErrorCode() code.Code {
if m != nil {
return m.ErrorCode
}
return code.Code_OK
}
func (m *SetOperationStatusRequest) GetErrorMessage() string {
if m != nil {
return m.ErrorMessage
}
return ""
}
func (m *SetOperationStatusRequest) GetValidationToken() uint64 {
if m != nil {
return m.ValidationToken
}
return 0
}
// A Google Cloud Service Account.
type ServiceAccount struct {
// Email address of the service account. Defaults to `default`,
// which uses the compute service account associated with the project.
Email string `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"`
// List of scopes to be enabled for this service account on the VM.
// The following scopes are automatically included:
//
// * path_to_url
// * path_to_url
// * path_to_url
// * path_to_url
// * path_to_url
Scopes []string `protobuf:"bytes,2,rep,name=scopes,proto3" json:"scopes,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ServiceAccount) Reset() { *m = ServiceAccount{} }
func (m *ServiceAccount) String() string { return proto.CompactTextString(m) }
func (*ServiceAccount) ProtoMessage() {}
func (*ServiceAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{14}
}
func (m *ServiceAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ServiceAccount.Unmarshal(m, b)
}
func (m *ServiceAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ServiceAccount.Marshal(b, m, deterministic)
}
func (m *ServiceAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_ServiceAccount.Merge(m, src)
}
func (m *ServiceAccount) XXX_Size() int {
return xxx_messageInfo_ServiceAccount.Size(m)
}
func (m *ServiceAccount) XXX_DiscardUnknown() {
xxx_messageInfo_ServiceAccount.DiscardUnknown(m)
}
var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo
func (m *ServiceAccount) GetEmail() string {
if m != nil {
return m.Email
}
return ""
}
func (m *ServiceAccount) GetScopes() []string {
if m != nil {
return m.Scopes
}
return nil
}
// The logging options for the pipeline run.
type LoggingOptions struct {
// The location in Google Cloud Storage to which the pipeline logs
// will be copied. Can be specified as a fully qualified directory
// path, in which case logs will be output with a unique identifier
// as the filename in that directory, or as a fully specified path,
// which must end in `.log`, in which case that path will be
// used, and the user must ensure that logs are not
// overwritten. Stdout and stderr logs from the run are also
// generated and output as `-stdout.log` and `-stderr.log`.
GcsPath string `protobuf:"bytes,1,opt,name=gcs_path,json=gcsPath,proto3" json:"gcs_path,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LoggingOptions) Reset() { *m = LoggingOptions{} }
func (m *LoggingOptions) String() string { return proto.CompactTextString(m) }
func (*LoggingOptions) ProtoMessage() {}
func (*LoggingOptions) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{15}
}
func (m *LoggingOptions) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LoggingOptions.Unmarshal(m, b)
}
func (m *LoggingOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LoggingOptions.Marshal(b, m, deterministic)
}
func (m *LoggingOptions) XXX_Merge(src proto.Message) {
xxx_messageInfo_LoggingOptions.Merge(m, src)
}
func (m *LoggingOptions) XXX_Size() int {
return xxx_messageInfo_LoggingOptions.Size(m)
}
func (m *LoggingOptions) XXX_DiscardUnknown() {
xxx_messageInfo_LoggingOptions.DiscardUnknown(m)
}
var xxx_messageInfo_LoggingOptions proto.InternalMessageInfo
func (m *LoggingOptions) GetGcsPath() string {
if m != nil {
return m.GcsPath
}
return ""
}
// The system resources for the pipeline run.
type PipelineResources struct {
// The minimum number of cores to use. Defaults to 1.
MinimumCpuCores int32 `protobuf:"varint,1,opt,name=minimum_cpu_cores,json=minimumCpuCores,proto3" json:"minimum_cpu_cores,omitempty"`
// Whether to use preemptible VMs. Defaults to `false`. In order to use this,
// must be true for both create time and run time. Cannot be true at run time
// if false at create time.
Preemptible bool `protobuf:"varint,2,opt,name=preemptible,proto3" json:"preemptible,omitempty"`
// The minimum amount of RAM to use. Defaults to 3.75 (GB)
MinimumRamGb float64 `protobuf:"fixed64,3,opt,name=minimum_ram_gb,json=minimumRamGb,proto3" json:"minimum_ram_gb,omitempty"`
// Disks to attach.
Disks []*PipelineResources_Disk `protobuf:"bytes,4,rep,name=disks,proto3" json:"disks,omitempty"`
// List of Google Compute Engine availability zones to which resource
// creation will restricted. If empty, any zone may be chosen.
Zones []string `protobuf:"bytes,5,rep,name=zones,proto3" json:"zones,omitempty"`
// The size of the boot disk. Defaults to 10 (GB).
BootDiskSizeGb int32 `protobuf:"varint,6,opt,name=boot_disk_size_gb,json=bootDiskSizeGb,proto3" json:"boot_disk_size_gb,omitempty"`
// Whether to assign an external IP to the instance. This is an experimental
// feature that may go away. Defaults to false.
// Corresponds to `--no_address` flag for [gcloud compute instances create]
// (path_to_url
// In order to use this, must be true for both create time and run time.
// Cannot be true at run time if false at create time. If you need to ssh into
// a private IP VM for debugging, you can ssh to a public VM and then ssh into
// the private VM's Internal IP. If noAddress is set, this pipeline run may
// only load docker images from Google Container Registry and not Docker Hub.
// ** Note: To use this option, your project must be in Google Access for
// Private IPs Early Access Program.**
NoAddress bool `protobuf:"varint,7,opt,name=no_address,json=noAddress,proto3" json:"no_address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineResources) Reset() { *m = PipelineResources{} }
func (m *PipelineResources) String() string { return proto.CompactTextString(m) }
func (*PipelineResources) ProtoMessage() {}
func (*PipelineResources) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{16}
}
func (m *PipelineResources) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineResources.Unmarshal(m, b)
}
func (m *PipelineResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineResources.Marshal(b, m, deterministic)
}
func (m *PipelineResources) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineResources.Merge(m, src)
}
func (m *PipelineResources) XXX_Size() int {
return xxx_messageInfo_PipelineResources.Size(m)
}
func (m *PipelineResources) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineResources.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineResources proto.InternalMessageInfo
func (m *PipelineResources) GetMinimumCpuCores() int32 {
if m != nil {
return m.MinimumCpuCores
}
return 0
}
func (m *PipelineResources) GetPreemptible() bool {
if m != nil {
return m.Preemptible
}
return false
}
func (m *PipelineResources) GetMinimumRamGb() float64 {
if m != nil {
return m.MinimumRamGb
}
return 0
}
func (m *PipelineResources) GetDisks() []*PipelineResources_Disk {
if m != nil {
return m.Disks
}
return nil
}
func (m *PipelineResources) GetZones() []string {
if m != nil {
return m.Zones
}
return nil
}
func (m *PipelineResources) GetBootDiskSizeGb() int32 {
if m != nil {
return m.BootDiskSizeGb
}
return 0
}
func (m *PipelineResources) GetNoAddress() bool {
if m != nil {
return m.NoAddress
}
return false
}
// A Google Compute Engine disk resource specification.
type PipelineResources_Disk struct {
// Required. The name of the disk that can be used in the pipeline
// parameters. Must be 1 - 63 characters.
// The name "boot" is reserved for system use.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Required. The type of the disk to create.
Type PipelineResources_Disk_Type `protobuf:"varint,2,opt,name=type,proto3,enum=google.genomics.v1alpha2.PipelineResources_Disk_Type" json:"type,omitempty"`
// The size of the disk. Defaults to 500 (GB).
// This field is not applicable for local SSD.
SizeGb int32 `protobuf:"varint,3,opt,name=size_gb,json=sizeGb,proto3" json:"size_gb,omitempty"`
// The full or partial URL of the persistent disk to attach. See
// path_to_url#resource
// and
// path_to_url#snapshots
// for more details.
Source string `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
// Deprecated. Disks created by the Pipelines API will be deleted at the end
// of the pipeline run, regardless of what this field is set to.
AutoDelete bool `protobuf:"varint,6,opt,name=auto_delete,json=autoDelete,proto3" json:"auto_delete,omitempty"`
// Required at create time and cannot be overridden at run time.
// Specifies the path in the docker container where files on
// this disk should be located. For example, if `mountPoint`
// is `/mnt/disk`, and the parameter has `localPath`
// `inputs/file.txt`, the docker container can access the data at
// `/mnt/disk/inputs/file.txt`.
MountPoint string `protobuf:"bytes,8,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineResources_Disk) Reset() { *m = PipelineResources_Disk{} }
func (m *PipelineResources_Disk) String() string { return proto.CompactTextString(m) }
func (*PipelineResources_Disk) ProtoMessage() {}
func (*PipelineResources_Disk) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{16, 0}
}
func (m *PipelineResources_Disk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineResources_Disk.Unmarshal(m, b)
}
func (m *PipelineResources_Disk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineResources_Disk.Marshal(b, m, deterministic)
}
func (m *PipelineResources_Disk) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineResources_Disk.Merge(m, src)
}
func (m *PipelineResources_Disk) XXX_Size() int {
return xxx_messageInfo_PipelineResources_Disk.Size(m)
}
func (m *PipelineResources_Disk) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineResources_Disk.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineResources_Disk proto.InternalMessageInfo
func (m *PipelineResources_Disk) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *PipelineResources_Disk) GetType() PipelineResources_Disk_Type {
if m != nil {
return m.Type
}
return PipelineResources_Disk_TYPE_UNSPECIFIED
}
func (m *PipelineResources_Disk) GetSizeGb() int32 {
if m != nil {
return m.SizeGb
}
return 0
}
func (m *PipelineResources_Disk) GetSource() string {
if m != nil {
return m.Source
}
return ""
}
func (m *PipelineResources_Disk) GetAutoDelete() bool {
if m != nil {
return m.AutoDelete
}
return false
}
func (m *PipelineResources_Disk) GetMountPoint() string {
if m != nil {
return m.MountPoint
}
return ""
}
// Parameters facilitate setting and delivering data into the
// pipeline's execution environment. They are defined at create time,
// with optional defaults, and can be overridden at run time.
//
// If `localCopy` is unset, then the parameter specifies a string that
// is passed as-is into the pipeline, as the value of the environment
// variable with the given name. A default value can be optionally
// specified at create time. The default can be overridden at run time
// using the inputs map. If no default is given, a value must be
// supplied at runtime.
//
// If `localCopy` is defined, then the parameter specifies a data
// source or sink, both in Google Cloud Storage and on the Docker container
// where the pipeline computation is run. The [service account associated with
// the Pipeline][google.genomics.v1alpha2.RunPipelineArgs.service_account] (by
// default the project's Compute Engine service account) must have access to the
// Google Cloud Storage paths.
//
// At run time, the Google Cloud Storage paths can be overridden if a default
// was provided at create time, or must be set otherwise. The pipeline runner
// should add a key/value pair to either the inputs or outputs map. The
// indicated data copies will be carried out before/after pipeline execution,
// just as if the corresponding arguments were provided to `gsutil cp`.
//
// For example: Given the following `PipelineParameter`, specified
// in the `inputParameters` list:
//
// ```
// {name: "input_file", localCopy: {path: "file.txt", disk: "pd1"}}
// ```
//
// where `disk` is defined in the `PipelineResources` object as:
//
// ```
// {name: "pd1", mountPoint: "/mnt/disk/"}
// ```
//
// We create a disk named `pd1`, mount it on the host VM, and map
// `/mnt/pd1` to `/mnt/disk` in the docker container. At
// runtime, an entry for `input_file` would be required in the inputs
// map, such as:
//
// ```
// inputs["input_file"] = "gs://my-bucket/bar.txt"
// ```
//
// This would generate the following gsutil call:
//
// ```
// gsutil cp gs://my-bucket/bar.txt /mnt/pd1/file.txt
// ```
//
// The file `/mnt/pd1/file.txt` maps to `/mnt/disk/file.txt` in the
// Docker container. Acceptable paths are:
//
// <table>
// <thead>
// <tr><th>Google Cloud storage path</th><th>Local path</th></tr>
// </thead>
// <tbody>
// <tr><td>file</td><td>file</td></tr>
// <tr><td>glob</td><td>directory</td></tr>
// </tbody>
// </table>
//
// For outputs, the direction of the copy is reversed:
//
// ```
// gsutil cp /mnt/disk/file.txt gs://my-bucket/bar.txt
// ```
//
// Acceptable paths are:
//
// <table>
// <thead>
// <tr><th>Local path</th><th>Google Cloud Storage path</th></tr>
// </thead>
// <tbody>
// <tr><td>file</td><td>file</td></tr>
// <tr>
// <td>file</td>
// <td>directory - directory must already exist</td>
// </tr>
// <tr>
// <td>glob</td>
// <td>directory - directory will be created if it doesn't exist</td></tr>
// </tbody>
// </table>
//
// One restriction due to docker limitations, is that for outputs that are found
// on the boot disk, the local path cannot be a glob and must be a file.
type PipelineParameter struct {
// Required. Name of the parameter - the pipeline runner uses this string
// as the key to the input and output maps in RunPipeline.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Human-readable description.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// The default value for this parameter. Can be overridden at runtime.
// If `localCopy` is present, then this must be a Google Cloud Storage path
// beginning with `gs://`.
DefaultValue string `protobuf:"bytes,5,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
// If present, this parameter is marked for copying to and from the VM.
// `LocalCopy` indicates where on the VM the file should be. The value
// given to this parameter (either at runtime or using `defaultValue`)
// must be the remote path where the file should be.
LocalCopy *PipelineParameter_LocalCopy `protobuf:"bytes,6,opt,name=local_copy,json=localCopy,proto3" json:"local_copy,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineParameter) Reset() { *m = PipelineParameter{} }
func (m *PipelineParameter) String() string { return proto.CompactTextString(m) }
func (*PipelineParameter) ProtoMessage() {}
func (*PipelineParameter) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{17}
}
func (m *PipelineParameter) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineParameter.Unmarshal(m, b)
}
func (m *PipelineParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineParameter.Marshal(b, m, deterministic)
}
func (m *PipelineParameter) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineParameter.Merge(m, src)
}
func (m *PipelineParameter) XXX_Size() int {
return xxx_messageInfo_PipelineParameter.Size(m)
}
func (m *PipelineParameter) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineParameter.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineParameter proto.InternalMessageInfo
func (m *PipelineParameter) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *PipelineParameter) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *PipelineParameter) GetDefaultValue() string {
if m != nil {
return m.DefaultValue
}
return ""
}
func (m *PipelineParameter) GetLocalCopy() *PipelineParameter_LocalCopy {
if m != nil {
return m.LocalCopy
}
return nil
}
// LocalCopy defines how a remote file should be copied to and from the VM.
type PipelineParameter_LocalCopy struct {
// Required. The path within the user's docker container where
// this input should be localized to and from, relative to the specified
// disk's mount point. For example: file.txt,
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
// Required. The name of the disk where this parameter is
// located. Can be the name of one of the disks specified in the
// Resources field, or "boot", which represents the Docker
// instance's boot disk and has a mount point of `/`.
Disk string `protobuf:"bytes,2,opt,name=disk,proto3" json:"disk,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PipelineParameter_LocalCopy) Reset() { *m = PipelineParameter_LocalCopy{} }
func (m *PipelineParameter_LocalCopy) String() string { return proto.CompactTextString(m) }
func (*PipelineParameter_LocalCopy) ProtoMessage() {}
func (*PipelineParameter_LocalCopy) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{17, 0}
}
func (m *PipelineParameter_LocalCopy) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PipelineParameter_LocalCopy.Unmarshal(m, b)
}
func (m *PipelineParameter_LocalCopy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PipelineParameter_LocalCopy.Marshal(b, m, deterministic)
}
func (m *PipelineParameter_LocalCopy) XXX_Merge(src proto.Message) {
xxx_messageInfo_PipelineParameter_LocalCopy.Merge(m, src)
}
func (m *PipelineParameter_LocalCopy) XXX_Size() int {
return xxx_messageInfo_PipelineParameter_LocalCopy.Size(m)
}
func (m *PipelineParameter_LocalCopy) XXX_DiscardUnknown() {
xxx_messageInfo_PipelineParameter_LocalCopy.DiscardUnknown(m)
}
var xxx_messageInfo_PipelineParameter_LocalCopy proto.InternalMessageInfo
func (m *PipelineParameter_LocalCopy) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *PipelineParameter_LocalCopy) GetDisk() string {
if m != nil {
return m.Disk
}
return ""
}
// The Docker execuctor specification.
type DockerExecutor struct {
// Required. Image name from either Docker Hub or Google Container Registry.
// Users that run pipelines must have READ access to the image.
ImageName string `protobuf:"bytes,1,opt,name=image_name,json=imageName,proto3" json:"image_name,omitempty"`
// Required. The command or newline delimited script to run. The command
// string will be executed within a bash shell.
//
// If the command exits with a non-zero exit code, output parameter
// de-localization will be skipped and the pipeline operation's
// [`error`][google.longrunning.Operation.error] field will be populated.
//
// Maximum command string length is 16384.
Cmd string `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DockerExecutor) Reset() { *m = DockerExecutor{} }
func (m *DockerExecutor) String() string { return proto.CompactTextString(m) }
func (*DockerExecutor) ProtoMessage() {}
func (*DockerExecutor) Descriptor() ([]byte, []int) {
return fileDescriptor_72a0789107b705b0, []int{18}
}
func (m *DockerExecutor) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DockerExecutor.Unmarshal(m, b)
}
func (m *DockerExecutor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DockerExecutor.Marshal(b, m, deterministic)
}
func (m *DockerExecutor) XXX_Merge(src proto.Message) {
xxx_messageInfo_DockerExecutor.Merge(m, src)
}
func (m *DockerExecutor) XXX_Size() int {
return xxx_messageInfo_DockerExecutor.Size(m)
}
func (m *DockerExecutor) XXX_DiscardUnknown() {
xxx_messageInfo_DockerExecutor.DiscardUnknown(m)
}
var xxx_messageInfo_DockerExecutor proto.InternalMessageInfo
func (m *DockerExecutor) GetImageName() string {
if m != nil {
return m.ImageName
}
return ""
}
func (m *DockerExecutor) GetCmd() string {
if m != nil {
return m.Cmd
}
return ""
}
func init() {
proto.RegisterEnum("google.genomics.v1alpha2.PipelineResources_Disk_Type", PipelineResources_Disk_Type_name, PipelineResources_Disk_Type_value)
proto.RegisterType((*ComputeEngine)(nil), "google.genomics.v1alpha2.ComputeEngine")
proto.RegisterType((*RuntimeMetadata)(nil), "google.genomics.v1alpha2.RuntimeMetadata")
proto.RegisterType((*Pipeline)(nil), "google.genomics.v1alpha2.Pipeline")
proto.RegisterType((*CreatePipelineRequest)(nil), "google.genomics.v1alpha2.CreatePipelineRequest")
proto.RegisterType((*RunPipelineArgs)(nil), "google.genomics.v1alpha2.RunPipelineArgs")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.RunPipelineArgs.InputsEntry")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.RunPipelineArgs.LabelsEntry")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.RunPipelineArgs.OutputsEntry")
proto.RegisterType((*RunPipelineRequest)(nil), "google.genomics.v1alpha2.RunPipelineRequest")
proto.RegisterType((*GetPipelineRequest)(nil), "google.genomics.v1alpha2.GetPipelineRequest")
proto.RegisterType((*ListPipelinesRequest)(nil), "google.genomics.v1alpha2.ListPipelinesRequest")
proto.RegisterType((*ListPipelinesResponse)(nil), "google.genomics.v1alpha2.ListPipelinesResponse")
proto.RegisterType((*DeletePipelineRequest)(nil), "google.genomics.v1alpha2.DeletePipelineRequest")
proto.RegisterType((*GetControllerConfigRequest)(nil), "google.genomics.v1alpha2.GetControllerConfigRequest")
proto.RegisterType((*ControllerConfig)(nil), "google.genomics.v1alpha2.ControllerConfig")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.ControllerConfig.DisksEntry")
proto.RegisterMapType((map[string]*ControllerConfig_RepeatedString)(nil), "google.genomics.v1alpha2.ControllerConfig.GcsSinksEntry")
proto.RegisterMapType((map[string]*ControllerConfig_RepeatedString)(nil), "google.genomics.v1alpha2.ControllerConfig.GcsSourcesEntry")
proto.RegisterMapType((map[string]string)(nil), "google.genomics.v1alpha2.ControllerConfig.VarsEntry")
proto.RegisterType((*ControllerConfig_RepeatedString)(nil), "google.genomics.v1alpha2.ControllerConfig.RepeatedString")
proto.RegisterType((*TimestampEvent)(nil), "google.genomics.v1alpha2.TimestampEvent")
proto.RegisterType((*SetOperationStatusRequest)(nil), "google.genomics.v1alpha2.SetOperationStatusRequest")
proto.RegisterType((*ServiceAccount)(nil), "google.genomics.v1alpha2.ServiceAccount")
proto.RegisterType((*LoggingOptions)(nil), "google.genomics.v1alpha2.LoggingOptions")
proto.RegisterType((*PipelineResources)(nil), "google.genomics.v1alpha2.PipelineResources")
proto.RegisterType((*PipelineResources_Disk)(nil), "google.genomics.v1alpha2.PipelineResources.Disk")
proto.RegisterType((*PipelineParameter)(nil), "google.genomics.v1alpha2.PipelineParameter")
proto.RegisterType((*PipelineParameter_LocalCopy)(nil), "google.genomics.v1alpha2.PipelineParameter.LocalCopy")
proto.RegisterType((*DockerExecutor)(nil), "google.genomics.v1alpha2.DockerExecutor")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// PipelinesV1Alpha2Client is the client API for PipelinesV1Alpha2 service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to path_to_url#ClientConn.NewStream.
type PipelinesV1Alpha2Client interface {
// Creates a pipeline that can be run later. Create takes a Pipeline that
// has all fields other than `pipelineId` populated, and then returns
// the same pipeline with `pipelineId` populated. This id can be used
// to run the pipeline.
//
// Caller must have WRITE permission to the project.
CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*Pipeline, error)
// Runs a pipeline. If `pipelineId` is specified in the request, then
// run a saved pipeline. If `ephemeralPipeline` is specified, then run
// that pipeline once without saving a copy.
//
// The caller must have READ permission to the project where the pipeline
// is stored and WRITE permission to the project where the pipeline will be
// run, as VMs will be created and storage will be used.
RunPipeline(ctx context.Context, in *RunPipelineRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
// Retrieves a pipeline based on ID.
//
// Caller must have READ permission to the project.
GetPipeline(ctx context.Context, in *GetPipelineRequest, opts ...grpc.CallOption) (*Pipeline, error)
// Lists pipelines.
//
// Caller must have READ permission to the project.
ListPipelines(ctx context.Context, in *ListPipelinesRequest, opts ...grpc.CallOption) (*ListPipelinesResponse, error)
// Deletes a pipeline based on ID.
//
// Caller must have WRITE permission to the project.
DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*empty.Empty, error)
// Gets controller configuration information. Should only be called
// by VMs created by the Pipelines Service and not by end users.
GetControllerConfig(ctx context.Context, in *GetControllerConfigRequest, opts ...grpc.CallOption) (*ControllerConfig, error)
// Sets status of a given operation. Any new timestamps (as determined by
// description) are appended to TimestampEvents. Should only be called by VMs
// created by the Pipelines Service and not by end users.
SetOperationStatus(ctx context.Context, in *SetOperationStatusRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type pipelinesV1Alpha2Client struct {
cc *grpc.ClientConn
}
func NewPipelinesV1Alpha2Client(cc *grpc.ClientConn) PipelinesV1Alpha2Client {
return &pipelinesV1Alpha2Client{cc}
}
func (c *pipelinesV1Alpha2Client) CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*Pipeline, error) {
out := new(Pipeline)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/CreatePipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) RunPipeline(ctx context.Context, in *RunPipelineRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) {
out := new(longrunning.Operation)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/RunPipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) GetPipeline(ctx context.Context, in *GetPipelineRequest, opts ...grpc.CallOption) (*Pipeline, error) {
out := new(Pipeline)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetPipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) ListPipelines(ctx context.Context, in *ListPipelinesRequest, opts ...grpc.CallOption) (*ListPipelinesResponse, error) {
out := new(ListPipelinesResponse)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/ListPipelines", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/DeletePipeline", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) GetControllerConfig(ctx context.Context, in *GetControllerConfigRequest, opts ...grpc.CallOption) (*ControllerConfig, error) {
out := new(ControllerConfig)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetControllerConfig", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pipelinesV1Alpha2Client) SetOperationStatus(ctx context.Context, in *SetOperationStatusRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/google.genomics.v1alpha2.PipelinesV1Alpha2/SetOperationStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// PipelinesV1Alpha2Server is the server API for PipelinesV1Alpha2 service.
type PipelinesV1Alpha2Server interface {
// Creates a pipeline that can be run later. Create takes a Pipeline that
// has all fields other than `pipelineId` populated, and then returns
// the same pipeline with `pipelineId` populated. This id can be used
// to run the pipeline.
//
// Caller must have WRITE permission to the project.
CreatePipeline(context.Context, *CreatePipelineRequest) (*Pipeline, error)
// Runs a pipeline. If `pipelineId` is specified in the request, then
// run a saved pipeline. If `ephemeralPipeline` is specified, then run
// that pipeline once without saving a copy.
//
// The caller must have READ permission to the project where the pipeline
// is stored and WRITE permission to the project where the pipeline will be
// run, as VMs will be created and storage will be used.
RunPipeline(context.Context, *RunPipelineRequest) (*longrunning.Operation, error)
// Retrieves a pipeline based on ID.
//
// Caller must have READ permission to the project.
GetPipeline(context.Context, *GetPipelineRequest) (*Pipeline, error)
// Lists pipelines.
//
// Caller must have READ permission to the project.
ListPipelines(context.Context, *ListPipelinesRequest) (*ListPipelinesResponse, error)
// Deletes a pipeline based on ID.
//
// Caller must have WRITE permission to the project.
DeletePipeline(context.Context, *DeletePipelineRequest) (*empty.Empty, error)
// Gets controller configuration information. Should only be called
// by VMs created by the Pipelines Service and not by end users.
GetControllerConfig(context.Context, *GetControllerConfigRequest) (*ControllerConfig, error)
// Sets status of a given operation. Any new timestamps (as determined by
// description) are appended to TimestampEvents. Should only be called by VMs
// created by the Pipelines Service and not by end users.
SetOperationStatus(context.Context, *SetOperationStatusRequest) (*empty.Empty, error)
}
func RegisterPipelinesV1Alpha2Server(s *grpc.Server, srv PipelinesV1Alpha2Server) {
s.RegisterService(&_PipelinesV1Alpha2_serviceDesc, srv)
}
func _PipelinesV1Alpha2_CreatePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreatePipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).CreatePipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/CreatePipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).CreatePipeline(ctx, req.(*CreatePipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_RunPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RunPipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).RunPipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/RunPipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).RunPipeline(ctx, req.(*RunPipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_GetPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetPipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).GetPipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetPipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).GetPipeline(ctx, req.(*GetPipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_ListPipelines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListPipelinesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).ListPipelines(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/ListPipelines",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).ListPipelines(ctx, req.(*ListPipelinesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_DeletePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeletePipelineRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).DeletePipeline(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/DeletePipeline",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).DeletePipeline(ctx, req.(*DeletePipelineRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_GetControllerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetControllerConfigRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).GetControllerConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/GetControllerConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).GetControllerConfig(ctx, req.(*GetControllerConfigRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PipelinesV1Alpha2_SetOperationStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetOperationStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PipelinesV1Alpha2Server).SetOperationStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/google.genomics.v1alpha2.PipelinesV1Alpha2/SetOperationStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PipelinesV1Alpha2Server).SetOperationStatus(ctx, req.(*SetOperationStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
var _PipelinesV1Alpha2_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.genomics.v1alpha2.PipelinesV1Alpha2",
HandlerType: (*PipelinesV1Alpha2Server)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "CreatePipeline",
Handler: _PipelinesV1Alpha2_CreatePipeline_Handler,
},
{
MethodName: "RunPipeline",
Handler: _PipelinesV1Alpha2_RunPipeline_Handler,
},
{
MethodName: "GetPipeline",
Handler: _PipelinesV1Alpha2_GetPipeline_Handler,
},
{
MethodName: "ListPipelines",
Handler: _PipelinesV1Alpha2_ListPipelines_Handler,
},
{
MethodName: "DeletePipeline",
Handler: _PipelinesV1Alpha2_DeletePipeline_Handler,
},
{
MethodName: "GetControllerConfig",
Handler: _PipelinesV1Alpha2_GetControllerConfig_Handler,
},
{
MethodName: "SetOperationStatus",
Handler: _PipelinesV1Alpha2_SetOperationStatus_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "google/genomics/v1alpha2/pipelines.proto",
}
func init() {
proto.RegisterFile("google/genomics/v1alpha2/pipelines.proto", fileDescriptor_72a0789107b705b0)
}
var fileDescriptor_72a0789107b705b0 = []byte{
// 2065 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x73, 0xdb, 0xc8,
0xd1, 0x36, 0x28, 0x4a, 0x22, 0x9a, 0x12, 0x45, 0xcf, 0xda, 0x6b, 0x9a, 0xf6, 0xbe, 0xb6, 0xe1,
0x37, 0xbb, 0xb2, 0x9c, 0x22, 0x63, 0x79, 0x9d, 0xc8, 0x4a, 0xd5, 0xd6, 0x4a, 0x14, 0x2d, 0xb1,
0x22, 0x4b, 0x0c, 0xa8, 0x55, 0xbe, 0x0e, 0xa8, 0x11, 0x38, 0x82, 0xb0, 0x02, 0x30, 0x08, 0x06,
0x50, 0x59, 0x4e, 0x25, 0x55, 0x49, 0xe5, 0x90, 0xda, 0x4a, 0x2e, 0xc9, 0xfe, 0x88, 0x5c, 0x72,
0xcc, 0xcf, 0xc8, 0x29, 0xa7, 0x9c, 0x72, 0xc9, 0x21, 0x3f, 0x21, 0xb9, 0xa5, 0x66, 0x06, 0x03,
0x82, 0x1f, 0x92, 0xc8, 0xaa, 0x54, 0x6e, 0x33, 0x3d, 0xdd, 0x0f, 0x9e, 0xe9, 0xe9, 0xe9, 0xe9,
0x06, 0xac, 0x3a, 0x94, 0x3a, 0x1e, 0x69, 0x3a, 0x24, 0xa0, 0xbe, 0x6b, 0xb3, 0xe6, 0xc5, 0x0b,
0xec, 0x85, 0x67, 0x78, 0xbd, 0x19, 0xba, 0x21, 0xf1, 0xdc, 0x80, 0xb0, 0x46, 0x18, 0xd1, 0x98,
0xa2, 0x9a, 0xd4, 0x6c, 0x28, 0xcd, 0x86, 0xd2, 0xac, 0x3f, 0x4c, 0x31, 0x70, 0xe8, 0x36, 0x71,
0x10, 0xd0, 0x18, 0xc7, 0x2e, 0x0d, 0x52, 0xbb, 0xfa, 0xd3, 0x74, 0xd5, 0xa3, 0x81, 0x13, 0x25,
0x41, 0xe0, 0x06, 0x4e, 0x93, 0x86, 0x24, 0x1a, 0x52, 0xfa, 0xbf, 0x54, 0x49, 0xcc, 0x4e, 0x92,
0xd3, 0x66, 0x3f, 0x91, 0x0a, 0xe9, 0xfa, 0x83, 0xd1, 0x75, 0xe2, 0x87, 0xf1, 0x65, 0xba, 0xf8,
0x68, 0x74, 0x31, 0x76, 0x7d, 0xc2, 0x62, 0xec, 0x87, 0xa9, 0xc2, 0xdd, 0x54, 0x21, 0x0a, 0xed,
0xa6, 0x4d, 0xfb, 0x44, 0x8a, 0x8d, 0xaf, 0x34, 0x58, 0x6e, 0x51, 0x3f, 0x4c, 0x62, 0xd2, 0x0e,
0x1c, 0x37, 0x20, 0xe8, 0x29, 0x2c, 0xbb, 0x01, 0x8b, 0x71, 0x60, 0x13, 0x2b, 0xc0, 0x3e, 0xa9,
0x69, 0x8f, 0xb5, 0x55, 0xdd, 0x5c, 0x52, 0xc2, 0x03, 0xec, 0x13, 0x84, 0xa0, 0xf8, 0x9e, 0x06,
0xa4, 0x56, 0x10, 0x6b, 0x62, 0x8c, 0x9e, 0xc0, 0x92, 0x8f, 0xed, 0x33, 0x37, 0x20, 0x56, 0x7c,
0x19, 0x92, 0xda, 0x9c, 0x58, 0x2b, 0xa7, 0xb2, 0xa3, 0xcb, 0x90, 0xa0, 0x8f, 0x00, 0xfa, 0x2e,
0x3b, 0x17, 0xb8, 0xac, 0x56, 0x7c, 0x3c, 0xb7, 0xaa, 0x9b, 0x3a, 0x97, 0x70, 0x50, 0x66, 0x60,
0x58, 0x31, 0x93, 0x80, 0x33, 0x7f, 0x4b, 0x62, 0xdc, 0xc7, 0x31, 0x46, 0x07, 0x50, 0xb1, 0x25,
0x3d, 0x8b, 0x08, 0x7e, 0x82, 0x4e, 0x79, 0xfd, 0x93, 0xc6, 0x55, 0x47, 0xd1, 0x18, 0xda, 0x8e,
0xb9, 0x6c, 0xe7, 0xa7, 0xc6, 0x5f, 0xe6, 0xa0, 0xd4, 0x4d, 0x4f, 0x95, 0xd3, 0x09, 0x23, 0xfa,
0x25, 0xb1, 0x63, 0xcb, 0xed, 0xa7, 0xfb, 0xd4, 0x53, 0x49, 0xa7, 0xcf, 0x37, 0x29, 0x1c, 0x90,
0x6e, 0x92, 0x8f, 0xd1, 0x63, 0x28, 0xf7, 0x09, 0xb3, 0x23, 0x37, 0xe4, 0x27, 0xa3, 0xf6, 0x98,
0x13, 0xa1, 0x63, 0xa8, 0xba, 0x41, 0x98, 0xc4, 0x56, 0x88, 0x23, 0xec, 0x93, 0x98, 0x44, 0xac,
0x56, 0x7a, 0x3c, 0xb7, 0x5a, 0x5e, 0x7f, 0x7e, 0x35, 0x67, 0x45, 0xa9, 0xab, 0x6c, 0xcc, 0x15,
0x01, 0x92, 0xcd, 0x19, 0xfa, 0x21, 0xdc, 0xa6, 0x49, 0x3c, 0x02, 0xac, 0xcf, 0x0e, 0x5c, 0x95,
0x28, 0x39, 0xe4, 0x6d, 0x58, 0xe8, 0x53, 0xfb, 0x9c, 0x44, 0xb5, 0x79, 0xe1, 0xdb, 0xd5, 0xab,
0xe1, 0x76, 0x84, 0x5e, 0xfb, 0x1d, 0xb1, 0x93, 0x98, 0x46, 0x7b, 0xb7, 0xcc, 0xd4, 0x12, 0x75,
0x40, 0x8f, 0x08, 0xa3, 0x49, 0x64, 0x13, 0x56, 0x5b, 0x10, 0x30, 0x53, 0xb0, 0x32, 0x95, 0x89,
0x39, 0xb0, 0x46, 0x8f, 0xa0, 0xac, 0xee, 0x1d, 0x3f, 0x96, 0x45, 0xe1, 0x62, 0x50, 0xa2, 0x4e,
0x7f, 0x1b, 0xa0, 0x44, 0x52, 0x06, 0xc6, 0x0f, 0xe0, 0x6e, 0x2b, 0x22, 0x38, 0x26, 0x03, 0xc8,
0x9f, 0x26, 0x84, 0xc5, 0xe8, 0x33, 0x28, 0x29, 0x93, 0x34, 0x64, 0x8c, 0x29, 0xf8, 0x64, 0x36,
0xc6, 0x9f, 0x17, 0x44, 0x30, 0xaa, 0x95, 0xad, 0xc8, 0x61, 0x37, 0xc5, 0xcb, 0x5b, 0x58, 0x10,
0x87, 0xc6, 0x6a, 0x05, 0x71, 0x2c, 0xaf, 0xae, 0xfe, 0xe0, 0x08, 0x72, 0xa3, 0x23, 0xec, 0xda,
0x41, 0x1c, 0x5d, 0x9a, 0x29, 0x08, 0xea, 0xc2, 0xa2, 0x3c, 0x2a, 0x56, 0x9b, 0x13, 0x78, 0xdf,
0x9e, 0x1e, 0xef, 0x50, 0x1a, 0x4a, 0x40, 0x05, 0x83, 0xbe, 0x0f, 0x2b, 0x8c, 0x44, 0x17, 0xae,
0x4d, 0x2c, 0x6c, 0xdb, 0x34, 0x09, 0xe2, 0x5a, 0xf1, 0xa6, 0x13, 0xef, 0x49, 0x83, 0x2d, 0xa9,
0x6f, 0x56, 0xd8, 0xd0, 0x1c, 0x3d, 0x00, 0xdd, 0xf6, 0x5c, 0x12, 0x08, 0x8f, 0xcc, 0x0b, 0x8f,
0x94, 0xa4, 0xa0, 0xd3, 0xff, 0x6f, 0x06, 0xc5, 0x36, 0x2c, 0x7a, 0xd4, 0x71, 0xdc, 0xc0, 0x11,
0x01, 0x71, 0x2d, 0xe5, 0x7d, 0xa9, 0x78, 0x28, 0xee, 0x23, 0x33, 0x95, 0x21, 0x3a, 0x81, 0x27,
0xe7, 0x84, 0x84, 0xd6, 0x85, 0x6f, 0x61, 0xcf, 0xbd, 0x20, 0x16, 0x0d, 0xac, 0x53, 0xec, 0x7a,
0x49, 0x44, 0x2c, 0x95, 0x6b, 0x6b, 0x25, 0x81, 0x7e, 0x5f, 0xa1, 0xab, 0x7c, 0xda, 0xd8, 0x49,
0x15, 0xcc, 0x87, 0x1c, 0xe3, 0xd8, 0xdf, 0xe2, 0x08, 0x87, 0xc1, 0x1b, 0x69, 0xaf, 0x56, 0x79,
0x0c, 0x78, 0xf8, 0x84, 0x78, 0xea, 0x6a, 0xce, 0x10, 0x03, 0xfb, 0xc2, 0x2e, 0x8d, 0x01, 0x09,
0x52, 0x7f, 0x0d, 0xe5, 0x5c, 0x68, 0xa0, 0x2a, 0xcc, 0x9d, 0x93, 0xcb, 0x34, 0xf2, 0xf8, 0x10,
0xdd, 0x81, 0xf9, 0x0b, 0xec, 0x25, 0x2a, 0x49, 0xc9, 0xc9, 0x66, 0x61, 0x43, 0xab, 0x6f, 0xc2,
0x52, 0x3e, 0x0a, 0x66, 0xb2, 0x7d, 0x0d, 0xe5, 0x1c, 0x9b, 0x59, 0x4c, 0x8d, 0x7f, 0x6a, 0x80,
0x72, 0x3b, 0x53, 0xd7, 0xf1, 0xc9, 0xf0, 0xa5, 0x16, 0x50, 0x7b, 0xb7, 0xf2, 0xd7, 0x1a, 0xf5,
0x00, 0x91, 0xf0, 0x8c, 0xf8, 0x24, 0xc2, 0x9e, 0x95, 0xdd, 0xdd, 0xc2, 0xb4, 0x77, 0x77, 0xef,
0x96, 0x79, 0x3b, 0xb3, 0xcf, 0x52, 0xfc, 0x01, 0x2c, 0x67, 0xdf, 0xc5, 0x91, 0xc3, 0x44, 0xc6,
0x2e, 0xaf, 0x3f, 0x9b, 0xfa, 0x58, 0xcc, 0xa5, 0x30, 0x37, 0xe3, 0xb9, 0x27, 0x4b, 0x11, 0xaf,
0x00, 0xed, 0x92, 0x78, 0x74, 0xa7, 0x8f, 0x26, 0xec, 0x34, 0xbf, 0x4f, 0xe3, 0xf7, 0x1a, 0xdc,
0xd9, 0x77, 0x59, 0x66, 0xc8, 0x94, 0xe5, 0x0d, 0xe9, 0xe5, 0x11, 0x94, 0xf9, 0x13, 0x64, 0x85,
0x11, 0x39, 0x75, 0xdf, 0xa5, 0x9e, 0x07, 0x2e, 0xea, 0x0a, 0x09, 0xbf, 0x8b, 0x21, 0x76, 0x88,
0xc5, 0xdc, 0xf7, 0xf2, 0xf5, 0x9d, 0x37, 0x4b, 0x5c, 0xd0, 0x73, 0xdf, 0xcb, 0xb7, 0x8e, 0x2f,
0xc6, 0xf4, 0x9c, 0x04, 0xe2, 0xda, 0x73, 0x70, 0xec, 0x90, 0x23, 0x2e, 0x30, 0x7e, 0xa9, 0xc1,
0xdd, 0x11, 0x52, 0x2c, 0xa4, 0x01, 0x23, 0xe8, 0x73, 0xd0, 0xb3, 0x32, 0xa8, 0xa6, 0x89, 0xa0,
0x9e, 0x26, 0x93, 0x0e, 0x8c, 0xd0, 0xc7, 0xb0, 0x12, 0x90, 0x77, 0xfc, 0xdd, 0xca, 0xbe, 0x2f,
0xc9, 0x2f, 0x73, 0x71, 0x37, 0xe3, 0xb0, 0x01, 0x77, 0x77, 0x88, 0x47, 0xc6, 0x73, 0xf9, 0x8d,
0x2e, 0xfd, 0x12, 0xea, 0xbb, 0x24, 0x6e, 0xd1, 0x20, 0x8e, 0xa8, 0xe7, 0x91, 0xa8, 0x45, 0x83,
0x53, 0xd7, 0x19, 0xc4, 0xde, 0x52, 0x56, 0x6c, 0x0d, 0xec, 0xcb, 0x99, 0xac, 0xd3, 0x47, 0xcf,
0xa0, 0x7a, 0x81, 0x3d, 0xb7, 0x2f, 0x75, 0x06, 0x1c, 0x8b, 0xe6, 0xca, 0x40, 0x2e, 0x59, 0xfe,
0x6d, 0x01, 0xaa, 0xa3, 0x5f, 0xe2, 0xf7, 0xc1, 0xf5, 0xb1, 0xa3, 0x8a, 0x25, 0x39, 0xe1, 0xf7,
0xc6, 0xf6, 0xfb, 0xe9, 0x66, 0xf9, 0x10, 0x3d, 0x86, 0x25, 0xc7, 0x66, 0x96, 0x47, 0x1d, 0x2b,
0xc4, 0xf1, 0x59, 0x5a, 0x3f, 0x80, 0x63, 0xb3, 0x7d, 0xea, 0x74, 0x71, 0x7c, 0x36, 0x56, 0x45,
0x15, 0xc7, 0xab, 0xa8, 0x3d, 0x28, 0x5e, 0xe0, 0x88, 0xd5, 0xe6, 0xc5, 0x61, 0x7c, 0x7a, 0x5d,
0x25, 0x34, 0x4c, 0xb3, 0x71, 0x8c, 0xa3, 0x34, 0xc1, 0x08, 0x04, 0xf4, 0x3d, 0x98, 0xe7, 0xd5,
0x17, 0x4f, 0xce, 0x37, 0x24, 0xab, 0x31, 0xa8, 0x1d, 0x6e, 0x27, 0xb1, 0x24, 0x06, 0xfa, 0x09,
0x94, 0xf9, 0xde, 0x54, 0xbe, 0x5f, 0x14, 0x90, 0x9b, 0x33, 0x40, 0xee, 0xda, 0xac, 0x27, 0x8d,
0x25, 0x2e, 0x77, 0x4b, 0x2a, 0x40, 0x5f, 0x80, 0x2e, 0xc0, 0xdd, 0xe0, 0x5c, 0x95, 0x53, 0x1b,
0x33, 0x42, 0x73, 0x53, 0x09, 0x5c, 0x72, 0xd2, 0x69, 0x7d, 0x15, 0x2a, 0x26, 0x09, 0x79, 0xfd,
0xd0, 0xef, 0xc5, 0x11, 0x7f, 0x24, 0x3e, 0x84, 0x05, 0x91, 0xcc, 0x64, 0xac, 0xeb, 0x66, 0x3a,
0xab, 0x7f, 0x07, 0xf4, 0xcc, 0x7b, 0x33, 0xe5, 0xd2, 0x0d, 0x80, 0x81, 0xaf, 0x66, 0xb2, 0x7c,
0x07, 0x2b, 0x23, 0x2e, 0x99, 0x60, 0x7e, 0x98, 0x37, 0x2f, 0xaf, 0xbf, 0x9e, 0xc1, 0x29, 0xc3,
0x3b, 0xcf, 0x7f, 0xf9, 0x02, 0x96, 0x87, 0x3c, 0xf6, 0x3f, 0xfa, 0xae, 0xe1, 0x41, 0xe5, 0x48,
0xf5, 0x2d, 0xed, 0x0b, 0x12, 0xc4, 0xa3, 0xf5, 0xb6, 0x36, 0x5e, 0x6f, 0x6f, 0x80, 0x9e, 0xf5,
0x3a, 0x29, 0x99, 0xfa, 0xd8, 0xeb, 0x9d, 0xa1, 0x9a, 0x03, 0x65, 0xe3, 0xeb, 0x02, 0xdc, 0xef,
0x91, 0xf8, 0x50, 0xe5, 0x81, 0x5e, 0x8c, 0xe3, 0x84, 0xcd, 0x90, 0x35, 0x7a, 0x50, 0xcd, 0xd0,
0x2c, 0xc2, 0xf9, 0xaa, 0xd2, 0xef, 0x9a, 0xea, 0x64, 0x78, 0x83, 0xe6, 0x4a, 0x3c, 0x34, 0x67,
0xa8, 0x09, 0x40, 0xa2, 0x88, 0x46, 0x16, 0xef, 0xd2, 0x44, 0x82, 0xa8, 0xac, 0x57, 0x15, 0x5c,
0x14, 0xda, 0x8d, 0x16, 0xed, 0x13, 0x53, 0x17, 0x3a, 0x7c, 0xc8, 0x1b, 0x36, 0x69, 0xe0, 0x13,
0xc6, 0x78, 0x0e, 0x92, 0x29, 0x63, 0x49, 0x08, 0xdf, 0x4a, 0xd9, 0xc4, 0x04, 0x37, 0x3f, 0x39,
0xc1, 0x7d, 0x06, 0x95, 0xe1, 0xa2, 0x8f, 0x87, 0x28, 0xf1, 0xb1, 0xeb, 0xa9, 0xec, 0x26, 0x26,
0xfc, 0xa6, 0x30, 0x9b, 0x86, 0x44, 0xee, 0x59, 0x37, 0xd3, 0x99, 0xf1, 0x1c, 0x2a, 0xc3, 0x15,
0x18, 0xba, 0x0f, 0xfc, 0xc6, 0xc9, 0x8c, 0x27, 0x21, 0x16, 0x1d, 0x9b, 0xf1, 0x74, 0x67, 0xfc,
0xbd, 0x08, 0xb7, 0xc7, 0x0a, 0x3f, 0xb4, 0x06, 0xb7, 0x7d, 0x37, 0x70, 0xfd, 0xc4, 0xb7, 0xec,
0x30, 0xb1, 0x6c, 0x1a, 0x89, 0xfb, 0xc8, 0x5f, 0xb4, 0x95, 0x74, 0xa1, 0x15, 0x26, 0x2d, 0x2e,
0xe6, 0x11, 0x12, 0x46, 0x84, 0xf7, 0xc2, 0xee, 0x89, 0x27, 0xc3, 0xb1, 0x64, 0xe6, 0x45, 0xe8,
0xff, 0xa1, 0xa2, 0xd0, 0x22, 0xec, 0x5b, 0xce, 0x89, 0xf0, 0xaa, 0x66, 0x2e, 0xa5, 0x52, 0x13,
0xfb, 0xbb, 0x27, 0xe8, 0x8d, 0xca, 0x85, 0x45, 0x71, 0x82, 0xdf, 0x9a, 0xa1, 0x50, 0x15, 0xc9,
0x50, 0xa5, 0xc1, 0x3b, 0x30, 0xcf, 0xdb, 0x61, 0x99, 0x9e, 0x75, 0x53, 0x4e, 0xd0, 0x33, 0xb8,
0x7d, 0x42, 0x69, 0x6c, 0x89, 0xf6, 0x97, 0x3f, 0xd0, 0x9c, 0xc6, 0x82, 0xd8, 0x51, 0x85, 0x2f,
0x70, 0x04, 0xfe, 0x4e, 0xef, 0x9e, 0xf0, 0x97, 0x3a, 0xa0, 0x16, 0xee, 0xf7, 0x23, 0xc2, 0x98,
0xa8, 0x76, 0x4b, 0xa6, 0x1e, 0xd0, 0x2d, 0x29, 0xa8, 0xff, 0xa9, 0x00, 0x45, 0xae, 0x9d, 0xb5,
0xa7, 0x5a, 0xae, 0x3d, 0xed, 0x40, 0x51, 0xbc, 0x1a, 0x05, 0x11, 0x36, 0xaf, 0x66, 0xdd, 0x43,
0x83, 0xbf, 0x2f, 0xa6, 0x80, 0x40, 0xf7, 0x60, 0x51, 0xf1, 0x94, 0xb5, 0xc4, 0x02, 0x93, 0xfc,
0xf8, 0xb9, 0x0b, 0x9b, 0x34, 0xd0, 0xd2, 0x19, 0x7f, 0xa5, 0x71, 0x12, 0x53, 0xab, 0x2f, 0xde,
0x70, 0xb1, 0xb9, 0x92, 0x09, 0x5c, 0x24, 0x5f, 0x75, 0xae, 0xe0, 0xf3, 0x78, 0xb2, 0x42, 0xea,
0x06, 0xb1, 0xa8, 0xb4, 0x75, 0x13, 0x84, 0xa8, 0xcb, 0x25, 0x46, 0x0f, 0x8a, 0xe2, 0x81, 0xbb,
0x03, 0xd5, 0xa3, 0x1f, 0x75, 0xdb, 0xd6, 0x17, 0x07, 0xbd, 0x6e, 0xbb, 0xd5, 0x79, 0xd3, 0x69,
0xef, 0x54, 0x6f, 0x21, 0x04, 0x95, 0x6e, 0xdb, 0xec, 0x75, 0x7a, 0x47, 0xed, 0x83, 0x23, 0x6b,
0x6f, 0x67, 0xa7, 0xaa, 0x8d, 0xc8, 0x7a, 0xbd, 0x9d, 0x6a, 0x01, 0x2d, 0x83, 0xbe, 0x7f, 0xd8,
0xda, 0xda, 0x17, 0xd3, 0x39, 0xe3, 0xdf, 0xda, 0x20, 0xc2, 0xb2, 0xa6, 0x77, 0xa2, 0xf3, 0x46,
0x72, 0x4d, 0x61, 0x3c, 0xd7, 0x3c, 0x85, 0xe5, 0x3e, 0x39, 0xc5, 0x89, 0x17, 0x5b, 0x32, 0xf9,
0xc9, 0x8e, 0x67, 0x29, 0x15, 0x1e, 0x73, 0x19, 0x3a, 0x02, 0xf0, 0xa8, 0x8d, 0x3d, 0xcb, 0xa6,
0xe1, 0x65, 0xda, 0xf6, 0xbc, 0x9a, 0xa1, 0x43, 0x6f, 0xec, 0x73, 0xeb, 0x16, 0x0d, 0x2f, 0x4d,
0xdd, 0x53, 0xc3, 0xfa, 0x4b, 0xd0, 0x33, 0x39, 0x67, 0x9f, 0xbb, 0x4c, 0x62, 0xcc, 0x65, 0x3c,
0xb8, 0xd4, 0xdf, 0x0a, 0x3e, 0x36, 0xb6, 0xa0, 0x32, 0xdc, 0xb1, 0xf3, 0xe0, 0x12, 0xb5, 0x49,
0xfe, 0xd7, 0x8e, 0x2e, 0x24, 0xe2, 0xbf, 0xce, 0x58, 0xc5, 0xb2, 0xfe, 0x9b, 0xd2, 0xc0, 0x7d,
0xec, 0xf8, 0xc5, 0x96, 0x20, 0x8d, 0x7e, 0xab, 0x41, 0x65, 0xb8, 0xef, 0x46, 0xcd, 0x6b, 0x5e,
0x80, 0x49, 0x1d, 0x7a, 0x7d, 0x8a, 0x2a, 0xd2, 0xf8, 0xc6, 0xaf, 0xfe, 0xfa, 0x8f, 0x3f, 0x14,
0x1e, 0x19, 0x1f, 0x4c, 0xf8, 0x27, 0xb7, 0x99, 0x55, 0xe2, 0xe8, 0x17, 0x50, 0xce, 0x95, 0xed,
0xe8, 0x9b, 0x53, 0x55, 0xf7, 0x8a, 0xc7, 0x47, 0x4a, 0x3b, 0xf7, 0x77, 0xae, 0x91, 0x3d, 0x0a,
0x86, 0x21, 0x28, 0x3c, 0x34, 0xee, 0x4d, 0xa2, 0x10, 0x25, 0xc1, 0xa6, 0xb6, 0x86, 0xbe, 0xd2,
0xa0, 0x9c, 0x6b, 0x05, 0xae, 0x23, 0x30, 0xde, 0x31, 0x4c, 0xe5, 0x88, 0x67, 0x82, 0xc5, 0x53,
0xf4, 0x64, 0x02, 0x8b, 0xe6, 0xcf, 0x72, 0xd5, 0xf1, 0xcf, 0xd1, 0xef, 0x34, 0x58, 0x1e, 0x2a,
0xe5, 0x51, 0xe3, 0x9a, 0x5e, 0x79, 0x42, 0x23, 0x52, 0x6f, 0x4e, 0xad, 0x2f, 0x7b, 0x04, 0xe3,
0x81, 0x60, 0x77, 0x17, 0x4d, 0x3a, 0x26, 0xf4, 0x6b, 0x0d, 0x2a, 0xc3, 0x75, 0xfd, 0x75, 0xb1,
0x32, 0xb1, 0x03, 0xa8, 0x7f, 0x38, 0xf6, 0xa2, 0xb7, 0xfd, 0x30, 0xbe, 0x54, 0x6e, 0x59, 0x9b,
0xc2, 0x2d, 0x7f, 0xd4, 0xe0, 0x83, 0x09, 0x4d, 0x02, 0xfa, 0xf4, 0xda, 0xb3, 0xba, 0xa2, 0xa7,
0xa8, 0xaf, 0x4d, 0x5f, 0xef, 0x18, 0x4d, 0x41, 0xf2, 0x19, 0xfa, 0x64, 0x52, 0x04, 0x39, 0x13,
0x28, 0x7d, 0xad, 0x01, 0x1a, 0x2f, 0x4c, 0xd0, 0xcb, 0xeb, 0xfe, 0xd2, 0x5c, 0x51, 0xc6, 0x5c,
0xe9, 0xb9, 0x17, 0x82, 0xd4, 0xf3, 0xfa, 0xc7, 0x93, 0x48, 0xb1, 0x31, 0xb8, 0x4d, 0x6d, 0x6d,
0x3b, 0x84, 0x7b, 0x36, 0xf5, 0x27, 0x91, 0xd8, 0xae, 0x64, 0x31, 0xd1, 0xe5, 0x9f, 0xe9, 0x6a,
0x3f, 0xfe, 0x5c, 0xa9, 0x51, 0x0f, 0x07, 0x4e, 0x83, 0x46, 0x4e, 0xd3, 0x21, 0x81, 0x20, 0xd1,
0x94, 0x4b, 0x38, 0x74, 0xd9, 0xf8, 0x3f, 0xf7, 0xef, 0x2a, 0xc9, 0xbf, 0x34, 0xed, 0x64, 0x41,
0xe8, 0xbf, 0xfc, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x13, 0x10, 0x96, 0x1d, 0xa2, 0x17, 0x00,
0x00,
}
``` |
Sala, Lampang () is a village and tambon (subdistrict) of Ko Kha District, in Lampang Province, Thailand. In 2005 it had a total population of 8732 people. The tambon contains 7 villages.
Gallery
References
Tambon of Lampang province
Populated places in Lampang province |
```objective-c
/*===-- llvm-c/TargetMachine.h - Target Machine Library C Interface - C++ -*-=*\
|* *|
|* Exceptions. *|
|* See path_to_url for license information. *|
|* *|
|*===your_sha256_hash------===*|
|* *|
|* This header declares the C interface to the Target and TargetMachine *|
|* classes, which can be used to generate assembly or object files. *|
|* *|
|* Many exotic languages can interoperate with C code but have a harder time *|
|* with C++ due to name mangling. So in addition to C, this interface enables *|
|* tools written in such languages. *|
|* *|
\*===your_sha256_hash------===*/
#ifndef LLVM_C_TARGETMACHINE_H
#define LLVM_C_TARGETMACHINE_H
#include "llvm-c/ExternC.h"
#include "llvm-c/Target.h"
#include "llvm-c/Types.h"
LLVM_C_EXTERN_C_BEGIN
typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;
typedef struct LLVMTarget *LLVMTargetRef;
typedef enum {
LLVMCodeGenLevelNone,
LLVMCodeGenLevelLess,
LLVMCodeGenLevelDefault,
LLVMCodeGenLevelAggressive
} LLVMCodeGenOptLevel;
typedef enum {
LLVMRelocDefault,
LLVMRelocStatic,
LLVMRelocPIC,
LLVMRelocDynamicNoPic,
LLVMRelocROPI,
LLVMRelocRWPI,
LLVMRelocROPI_RWPI
} LLVMRelocMode;
typedef enum {
LLVMCodeModelDefault,
LLVMCodeModelJITDefault,
LLVMCodeModelTiny,
LLVMCodeModelSmall,
LLVMCodeModelKernel,
LLVMCodeModelMedium,
LLVMCodeModelLarge
} LLVMCodeModel;
typedef enum {
LLVMAssemblyFile,
LLVMObjectFile
} LLVMCodeGenFileType;
/** Returns the first llvm::Target in the registered targets list. */
LLVMTargetRef LLVMGetFirstTarget(void);
/** Returns the next llvm::Target given a previous one (or null if there's none) */
LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T);
/*===-- Target ------------------------------------------------------------===*/
/** Finds the target corresponding to the given name and stores it in \p T.
Returns 0 on success. */
LLVMTargetRef LLVMGetTargetFromName(const char *Name);
/** Finds the target corresponding to the given triple and stores it in \p T.
Returns 0 on success. Optionally returns any error in ErrorMessage.
Use LLVMDisposeMessage to dispose the message. */
LLVMBool LLVMGetTargetFromTriple(const char* Triple, LLVMTargetRef *T,
char **ErrorMessage);
/** Returns the name of a target. See llvm::Target::getName */
const char *LLVMGetTargetName(LLVMTargetRef T);
/** Returns the description of a target. See llvm::Target::getDescription */
const char *LLVMGetTargetDescription(LLVMTargetRef T);
/** Returns if the target has a JIT */
LLVMBool LLVMTargetHasJIT(LLVMTargetRef T);
/** Returns if the target has a TargetMachine associated */
LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T);
/** Returns if the target as an ASM backend (required for emitting output) */
LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T);
/*===-- Target Machine ----------------------------------------------------===*/
/** Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine */
LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
const char *Triple, const char *CPU, const char *Features,
LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, LLVMCodeModel CodeModel);
/** Dispose the LLVMTargetMachineRef instance generated by
LLVMCreateTargetMachine. */
void LLVMDisposeTargetMachine(LLVMTargetMachineRef T);
/** Returns the Target used in a TargetMachine */
LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T);
/** Returns the triple used creating this target machine. See
llvm::TargetMachine::getTriple. The result needs to be disposed with
LLVMDisposeMessage. */
char *LLVMGetTargetMachineTriple(LLVMTargetMachineRef T);
/** Returns the cpu used creating this target machine. See
llvm::TargetMachine::getCPU. The result needs to be disposed with
LLVMDisposeMessage. */
char *LLVMGetTargetMachineCPU(LLVMTargetMachineRef T);
/** Returns the feature string used creating this target machine. See
llvm::TargetMachine::getFeatureString. The result needs to be disposed with
LLVMDisposeMessage. */
char *LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T);
/** Create a DataLayout based on the targetMachine. */
LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T);
/** Set the target machine's ASM verbosity. */
void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
LLVMBool VerboseAsm);
/** Emits an asm or object file for the given module to the filename. This
wraps several c++ only classes (among them a file stream). Returns any
error in ErrorMessage. Use LLVMDisposeMessage to dispose the message. */
LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
char *Filename, LLVMCodeGenFileType codegen, char **ErrorMessage);
/** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */
LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,
LLVMCodeGenFileType codegen, char** ErrorMessage, LLVMMemoryBufferRef *OutMemBuf);
/*===-- Triple ------------------------------------------------------------===*/
/** Get a triple for the host machine as a string. The result needs to be
disposed with LLVMDisposeMessage. */
char* LLVMGetDefaultTargetTriple(void);
/** Normalize a target triple. The result needs to be disposed with
LLVMDisposeMessage. */
char* LLVMNormalizeTargetTriple(const char* triple);
/** Get the host CPU as a string. The result needs to be disposed with
LLVMDisposeMessage. */
char* LLVMGetHostCPUName(void);
/** Get the host CPU's features as a string. The result needs to be disposed
with LLVMDisposeMessage. */
char* LLVMGetHostCPUFeatures(void);
/** Adds the target-specific analysis passes to the pass manager. */
void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM);
LLVM_C_EXTERN_C_END
#endif
``` |
Zaitzevia thermae, also called the warm springs zaitzevian riffle beetle, is a flightless, wingless small beetle found in aquatic habitats in Montana.
Description
The species is distinguished from other elmids by its 8–segmented antennae, its side–lying and silk like elytra, pimply abdominal sternum, and other minor genetic differences. In general, but not always, the more slender form of Z. thermae can visually differentiate it from its sister species, Z. parvula.
Taxonomy
Zaitzevia thermae is sometimes treated as a synonym of or subspecies to Z. parvula; though this appears to be because a morphology report by Hooter in 1991 went unpublished and widely unread, which concluded that Z. thermae was its own distinct species and not a subspecies of another member of the genus. Due to this and the fact that the species is appropriately listed by the US Fish and Wildlife Service, Z. thermae is generally considered its own unique species.
Distribution
Zaitzevia thermae has a very limited range of less than 35 square meters in one specific location. They are known from only a handful of occurrences around a small warm spring along Bridger Creek, near Bozeman, Montana, on land owned by the US Fish and Wildlife Service. The primary threat to the species was the massive reduction of its habitat by human intervention, namely water collection infrastructure at the spring. In addition, fill in and around the spring further reduced the beetle's feeding grounds and habitat. The species is classified as N1, or critically imperiled, by NatureServe, but threats to its longevity have largely been eliminated, and drastic change in the size of its population in the next ten years is unlikely.
Another riffle beetle, Microcylloepus browni, has an almost identical distribution, endemic to the warm springs less than 300 meters down stream. Z. parvula, the sister species of Z. thermae, has a distribution that actually overlaps that of the latter species, and has an almost nationwide distribution in the United States.
Ecology
The species is found only in warm springs, in surface flowing water from 60–84 degrees Fahrenheit. The species attaches itself to the underside of rocks or clings to watercress and feeds on algae on the gravel bottom of the spring using their mandibles. They are non–migratory, and their lack of wings makes their dispersal opportunities limited, but are most likely long–lived, with lifespans of greater than a year.
References
Elmidae
Natural history of Montana
Beetles described in 1938
Beetles of North America
Wingless beetles |
Modern Combat 2: Black Pegasus is a 2010 first-person shooter developed and published by Gameloft for iOS, Android, Xperia Play and BlackBerry PlayBook devices as part of the Modern Combat series. It is a sequel to 2009's Modern Combat: Sandstorm, and features new environments, updated graphics and more robust multiplayer. A sequel was released in 2011, titled Modern Combat 3: Fallen Nation. This was followed by 2012's Modern Combat 4: Zero Hour and 2014's Modern Combat 5: Blackout.
Gameplay
The gameplay in Black Pegasus is quite similar to that of its predecessor, and also similar to Call of Duty 4: Modern Warfare and Call of Duty: Modern Warfare 2, as players travel through various environments, such as a snowy mountain and a jungle. There are three controllable characters in the game; Lieutenant "Chief" Warrens (the protagonist from Sandstorm), Sergeant Anderson, and Private Newman, who are members of Delta, Razor, and Mustang Squads, respectively.
The game is controlled using virtual buttons on-screen; a virtual control stick on the left of the screen is used for movement, while aiming is achieved by swiping on the touchscreen. Gyroscopic controls are featured on the iPhone 4 and fourth generation iPod Touch. The player can also crouch, throw grenades, use their weapon's iron sights, reload, change weapon, pick up different weapons, knife enemies, mantle obstacles, and shoot using buttons and prompts on the touchscreen. All controls can be customized from the main menu. The single-player campaign also includes Quick time events.
The graphics have advanced considerably since the previous game, due to the power of a new engine. On fourth generation devices utilizing a Retina Display, the graphics are even better.
Multiplayer
In addition to the single-player campaign, the game also includes an online multiplayer mode for up to 10 players, a drastic upgrade from Sandstorms four. Modes include "Capture the flag", "Deathmatch", "Team deathmatch", and a mode in which one team attempts to defuse a bomb while the other team protects it ("Demolition"). Killing enemies and securing objectives earns experience points, allowing players to level up through 72 ranks, rising up the global leaderboard, and unlocking new weaponry and bonuses. The host of the match can select the number of players, the time limit, score limit, and whether or not to allow "Aim Assist" and "Health Regeneration".
On April 12, 2011 downloadable content (DLC) was released for $1.99 under the name "Modern Combat 2: Black Pegasus Multiplayer Map Pack 1". It included three new maps ("Bunker", "Battlefield", and "Shanty Town"), all based on levels in the game. The update also fixed a few bugs with the game, such as killing teammates, and added a new look to the map "Jungle".
Plot
The game begins with two members of Mustang Squad imprisoned in the compound of international terrorist Pablo. Private Newman is being questioned by Pablo until he's knocked out with a rifle butt to the head. Private Downs then rescues Newman and they attempt to escape. However, after entering another part of the compound, they are caught in an ambush.
The game then shifts in time prior to the capture of Newman and Downs, as Lt. Mike "Chief" Warrens and Delta Squad assault an oil rig in the Middle East in an attempt to find Kali Ghazi (an underling of Abu Bahaa; the antagonist from Sandstorm). The mission is a success, but several men are lost during the fighting. Delta Squad interrogate Kali, persuading him to give up the name of his new boss.
Meanwhile, Sgt. Anderson and Razor Squad escort Azimi, a Middle Eastern politician, as he travels to the safety of the American embassy for peace talks. The convoy is attacked en route, but manages to make it to the embassy only to find the embassy itself has been attacked. The squad save the remaining American hostages, but then discover that Azimi himself is in fact a terrorist. During the subsequent battle, Azimi is killed.
Acting on information provided by Kali Ghazi, Mustang Squad travel to the compound of an eastern European arms dealer named Nikkitich. Fighting their way through a power plant, Newman ultimately finds Nikkitich inside a tank. Nikkitich surrenders and gives up his boss, Popovich, who has connections to the other leaders of the terrorist cell. Mustang Squad attack Popovich's bunker, with Newman and Downs heading to a Cold War-era bunker to find Popovich. However, they themselves are captured and taken to Pablo's compound.
The game then picks up with Newman and Downs caught in the ambush. They survive and manage to escape in a waiting helicopter. Acting on information provided by Newman and Downs, Razor Squad then heads to Pablo's private villa, where he is believed to be hiding. They attack the villa, but Pablo escapes into a nearby shanty town. After meeting Pablo's translator, Anderson follows Pablo, and destroys a helicopter protecting him. After a brief fight, Anderson kills Pablo by shoving a grenade into his mouth and pulling the pin.
Weapons
Whereas Sandstorm had only seven weapons, Black Pegasus has fifteen; including multiple pistols, two SMGs, several assault rifles, two sniper rifles, two shotguns, and an RPG, among others. Weapons can also be fitted with attachments like red dot sights or silencers.
When players first start with multiplayer, they can only use an AK-47 and a Beretta M9. As characters gain experience, they unlock new weapons and 'skills', such as increased movement speed. In multiplayer, there are variations for several of the weapons. Examples include a red dot sight on the MN106, and silencers for many secondary weapons. These variations grant advantages to the weapon, and in some cases slight disadvantages. They are unlocked after all the primary weapons are unlocked.
Weapons include an AK-47, an S1 Custom, an M40A3, an M249, an MN106 (a fictional assault rifle based on the real life M16A3), a Benelli M4, a Dradonitch (fictional semi-automatic sniper rifle based on the real life Dragunov sniper rifle), an RPG-7, a Beretta M9, a MAC-11, a Desert Eagle and an MP5
Reception
Black Pegasus has received extremely positive reviews, even better than those of its predecessor. The iPhone version received "universal acclaim" according to the review aggregation website Metacritic.
IGNs Levi Buchanan said, "Modern Combat 2 is Gameloft's best shooter yet, [...] even better than N.O.V.A.. But it's online that really takes things to the next level, with persistent perks that inspire you to keep playing. I recommend it to anybody seeking a great shooter for their iDevice." Chris Hall of 148Apps said, "the graphics are killer, the sound is great (especially with headphones), the weapon selection is top notch, the multiplayer is great, and the controls are easily the best I've ever encountered. Fans of the FPS genre will certainly not be disappointed with Modern Combat 2. If you've been waiting for a true first person shooter on the iPhone, now is the time." AppSpys Andrew Nesvadba argued that it improved exponentially on Sandstorm, saying, "Modern Combat 2: Black Pegasus not only continues the franchise, but it feels like so much more and the time spent waiting for this epic shooter was not without its benefits [...] The gorgeous Retina optimized graphics and single-player campaign are more than enough to justify grabbing Modern Combat 2: Black Pegasus, but the luscious and brutally fun multiplayer clinches the whole deal and action fans really should make it their next big purchase."
Pocket Gamers Tracy Erickson wrote of the iPhone version, "while it likely won't be long before a new game raises the bar, Modern Combat 2 has for now set the new shooter standard." Slide to Plays Chris Reed called it "top notch modern warfare on the go" and praised the multiplayer feature. TouchArcades Eli Hodapp said, "there is absolutely nothing like it on the App Store [...] The single player, while entirely cliche , is extremely fun to play through and the online multiplayer is incredible. Our forum members have been going crazy over the game, and as it stands, Modern Combat 2 is the king of iPhone first person shooters. For now, anyway."
TouchGens Matt Dunn, who had been somewhat critical of the first game, was again critical of the second game's storyline ("the single player campaign suffers from almost all the same issues that the original game suffered from. The story is almost non-existent, and is limited to a few sentences before each mission and some limited in-game dialogue"), and also criticsed some of mechanics of the game ("from a technical standpoint, MC2 leaves something to be desired. The collision detection for bullets is pretty bad, especially when sniping. About half the time, a direct headshot won't do anything to an enemy, or will be recorded as a body shot. Grenades and explosions are inconsistent as well"), but they praised the graphics ("Modern Combat 2 is a fantastic-looking game, with some of the best graphics I've seen in an App Store shooter. The game looks crisp and clear in both single player and multiplayer, and is one of those "show your friends" kind of games, for those doubting the graphical power of the A4 processor in the iPhone") and the multiplayer ("MC2 multiplayer gameplay is an absolute blast, and feels very solid [...] If you're a fan of online shooters, but don't mind the clunky menus or inability to easily play with friends, this is the game for you. The 5 vs 5 online matches are intense, and the different gametypes offer a nice variety of gameplay options. The addition of ranking and kill signatures will keep you playing for a while to come, and the gorgeous graphics really give the feel that this is much more than a mobile game").
However, the only critic to give the iOS version a negative review was James Stephanie Sterling of Destructoid, who stated, "When it works, Black Pegasus is a decent experience, but it's not a patch on the first game. Controls are poorly placed and the whole game feels sloppy and rushed, which is abysmal behavior from what is usually one of the best iOS developers in the business. Oh, and nobody's playing the multiplayer."
References
External links
2010 video games
Android (operating system) games
BlackBerry games
First-person shooter multiplayer online games
Gameloft games
IOS games
Multiplayer and single-player video games
Video games about terrorism
Video games developed in Canada
Video games set in Asia
Video games set in the 2010s
War video games set in Asia |
```ocaml
(*
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*)
exception Dns_resolve_timeout
exception Dns_resolve_error of exn list
(** The type of pluggable DNS resolver modules for request contexts and
custom metadata and wire protocols.
*)
module type CLIENT = sig
type context
val get_id : unit -> int
(** [marshal query] is a list of context-buffer pairs corresponding to the
channel contexts and request buffers with which to attempt DNS requests.
Requests are made in parallel and the first response to successfully
parse is returned as the answer. Lagging requests are kept running until
successful parse or timeout. With this behavior, it is easy to construct
low-latency but network-environment-aware DNS resolvers.
*)
val marshal : ?alloc:(unit -> Cstruct.t) -> Packet.t -> (context * Cstruct.t) list
(** [parse ctxt buf] is the potential packet extracted out of [buf]
with [ctxt]
*)
val parse : context -> Cstruct.t -> Packet.t option
(** [timeout ctxt] is the exception resulting from a context [ctxt] that has
timed-out
*)
val timeout : context -> exn
end
(** The default DNS resolver using the standard DNS protocol *)
module Client : CLIENT
(** The type of pluggable DNS server modules for request contexts and
custom metadata dn wire protocols.
*)
module type SERVER = sig
type context
(** Projects a context into its associated query *)
val query_of_context : context -> Packet.t
(** DNS wire format parser function.
@param buf message buffer
@return parsed packet and context
*)
val parse : Cstruct.t -> context option
(** DNS wire format marshal function.
@param alloc allocator
@param _q context
@param response answer packet
@return buffer to write
*)
val marshal : ?alloc:(unit -> Cstruct.t) -> context -> Packet.t -> Cstruct.t option
end
(** The default DNS server using the standard DNS protocol *)
module Server : SERVER with type context = Packet.t
val contain_exc : string -> (unit -> 'a) -> 'a option
``` |
```c++
//
// (See accompanying file LICENSE_1_0.txt or copy at
// path_to_url
//
// See path_to_url for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/bitwise.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/test.hpp>
typedef integral_c<unsigned int, 0> _0;
typedef integral_c<unsigned int, 1> _1;
typedef integral_c<unsigned int, 2> _2;
typedef integral_c<unsigned int, 8> _8;
typedef integral_c<unsigned int, 0xffffffff> _ffffffff;
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (bitand_<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_1,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_0,_1>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_0,_ffffffff>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitand_<_1,_ffffffff>::value), ==, 1 );
MPL_ASSERT_RELATION( (bitand_<_8,_ffffffff>::value), ==, 8 );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (bitor_<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitor_<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (bitor_<_0,_1>::value), ==, 1 );
MPL_ASSERT_RELATION( static_cast<long>(bitor_<_0,_ffffffff>::value), ==, static_cast<long>(0xffffffff) );
MPL_ASSERT_RELATION( static_cast<long>(bitor_<_1,_ffffffff>::value), ==, static_cast<long>(0xffffffff) );
MPL_ASSERT_RELATION( static_cast<long>(bitor_<_8,_ffffffff>::value), ==, static_cast<long>(0xffffffff) );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (bitxor_<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (bitxor_<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (bitxor_<_0,_1>::value), ==, 1 );
MPL_ASSERT_RELATION( static_cast<long>(bitxor_<_0,_ffffffff>::value), ==, static_cast<long>(0xffffffff ^ 0) );
MPL_ASSERT_RELATION( static_cast<long>(bitxor_<_1,_ffffffff>::value), ==, static_cast<long>(0xffffffff ^ 1) );
MPL_ASSERT_RELATION( static_cast<long>(bitxor_<_8,_ffffffff>::value), ==, static_cast<long>(0xffffffff ^ 8) );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (shift_right<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (shift_right<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (shift_right<_1,_1>::value), ==, 0 );
MPL_ASSERT_RELATION( (shift_right<_2,_1>::value), ==, 1 );
MPL_ASSERT_RELATION( (shift_right<_8,_1>::value), ==, 4 );
}
MPL_TEST_CASE()
{
MPL_ASSERT_RELATION( (shift_left<_0,_0>::value), ==, 0 );
MPL_ASSERT_RELATION( (shift_left<_1,_0>::value), ==, 1 );
MPL_ASSERT_RELATION( (shift_left<_1,_1>::value), ==, 2 );
MPL_ASSERT_RELATION( (shift_left<_2,_1>::value), ==, 4 );
MPL_ASSERT_RELATION( (shift_left<_8,_1>::value), ==, 16 );
}
``` |
This is a list of the National Register of Historic Places listings in Greenbrier County, West Virginia.
This is intended to be a complete list of the properties and districts on the National Register of Historic Places in Greenbrier County, West Virginia, United States. The locations of National Register properties and districts for which the latitude and longitude coordinates are included below, may be seen in an online map.
There are 45 properties and districts listed on the National Register in the county, 1 of which is a National Historic Landmark.
Current listings
|}
See also
List of National Historic Landmarks in West Virginia
National Register of Historic Places listings in West Virginia
References
Greenbrier County |
Aras District () is in Poldasht County, West Azerbaijan province, Iran.
At the 2006 National Census, the region's population (as a part of the former Poldasht District of Maku County) was 12,716 in 2,843 households. The following census in 2011 counted 14,049 people in 3,604 households, by which time the district had been separated from the county, Poldasht County established, and divided into two districts: the Central and Aras Districts. At the latest census in 2016, there were 13,793 inhabitants in 3,796 households.
References
Poldasht County
Districts of West Azerbaijan Province
Populated places in Poldasht County |
The 2016 season marks Glamorgan County Cricket Club's 129th year of existence and its 95th as a first-class cricket county. In 2016, Glamorgan is playing in the Second Division of the County Championship, and the South Groups of both the 50-over Royal London One-Day Cup and the NatWest t20 Blast. It is the first season in charge for head coach Robert Croft. The club captain is overseas player Jacques Rudolph. Unlike other counties, Glamorgan is competing in limited-overs cricket without a nickname for the fourth year in a row.
Squad
No. denotes the player's squad number, as worn on the back of their shirt.
denotes players with international caps.
denotes a player who has been awarded a county cap.
Ages given as of the first day of the County Championship season, 17 April 2016.
County Championship
In 2016 Glamorgan will play in Division Two of the County Championship.
Royal London One-Day Cup
NatWest t20 Blast
Pre-season friendlies
References
External links
Glamorgan home at ESPNcricinfo
2016
2016 in English cricket
2016 in Welsh sport
Welsh cricket in the 21st century
Seasons in Welsh cricket |
Chatursinh Javanji Chavda (born 29 March 1958) is an Indian politician and was member of Gujarat Legislative Assembly. He was the president of Gujarat Pradesh Congress Committee. Also, he served the party as head of Gandhinagar District Congress Committee.
He was elected from Gandhinagar North assembly constituency in 2017 Gujarat Legislative Assembly election. He contested 2019 Indian general election from Gandhinagar and was defeated.
He was elected from Vijapur Assembly constituency in 2022 Gujarat Legislative Assembly election as a INC candidate defeating his nearest rival and Bharatiya Janata Party candidate Ramanbhai Patel.
References
External links
http://myneta.info/Gujarat2017/candidate.php?candidate_id=5406
1968 births
Living people
Gujarat MLAs 2017–2022
Gujarat MLAs 2022–2027
Indian National Congress politicians from Gujarat |
```objective-c
/*
*
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef AOM_AOM_DSP_PROB_H_
#define AOM_AOM_DSP_PROB_H_
#include <assert.h>
#include <stdio.h>
#include "pxr/imaging/plugin/hioAvif/aom/config/aom_config.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_dsp/aom_dsp_common.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_dsp/entcode.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_ports/bitops.h"
#include "pxr/imaging/plugin/hioAvif/aom/aom_ports/mem.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef uint16_t aom_cdf_prob;
#define CDF_SIZE(x) ((x) + 1)
#define CDF_PROB_BITS 15
#define CDF_PROB_TOP (1 << CDF_PROB_BITS)
#define CDF_INIT_TOP 32768
#define CDF_SHIFT (15 - CDF_PROB_BITS)
/*The value stored in an iCDF is CDF_PROB_TOP minus the actual cumulative
probability (an "inverse" CDF).
This function converts from one representation to the other (and is its own
inverse).*/
#define AOM_ICDF(x) (CDF_PROB_TOP - (x))
#if CDF_SHIFT == 0
#define AOM_CDF2(a0) AOM_ICDF(a0), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF3(a0, a1) AOM_ICDF(a0), AOM_ICDF(a1), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF4(a0, a1, a2) \
AOM_ICDF(a0), AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF5(a0, a1, a2, a3) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF6(a0, a1, a2, a3, a4) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF7(a0, a1, a2, a3, a4, a5) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF8(a0, a1, a2, a3, a4, a5, a6) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF9(a0, a1, a2, a3, a4, a5, a6, a7) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF10(a0, a1, a2, a3, a4, a5, a6, a7, a8) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF11(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF12(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF13(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF14(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(a12), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF15(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(a12), AOM_ICDF(a13), AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, \
a14) \
AOM_ICDF(a0) \
, AOM_ICDF(a1), AOM_ICDF(a2), AOM_ICDF(a3), AOM_ICDF(a4), AOM_ICDF(a5), \
AOM_ICDF(a6), AOM_ICDF(a7), AOM_ICDF(a8), AOM_ICDF(a9), AOM_ICDF(a10), \
AOM_ICDF(a11), AOM_ICDF(a12), AOM_ICDF(a13), AOM_ICDF(a14), \
AOM_ICDF(CDF_PROB_TOP), 0
#else
#define AOM_CDF2(a0) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 2) + \
((CDF_INIT_TOP - 2) >> 1)) / \
((CDF_INIT_TOP - 2)) + \
1) \
, AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF3(a0, a1) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 3) + \
((CDF_INIT_TOP - 3) >> 1)) / \
((CDF_INIT_TOP - 3)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 3) + \
((CDF_INIT_TOP - 3) >> 1)) / \
((CDF_INIT_TOP - 3)) + \
2), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF4(a0, a1, a2) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 4) + \
((CDF_INIT_TOP - 4) >> 1)) / \
((CDF_INIT_TOP - 4)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 4) + \
((CDF_INIT_TOP - 4) >> 1)) / \
((CDF_INIT_TOP - 4)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 4) + \
((CDF_INIT_TOP - 4) >> 1)) / \
((CDF_INIT_TOP - 4)) + \
3), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF5(a0, a1, a2, a3) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 5) + \
((CDF_INIT_TOP - 5) >> 1)) / \
((CDF_INIT_TOP - 5)) + \
4), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF6(a0, a1, a2, a3, a4) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 6) + \
((CDF_INIT_TOP - 6) >> 1)) / \
((CDF_INIT_TOP - 6)) + \
5), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF7(a0, a1, a2, a3, a4, a5) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 7) + \
((CDF_INIT_TOP - 7) >> 1)) / \
((CDF_INIT_TOP - 7)) + \
6), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF8(a0, a1, a2, a3, a4, a5, a6) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 8) + \
((CDF_INIT_TOP - 8) >> 1)) / \
((CDF_INIT_TOP - 8)) + \
7), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF9(a0, a1, a2, a3, a4, a5, a6, a7) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 9) + \
((CDF_INIT_TOP - 9) >> 1)) / \
((CDF_INIT_TOP - 9)) + \
8), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF10(a0, a1, a2, a3, a4, a5, a6, a7, a8) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 10) + \
((CDF_INIT_TOP - 10) >> 1)) / \
((CDF_INIT_TOP - 10)) + \
9), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF11(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 11) + \
((CDF_INIT_TOP - 11) >> 1)) / \
((CDF_INIT_TOP - 11)) + \
10), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF12(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 12) + \
((CDF_INIT_TOP - 12) >> 1)) / \
((CDF_INIT_TOP - 12)) + \
11), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF13(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 13) + \
((CDF_INIT_TOP - 13) >> 1)) / \
((CDF_INIT_TOP - 13)) + \
12), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF14(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
12), \
AOM_ICDF((((a12)-13) * ((CDF_INIT_TOP >> CDF_SHIFT) - 14) + \
((CDF_INIT_TOP - 14) >> 1)) / \
((CDF_INIT_TOP - 14)) + \
13), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF15(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
12), \
AOM_ICDF((((a12)-13) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
13), \
AOM_ICDF((((a13)-14) * ((CDF_INIT_TOP >> CDF_SHIFT) - 15) + \
((CDF_INIT_TOP - 15) >> 1)) / \
((CDF_INIT_TOP - 15)) + \
14), \
AOM_ICDF(CDF_PROB_TOP), 0
#define AOM_CDF16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, \
a14) \
AOM_ICDF((((a0)-1) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
1) \
, \
AOM_ICDF((((a1)-2) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
2), \
AOM_ICDF((((a2)-3) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
3), \
AOM_ICDF((((a3)-4) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
4), \
AOM_ICDF((((a4)-5) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
5), \
AOM_ICDF((((a5)-6) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
6), \
AOM_ICDF((((a6)-7) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
7), \
AOM_ICDF((((a7)-8) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
8), \
AOM_ICDF((((a8)-9) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
9), \
AOM_ICDF((((a9)-10) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
10), \
AOM_ICDF((((a10)-11) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
11), \
AOM_ICDF((((a11)-12) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
12), \
AOM_ICDF((((a12)-13) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
13), \
AOM_ICDF((((a13)-14) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
14), \
AOM_ICDF((((a14)-15) * ((CDF_INIT_TOP >> CDF_SHIFT) - 16) + \
((CDF_INIT_TOP - 16) >> 1)) / \
((CDF_INIT_TOP - 16)) + \
15), \
AOM_ICDF(CDF_PROB_TOP), 0
#endif
static INLINE uint8_t get_prob(unsigned int num, unsigned int den) {
assert(den != 0);
{
const int p = (int)(((uint64_t)num * 256 + (den >> 1)) / den);
// (p > 255) ? 255 : (p < 1) ? 1 : p;
const int clipped_prob = p | ((255 - p) >> 23) | (p == 0);
return (uint8_t)clipped_prob;
}
}
static INLINE void update_cdf(aom_cdf_prob *cdf, int8_t val, int nsymbs) {
int rate;
int i, tmp;
static const int nsymbs2speed[17] = { 0, 0, 1, 1, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2 };
assert(nsymbs < 17);
rate = 3 + (cdf[nsymbs] > 15) + (cdf[nsymbs] > 31) +
nsymbs2speed[nsymbs]; // + get_msb(nsymbs);
tmp = AOM_ICDF(0);
// Single loop (faster)
for (i = 0; i < nsymbs - 1; ++i) {
tmp = (i == val) ? 0 : tmp;
if (tmp < cdf[i]) {
cdf[i] -= ((cdf[i] - tmp) >> rate);
} else {
cdf[i] += ((tmp - cdf[i]) >> rate);
}
}
cdf[nsymbs] += (cdf[nsymbs] < 32);
}
#ifdef __cplusplus
} // extern "C"
#endif
#endif // AOM_AOM_DSP_PROB_H_
``` |
Margit Bara (21 June 1928 – 25 October 2016) was a Hungarian film actress. She appeared in 25 films between 1956 and 1975. She retired from acting in 1977 and later in 1992 received the Order of Merit of the Republic of Hungary and in 2002 she was awarded the Kossuth Prize.
Selected filmography
Drama of the Lark (1963)
A Cozy Cottage (1963)
Jacob the Liar (1975)
References
External links
1928 births
2016 deaths
Hungarian film actresses
Actors from Cluj-Napoca
20th-century Hungarian actresses |
```javascript
Synchronous File Write/Read in Node.js
Asynchronous File Write/Read in Node.js
Global Objects and Environment Variables in **Node**
The built-in Node debugger
Handle `JSON.parse` error in Node.js
``` |
Big Lake State Park is a public recreation area located in northwest Missouri, United States. The state park was established in 1932 at the northern end of the state's largest oxbow lake, Big Lake. Park activities include boating, camping, picnicking, fishing, and swimming. Because park accommodations have been repeatedly destroyed by Missouri River floods, the park began using wheeled rental cabins that can be moved in the event of flooding in 2016.
References
External links
Big Lake State Park Missouri Department of Natural Resources
Big Lake State Park Map Missouri Department of Natural Resources
Protected areas of Holt County, Missouri
State parks of Missouri
Protected areas established in 1932 |
Manos may refer to:
Films
The Hands (Spanish: Las manos), a 2006 Argentinean-Italian film
Manos: The Hands of Fate, 1966 horror film
Music
Manos (band), German Black metal band
Manos (album), by The Spinanes
Other uses
Manos (name)
Mano (stone) or manos, a stone tool used to grind and process food
Manos: The Hands of Fate (video game), a 2012 video game based on the film
Monte Manos, a mountain of Lombardy, Italy
See also
En Tus Manos (disambiguation)
Mano (disambiguation) |
Amine El Khalifi (; born c. 1983) is a Moroccan man who was arrested by the Federal Bureau of Investigation (FBI) for plotting to carry out a suicide bombing on the United States Capitol. He was charged with "attempting to use a weapon of mass destruction against federal property" and now convicted, faces 30 years in prison.
El Khalifi thought he was working with al-Qaeda operatives, but was actually in contact with undercover FBI agents. He is believed to have no actual ties to al-Qaeda. All arms and support were provided by the FBI, and authorities say the operation never placed the public in danger.
On June 22, 2012, El Khalifi pleaded guilty in federal court in the Eastern District of Virginia of trying to carry out a suicide bomb attack on the U.S. Capitol Building in February 2012 as part of what he intended to be a terrorist operation and was sentenced to 30 years in prison the following September.
Early life
El Khalifi came to the United States on a visitor's visa at the age of 16. He settled in Arlington County, Virginia, as an illegal immigrant when his visa expired in 1999.
He worked at odd jobs and had occasional minor brushes with the law, including a marijuana charge and traffic violations. According to an acquaintance, El Khalifi regularly attended a mosque in Falls Church.
El Khalifi attracted attention in 2010, when his suburban Virginia landlord called police after the man allegedly threatened to beat him up. At the time, El Khalifi was being evicted from his apartment for failure to pay rent. The landlord was suspicious of packages El Khalifi had been receiving, and told police he thought El Khalifi was making bombs, but police told him to leave the man alone. At least one other man was living with El Khalifi at the time, and he claimed to be running a luggage business.
Bombing plot
By January 2011, El Khalifi was under federal surveillance. At a meeting in an Arlington residence he agreed when someone stated that the "war on terrorism" was a "war on Muslims," according to an informant. El Khalifi watched as the man produced an AK-47 rifle, two revolvers and ammunition, and discussed being ready to "fight back".
El Khalifi allegedly expressed a desire to be "associated with an armed extremist group." In December 2011, he was introduced to "Yusaf", an undercover officer. El Khalifi allegedly told Yusaf that he wanted to carry out a mass shooting at a Washington, D.C. restaurant frequented by U.S. military officers. He allegedly wanted to kill at least 30 people and was also considering targeting an office building in Alexandria, a restaurant, or a synagogue. He is said to have expressed interest in gunning people down "face-to-face."
On January 7, 2012, El Khalifi discussed a larger attack on a military facility. On January 15, El Khalifi changed his plan, allegedly telling under cover officers that he now wanted to carry out a suicide bombing. That same day he is said to have carried out a test with a cellphone detonation device. When the test was successful, he expressed a desire for larger explosives, enough to blow up a building. He selected February 17 as the day for his attack. He visited Washington, D.C. several times over the following weeks to plan his attack and purchased supplies for his operation including nails. He asked for a gun to shoot anyone who tried to interfere with his "martyrdom operation" and request remote detonation of the bomb in the event he was captured.
On February 17, El Khalifi went to the Dar Al-Hijrah Islamic Center to pray before embarking on a suicide mission. Authorities say he was "not a regular" at that mosque or any other in the area. The mosque's imam offered to provide authorities with surveillance footage, but was told it was not necessary. Later that day, El Khalifi was provided a disarmed suicide vest and MAC-10 by Yusaf and transported to downtown Washington. He was arrested before he exited the parking building he had been dropped off in, as he walked alone toward the Capitol building. After the arrest, authorities raided his west Alexandria residence and searched his property. "There is no doubt that this guy was committed," commented a law enforcement officer.
El Khalifi was unemployed at the time of arrest and is not believed to have a genuine association with al-Qaeda. Authorities say they are close to arresting an associate of his on unrelated charges. "Today's case underscores the continuing threat we face from homegrown violent extremists," remarked Assistant Attorney General Lisa Monaco. "Thanks to a coordinated law enforcement effort, El Khalifi's plot was thwarted before anyone was harmed." Some commentators were critical of the arrest, saying the sting operation was a form of entrapment.
Court case
El Khalifi appeared in court the afternoon of his arrest and was charged with attempting to use a weapon of mass destruction against U.S. property. An attorney for the government stated "El Khalifi ... devised the plot, the targets and the methods on his own." On February 22, El Khalifi appeared in court before Judge John Anderson and waived his rights to preliminary and detention hearings. He was represented by a federal public defender during the hearing. Judge Anderson ordered El Khalifi held pending indictment due to the serious nature of the charges.
At a hearing on June 22, 2012, before U.S. District Court Judge James C. Cacheris, El Khalifi pleaded guilty to one count of attempted use of a weapon of mass destruction (specifically, a destructive device consisting of an improvised explosive device) against U.S. property, namely, the U.S. Capitol Building in Washington, D.C. As part of the plea agreement, the United States and El Khalifi agree that a sentence within a range of 25 years to 30 years' incarceration is the appropriate disposition of this case. El Khalifi was sentenced to 30 years in prison on September 14, 2012. He is currently at FMC Butner with BOP #79748-083.
See also
2010 Portland car bomb plot
Islamic extremism in the United States
Farooque Ahmed
Rezwan Ferdaus
David Headley
Sami Osmakac
Faisal Shahzad
References
External links
PDF copy of full arrest warrant
fbi.gov
Islamic terrorism in the United States
Living people
War on terror
1980s births
Moroccan people imprisoned abroad
Moroccan emigrants to the United States
Prisoners and detainees of the United States federal government
American Muslims |
Dharmaram College is a major seminary of the Carmelites of Mary Immaculate congregation. It was relocated to Bangalore, India in 1957 from Chethipuzha in Kerala. It is the combination of the Sanskrit words dharma (virtue) and arāma (garden) or "Rāma" (Almighty, NOT Vishnu's avatar) that makes the word Dharmaram, which means 'Garden of Virtues'. The 'Garden of Virtues' symbolizes the Sacred Heart of Jesus to which Dharmaram is dedicated to. "Isabhakti Paramjnanam" (Love of God is the Supreme Wisdom) is the motto of Dharmaram. (It is to be noted that "Isa" could also mean "Ishwara" / Almighty)
The aim of Dharmaram is to form holistically, spiritually, intellectually and culturally future generation priests who are prepared to commit themselves to the service of the Church and the world.
References
External links
Official Website of Carmelites of Mary Immaculate
Official Website of Dharmaram College
Location of Dharmaram college
Seminaries and theological colleges in India
Colleges in Bangalore |
Kodiyeri Balakrishnan (16 November 1953 – 1 October 2022) was an Indian politician of the Communist Party of India (Marxist). He was the secretary of the CPI(M) Kerala State Committee from 2015 to 2022. He stepped down from the position of state secretary due to his failing health. He was the Chief Editor of the Malayalam newspaper Deshabhimani.
Balakrishnan was the Deputy Leader of the Opposition in the Kerala Legislative Assembly from 2001 to 2006 and again from 2011 to 2016, and also served as the State Minister of Home Affairs and Tourism from 2006 to 2011 under the Achuthananadan Ministry. He represented Thalassery State Assembly Constituency in the Kerala Legislative Assembly from 1982 to 1991 and again from 2001 to 2016.
Political life
Balakrishnan entered politics through the student wing of the CPI(M) in 1970. He was Secretary of the Kerala State Committee of the Students' Federation of India (SFI) and its All India Joint Secretary between 1973 and 1979. During the time of the emergency, Kodiyeri Balakrishnan was imprisoned under MISA for 16 months.
From 1980 to 1982, he was the Kannur District President of Democratic Youth Federation of India (DYFI). He was a CPI (M) Politburo member and was CPI (M) Parliamentary Party Deputy Leader. He was elected as an MLA to Kerala Legislative Assembly in 1982, 1987, 2001, 2006 and 2011 from Thalassery.
He was Minister of Home affairs of Kerala during the time of V S Achudanandan Ministry.
On 23 February 2015, he was elected as the Secretary of the Communist Party of India (Marxist) Kerala State Committee for a period of 3 years. He was re-elected for a second term as a State Secretary in 2018 and for a third term in March 2022. On 28 August 2022, he stepped down from the position due to failing health and was succeeded by M. V. Govindan.
Personal life and death
Balakrishnan was born in Kodiyeri, Thalassery to Kunjunni Kurup and Narayani Amma on 16 November 1953. He studied in Kodiyeri Junior Basic School and Oniyan High School. He became active in politics while studying at Mahatma Gandhi Government Arts College, Mahé and was active in University College, Thiruvananthapuram.
In 1980, he married S. R. Vinodini, daughter of ex-MLA M. V. Rajagopalan Master and had two children, Binoy Kodiyeri and Bineesh Kodiyeri.
Balakrishnan was diagnosed with pancreatic cancer and admitted in Apollo Hospital, Chennai from 28 August 2022 in view of worsening health. He died on 1 October 2022, at the age of 68.
References
External links
Biography of Kodiyeri Balakrishnan on the CPIM website
1953 births
2022 deaths
People from Thalassery
Malayali politicians
Communist Party of India (Marxist) politicians from Kerala
Kerala MLAs 1982–1987
Kerala MLAs 1987–1991
Kerala MLAs 2001–2006
Kerala MLAs 2011–2016
Kerala MLAs 2006–2011
Deaths from cancer in India |
```html
<!-- Search accordion for /api/v1/hosts/<id> (filtering task results) -->
{% load datetime_formatting %}
{% if not static_generation %}
<div class="col-xl-6 offset-xl-3">
<div class="accordion" id="search_accordion">
<div class="accordion-item">
<h2 class="accordion-header">
<button class="accordion-button text-bg-ara {% if not expand_search %}collapsed{% endif %}" type="button" data-bs-toggle="collapse" data-bs-target="#search_host_results" aria-expanded="{% if expand_search %}true{% else %}false{% endif %}" aria-controls="search_host_results">
<svg xmlns="path_to_url" width="16" height="16" fill="currentColor" class="bi bi-search" viewBox="0 0 16 16">
<path d="M11.742 10.344a6.5 6.5 0 1 0-1.397 1.398h-.001c.03.04.062.078.098.115l3.85 3.85a1 1 0 0 0 1.415-1.414l-3.85-3.85a1.007 1.007 0 0 0-.115-.1zM12 6.5a5.5 5.5 0 1 1-11 0 5.5 5.5 0 0 1 11 0z"></path>
</svg>
Search and filter host results
</button>
</h2>
<div id="search_host_results" class="accordion-collapse collapse {% if expand_search %}show{% endif %}" data-bs-parent="#search_host_results">
<div class="accordion-body">
<form method="get" action="{% url 'ui:host' host.id %}#results">
<!-- task name -->
<div class="row g-2">
<div class="col-md">
<div class="form-floating">
<input type="text" class="form-control" id="task_name" name="task_name" placeholder="ex: Install httpd" value="{{ search_form.task_name.value | default_if_none:'' }}">
<label for="task_name" {% if request.GET.task_name %}style="font-weight:bold;"{% endif %}>Task name</label>
</div>
</div>
</div>
<br />
<!-- Result status -->
<div class="row g-2">
<div class="col-md">
<label for="status" {% if request.GET.status %}style="font-weight:bold;"{% endif %}>Status: </label>
{% for value, text in search_form.status.field.choices %}
{% if value != "unknown" %}
<div class="form-check form-check-inline {% if value == 'completed' %}text-success{% elif value == 'failed' %}text-danger{% elif value == 'running' %}text-info{% else %}text-warning{% endif %}">
<input class="form-check-input" type="checkbox" id="{{ value }}" value="{{ value }}" name="status" {% if value in search_form.status.data %}checked{% endif %}>
<label class="form-check-label" for="{{ value }}">
{% include "partials/result_status_icon.html" with status=value %}
</label>
</div>
{% endif %}
{% endfor %}
</div>
</div>
<br />
<!-- include only changes -->
<div class="row g-2">
<div class="col-md">
<label class="align-middle" for="changed" {% if request.GET.changed %}style="font-weight:bold;"{% endif %}>Changed: </label>
<div class="form-check form-check-inline">
<input class="form-check-input" type="checkbox" id="changed" value="true" name="changed" {% if search_form.changed.value %}checked{% endif %}/>
<label class="form-check-label" for="changed">
<span class="btn btn-warning btn-sm ara-result-status-badge" title="Search changed results">
CHANGED
</span>
</label>
</div>
</div>
</div>
<br />
<!-- submit -->
<div class="row g-2">
<div class="col-md">
<button type="submit" class="btn btn-primary">Submit</button>
</div>
</div>
</form>
<!-- reset button -->
{% if request.GET %}
<br />
<div class="row g-2">
<div class="col-md">
<a class="btn btn-outline-danger" href="{% url 'ui:host' host.id %}#results" role="button">Reset</a>
</div>
</div>
{% endif %}
</div>
</div>
</div>
</div>
</div>
{% endif %}
``` |
Kotyhoroshko (Ukrainian: Котигорошко), also Kotygoroshko, is the hero of the Eastern European folk tale of Ukrainian origin of the same name, centered around a boy of extraordinary strength who was born from a pea and freed his own brothers and sisters from the captivity of a serpent.
Name and origin
The name Kotyhoroshko is related to peas, a leguminous crop that has been grown since the Chalcolithic period by the peoples who inhabited Eastern Asia, the coastal lands of the Mediterranean and Black seas. Peas were considered a sign of life-giving force in agricultural societies: yield, fertility of livestock and prosperity of the land owner. In particular, among the Slavs, peas were an integral part of the Christmas table and marriage customs associated with the birth of children.
The image of the hero Kotyhoroshko, as it is believed in modern folklore, goes back to the initial Indo-European mythological tale about a hero born by a good miracle, who frees a kidnapped girl with the help of a powerful weapon. The epic Ramayana (Indra's liberation of his wife Sita from Ravana's captivity) and fairy tales such as "Bukh Kopytovych" or "Suchenko" are based on the same content.
The Russian historian, Borys Rybakov, considered the fairy tale Kotyhoroshko as a late Neolithic mythologeme about the journey of a magician to the afterlife to liberate the souls of the dead.
Ukrainian folklorist Viktor Davidyuk considered Kotyhoroshko as the embodiment of the collective strength of his brothers, who were captured by a snake or serpent. Therefore, Kotyhoroshko shows extraordinary strength even before passing the main test. Peas in this case symbolize the embodiment of the human essence in other forms.
Kotyhoroshko in fairy tales
Main plot
A father sends his six sons to plow the field, and his daughter to bring them lunch. The daughter then looks for the brothers, following the furrow plowed by them, but the serpent tricks her by making his own furrow to lure her to him and imprison her. When the brothers go to free her, the serpent challenges them to a battle. The serpent defeats all six sons and imprisons them also.
Now without children, their mother eats a pea that rolled by, after which she gives birth to a son, whom she calls Kotyhoroshko (Котигорошко or "Pea"). The boy grows quickly, becomes extremely strong and digs a hole to obtain a piece of iron. After that, he asks his parents where his brothers and sister are. They dissuade him from searching, but Kotyhoroshko takes the iron to the blacksmith to make a weapon to fight against the snake. The blacksmith forges a mace, and Kotyhoroshko tosses it twice, testing its strength. The first version breaks from falling, and the second version bends. Taking the final mace, Kotyhoroshko proceeds to the snake's lair.
Hiding in the snake's dwelling, Kotyhoroshko is waiting for the snake. When the snake dies, Kotyhoroshko takes the snake's treasures and frees the prisoners, but does not reveal that he is their brother. On the way home, Kotyhoroshko falls asleep, and the brothers plan to tie Kotyhoroshko face down to an oak tree and tell their parents that they alone defeated the snake. Arriving home, the brothers learn from their parents about Kotyhoroshko. Meanwhile, Kotyhoroshko uproots the oak tree and throws it into the house. After that Kotyhoroshko leaves.
While traveling the world, Kotyhoroshko meets three men with unusual powers: Vernyhora (Вернигору), Vernydub (Вернидуба) and Krutyvus (Крутивуса). Vernihora can move mountains, Vernydub can uproot oak trees with his bare hands, and Krutyvus can make waters part. The four of them reach an empty cabin in the forest, where they stop for the night.
In the next three days, three go hunting, while a different one each day stays in the hut to guard and cook food. Repeatedly, a small but powerful old man (grandfather) comes with demands to each of the three men standing watch in their turn. When Vernyhora, Vernydub, and Krutyvus each in turn treat the grandfather disrespectfully, the grandfather hangs each one guarding on a nail, eats everything prepared and leaves. None of the three men admit this, and tell the others that they fell asleep and did not have time to prepare food. On the fourth day, Kotyhoroshko himself remains in the hut. Kotyhoroshko puts the old man outside, but the old man tries to hang Kotyhoroshko in the same way. Kotyhoroshko pinches the old man's beard in an oak tree. The old man then pulls the oak tree from the ground and runs away.
Their trail leads to a pit into which Vernyhora, Vernydub and Krutyvus are afraid to go. They decide to knit ropes on which Kotyhoroshko descends into the pit. At the bottom there is a palace and a princess, who dissuades Kotyhoroshko from fighting with the old man. Kotyhoroshko still fights the old man, kills him and takes the treasures together with the princess. Kotyhoroshko's friends pull out three bags of jewels and the princess's robe to the surface, and they decide to throw Kotyhoroshko down. Kotyhoroshko ties a stone to the rope instead of himself and when it is dropped, remains unharmed.
Inside the pit, Kotyhoroshko protects some chicks from a thunderstorm. When a bird flies in and asks who covered them from the rain, the chicks point to Kotyhoroshko. The bird promises to fulfill his wish for this, and he wishes to fly to the surface. During the flight of the bird, the bird asks for six pieces of meat and water to feed it. There is not enough meat, so Kotyhoroshko cuts off his calf and gives it to the bird. After learning what Kotyhoroshko gave her, the bird regurgitates the calf and brings living water. Sprinkled with water, the calf grows in its place.
After getting out of the pit, Kotyhoroshko looks for Vernyhora, Vernydub and Krutyvus. He punishes them and marries the princess.
In the Ukrainian version of the tale, the grandfather not only hangs the guards on nails, but also cuts a belt from the leather on the back of each; the bird is described sometimes as the mother of chicks; Kotyhoroshko forgives his betraying friends.
Interpretation of the content of the fairy tale
According to ethnologists, the plot of the liberation of the brothers from the serpent's captivity reflects the liberation from foreign oppression. The motive of abducting the bride is considered to be a reflection of the original customs of transferring her from her parents' lineage to her own. At the same time, the boy can find a bride in a different family, where he was brought up. The struggle with the bride's guards is an allegory of the magical struggle with the totem of the family. This also includes the original rite of killing the king (or a person representing him), necessary for marrying his daughter and inheriting the throne.
Ukrainian folklorist Lidia Dunaevska noted that the fairy tale "Kotyhoroshko" depicts the hero's initiation, and according to an atypical structure. Usually, the old man or grandfather, who represents the ancestor, must help the hero for showing kindness. But here it happens at the end, when Kotyhoroshko sacrifices a calf to a bird. Kotyhoroshko has the characteristics of a hero, which he acquires after the fight with the snake, and which takes place in a liminal space (where there is uncertainty). Having overcome the snake, the hero gets rid of uncertainty about his fate and leaves the everyday world for further exploits, unlike his brothers, who do not fight with the snake.
According to Viktor Davydyuk, Kotyhoroshko belongs to the same line of fairytale heroes as Ivan the Son of Man and Ivan Pobyvan. They are united by the acquisition of invulnerability after being hit by an opponent. Viktor Davydyuk interpreted this as the use of wisdom to counteract physical force. The hero knows that he needs the snake strike to gain power. Kotyhoroshko deliberately allows him to strike the first blow in order to go beyond ordinary time and space, to become eternal and immortal. Similarly, the weakness of friends in front of the old man and their betrayal serves as a warning for Kotyhoroshka himself.
Image in culture
Cartoons
1970 — "Kotyhoroshko" ("Котигорошко", Kyivnaukfilm). Director: Boris Hranevich. Production designer: Yuriy Skirda.
2008 — "Magic pea" ("чарівний горох"). Director: Rudenko-Shvedova Yaroslava Yuriivna . Production designer: Eduard Kirich.
2013 — "Adventures of Kotyhoroshka and his friends" (Ukrainian: "Пригоди Котигорошка та його друзів", Ukranimafilm). Director: Rudenko-Shvedova Yaroslava Yuriivna . Production designer: Eduard Kirich.
Movies
1960 - family fantasy film entitled Letayushchiy korabl.
Books
The story of Kotyhoroshko has been translated into Japanese.
Plays
Ukrainian play of the same name by Anatoly Shiyan (b. April 5, 1906, Borysovka - d. May 6, 1989, Kyiv)
Stories
In Vsevolod Nestaik's story "In the Land of the Sunny Bunnies", one of the residents of the Palace of Magical Tales fought with snakes during the release of negative characters by Mr. Morok.
Other
Kotyhoroshko is a Ukrainian surname.
Ivan Kotyhoroshko is a heroic character in Mykhailo Kotsyubynskyi's story "At a High Price".
Vasyl Kozhelyanko's fantasy novel "Kotyhoroshko" (2000). The main character is Vyshneslav Kotygoroshko.
References
Ukrainian folklore
Slavic folklore
Ukrainian fairy tales |
```go
package copy
import (
"github.com/containers/image/signature"
"github.com/containers/image/transports"
"github.com/pkg/errors"
)
// createSignature creates a new signature of manifest using keyIdentity.
func (c *copier) createSignature(manifest []byte, keyIdentity string) ([]byte, error) {
mech, err := signature.NewGPGSigningMechanism()
if err != nil {
return nil, errors.Wrap(err, "Error initializing GPG")
}
defer mech.Close()
if err := mech.SupportsSigning(); err != nil {
return nil, errors.Wrap(err, "Signing not supported")
}
dockerReference := c.dest.Reference().DockerReference()
if dockerReference == nil {
return nil, errors.Errorf("Cannot determine canonical Docker reference for destination %s", transports.ImageName(c.dest.Reference()))
}
c.Printf("Signing manifest\n")
newSig, err := signature.SignDockerManifest(manifest, dockerReference.String(), mech, keyIdentity)
if err != nil {
return nil, errors.Wrap(err, "Error creating signature")
}
return newSig, nil
}
``` |
```shell
#!/bin/sh
#
# Run this script in a directory that contains a valid SQLite makefile in
# order to verify that unintentionally exported symbols.
#
make sqlite3.c
echo '****** Exported symbols from a build including RTREE && FTS4 ******'
gcc -c -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_RTREE \
-DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_STAT3 \
-DSQLITE_ENABLE_MEMSYS5 -DSQLITE_ENABLE_UNLOCK_NOTIFY \
-DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_ATOMIC_WRITE \
sqlite3.c
nm sqlite3.o | grep " [TD] "
echo '****** Surplus symbols from a build including RTREE & FTS4 ******'
nm sqlite3.o | grep " [TD] " | grep -v " .*sqlite3_"
echo '****** Dependencies of the core. No extensions. No OS interface *******'
gcc -c -DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_STAT3 \
-DSQLITE_ENABLE_MEMSYS5 -DSQLITE_ENABLE_UNLOCK_NOTIFY \
-DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_ATOMIC_WRITE \
-DSQLITE_OS_OTHER -DSQLITE_THREADSAFE=0 \
sqlite3.c
nm sqlite3.o | grep " U "
echo '****** Dependencies including RTREE & FTS4 *******'
gcc -c -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_RTREE \
-DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_STAT3 \
-DSQLITE_ENABLE_MEMSYS5 -DSQLITE_ENABLE_UNLOCK_NOTIFY \
-DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_ATOMIC_WRITE \
sqlite3.c
nm sqlite3.o | grep " U "
``` |
193 A.D. is a year.
193 may also refer to:
193 Ambrosia
Connecticut Route 193
Maryland Route 193
West Virginia Route 193
Alabama State Route 193
California State Route 193
Ohio State Route 193
Georgia State Route 193
Maine State Route 193
New York State Route 193
Tennessee State Route 193
Utah State Route 193
Virginia State Route 193
Washington State Route 193
Japan National Route 193
Arkansas Highway 193
Wisconsin Highway 193
Wyoming Highway 193
Mexican Federal Highway 193
Texas State Highway 193
Jordan 193
Eyebrow No. 193, Saskatchewan
Lectionary 193
Radical 193
Minuscule 193
Trial of the 193
DFS 193
JWH-193
SP-193
USA-193
ICRF 193
P.S. 193
National Airlines Flight 193
German submarine U-193
193rd (2nd Argyll & Sutherland Highlanders) Brigade
193rd Battalion (Nova Scotia Highlanders), CEF
193rd Ohio Infantry
193rd Infantry Brigade (United States)
193d Special Operations Squadron
193d Special Operations Wing
Ikkyū |
James Jordan (born March 14, 1979) is an American actor.
Life and career
Jordan was born on March 14, 1979, in Houston Texas. He grew up in Texas and Webb City, Missouri, graduating from Webb City High School in 1997. Jordan went to college at Missouri Southern in Joplin and graduated from UCLA School of Theater, Film and Television with a Master of Fine Arts in Acting.
Jordan has had roles in series such as Veronica Mars, playing two different characters (Lucky, a janitor at Neptune High, and Tim Foyle), and has also appeared in Without a Trace, Seraphim Falls, Just Legal, Cold Case, Close to Home and CSI: Crime Scene Investigation among other prime-time television dramas.
Jordan has guest-starred on TNT's The Closer, Fox's 24 opposite Kiefer Sutherland, and he had a guest star role on FX's Elmore Leonard-inspired series Justified starring Timothy Olyphant. Jordan was also cast as the mentally disturbed former Marine "Ray Brennan" in TNT's adaptation of April Smith's thriller novel Good Morning, Killer. The film aired as part of TNT's Movie Mystery Night in December 2011.
In 2012, Jordan played one of the "Obamas" on HBO's hit series, True Blood. He played "Ray", the anti-vampire bigot that takes Jessica Hamby hostage. He also played a role in Best Night Ever, a comedy from the creators of the Scary Movie franchise, which was released in 2014. He guest starred on CBS' The Mentalist in the winter of 2012.
Jordan guest-starred in season three of Hulu series Blue starring Julia Stiles. Season three premiered in late March 2014. He was cast in two independent feature films in March 2015: Message from the King starring Chadwick Boseman, Luke Evans, Alfred Molina, directed by Fabrice Du Welz, and in the Kelly Reichardt directed ensemble piece Certain Women about life in small town Montana with Kristen Stewart, Laura Dern, and Michelle Williams. Both films were slated for released in 2016.
In 2017, Jordan appeared in Wind River, written and directed by Taylor Sheridan. In 2021, Jordan was cast in Those Who Wish Me Dead. Jordan also had recurring roles in several Sheridan created television shows such as Yellowstone, Mayor of Kingstown, 1883 and Special Ops: Lioness.
Filmography
Film
Television
Web
Video games
External links
1979 births
Living people
American male television actors
Male actors from Houston
Place of birth missing (living people)
UCLA Film School alumni |
The discography of American country music artist Wynonna contains nine studio albums, four compilation albums, two video albums, one live album, one extended play (EP), 43 singles, 11 music videos and one other-charting song. She achieved success as one half of the mother-daughter duo, The Judds. In 1991, the duo split and Wynonna signed a solo recording contract with MCA Records that year. In March 1992, her debut studio album entitled Wynonna reached number one on the Billboard Top Country Albums chart and number four on the Billboard 200. The album spawned three number one hits on the Billboard Hot Country Songs chart: "She Is His Only Need," "I Saw the Light" and "No One Else on Earth." The album also sold over five million copies. In 1993, it was followed by Tell Me Why, which certified platinum in the United States. It also topped the country albums chart and reached number five on the Billboard 200 It spawned five more top ten country hits, including the title track and "Rock Bottom."
In 1996, her third studio album Revelations was issued. It produced the number one hit "To Be Loved by You" and reached number two on the Billboard country albums chart. It was followed by 1997's The Other Side, which debuted in the Billboard country top five. It spawned two top 20 hits, including "When Love Starts Talkin'." In 2000, Judd released her fifth studio album, New Day Dawning, which produced no major hit singles. In 2003, Judd returned with her sixth studio effort, What the World Needs Now Is Love. It reached number one on the Top Country Albums chart and number eight on the Billboard 200. It produced Judd's final top 20 country hit: "What the World Needs." In 2005, she released her first live effort entitled Her Story: Scenes from a Lifetime. Its only single, "Attitude," is her final country top 40 hit to date. In 2006, her first holiday album reached number ten on the country albums chart. In 2009, she issued an album of cover songs entitled Sing: Chapter 1. The title track reached number four on the Billboard Hot Dance Club Songs chart. In 2016, Judd released her eighth studio offering called Wynonna & the Big Noise on Curb Records.
Albums
Studio albums
Compilation albums
Live albums
Extended plays
Singles
As lead artist
As a featured artist
Other charted songs
Videography
Video albums
Music videos
See also
The Judds discography
Notes
References
External links
Wynonna Judd discography at her official website
Country music discographies
Discographies of American artists
Discography |
The (, plural ), in Irish () is a fairy creature from Celtic mythology, said to resemble a large black cat with a white spot on its chest. Legend has it that the spectral cat haunts the Scottish Highlands. The legends surrounding this creature are more common in Scottish folklore, but a few occur in Irish. Some common folklore suggested that the was not a fairy, but a witch that could transform into a cat nine times.
The may have been inspired by the Scottish wildcat itself. It is possible that the legends of the were inspired by Kellas cats, which are a distinctive hybrid between Scottish wildcats and domestic cats found only in Scotland (the Scottish wildcat is a population of the European wildcat, which is now absent from elsewhere in the British Isles).
Appearance
The is all black with the exception of a white spot on its chest. It is described as being as large as a dog and chooses to display itself with its back arched and bristles erect.
The King of the Cats
In the British folk tale "The King of the Cats", a man comes home to tell his wife and cat, Old Tom, that he saw nine black cats with white spots on their chests carrying a coffin with a crown on it and one of the cats tells the man to "Tell Tom Tildrum that Tim Toldrum is dead." Old Tom then exclaims, "What?! Old Tim dead! Then I'm the King o' the Cats!" The cat then climbs up the chimney and is never seen again.
Soul-stealing
The people of the Scottish Highlands did not trust the . They believed that it could steal a person's soul, before it was claimed by the gods, by passing over a corpse before burial; therefore, watches called the ('late wake') were performed night and day to keep the away from a corpse before burial. Methods of "distraction" such as games of leaping and wrestling, catnip, riddles and music would be employed to keep the away from the room in which the corpse lay. In addition, there were no fires where the body lay, as it was said that the was attracted to the warmth.
Samhain
On Samhain, it was believed that a would bless any house that left a saucer of milk out for it to drink and those houses that did not put out a saucer of milk would be cursed into having all of their cows' udders go dry.
Summoning
The demonic called Big Ears could be summoned (Gaelic ) to appear and grant any wish to those who took part in the ceremony. The ceremony required practitioners to burn the bodies of cats over the course of four days and nights.
Transformation
Some people believed that the was a witch that could transform voluntarily into its cat form and back nine times. If one of these witches chose to go back into their cat form for the ninth time, they would remain a cat for the rest of their lives. It is believed by some that this is how the idea of a cat having nine lives originated.
See also
Beast of Bodmin
Kellas cat
List of fictional cats
Phantom cat
"The Black Cat" (short story)
References
Aos Sí
Cat folklore
Fairies
Fantasy creatures
Irish folklore
Irish legendary creatures
Mythological felines
Scottish legendary creatures
Scottish mythology
Tuatha Dé Danann
Witchcraft in folklore and mythology |
The 2022 Fort Valley State Wildcats men's volleyball team, the first ever Fort Valley State men's volleyball team, represents Fort Valley State University in the 2022 NCAA Division I & II men's volleyball season. The Wildcats, led by first year head coach Larry Wrather, play their home games at HPE Arena. The Wildcats compete as members of the Southern Intercollegiate Athletic Conference.
Season highlights
Will be filled in as the season progresses.
Roster
Schedule
TV/Internet Streaming information:
All home games will be streamed on Team 1 Sports. Most road games will also be streamed by the schools streaming service.
*-Indicates conference match.
Times listed are Eastern Time Zone.
Announcers for televised games
King: Brittany Ramsey & Julie Ward
Benedict: No commentary
Belmont Abbey: No commentary
Reinhardt: No commentary
Charleston: Jack Withrow & Mychal Schulz
Charleston: Mychal Schulz
Tusculum: Jim Miller
Maryville: No commentary
Emmanuel: Logan Reese & Taylor Roberts
Morehouse: No commentary
Edward Waters: No commentary
Central State: Doug Brown
Edward Waters: No commentary
Morehouse: No commentary
Edward Waters: No commentary
Kentucky State: No commentary
Benedict: No commentary
References
2022 in sports in Georgia (U.S. state)
2022 NCAA Division I & II men's volleyball season
2022 Southern Intercollegiate Athletic Conference men's volleyball season |
Khujli is a 2017 Indian short drama film written & directed by Sonam Nair, produced by Chintan Ruparel & Anuj Gosalia and starring Jackie Shroff and Neena Gupta. It was released on 31 March 2017 by Terribly Tiny Talkies to their official YouTube handle. The film marks debut of Jackie Shroff in short films.
Plot
In a room, a bed is shaking rhythmically and sounds of a man moaning as it is revealed that it was due to Roopmati (Neena Gupta) is scratching Girdharilal's (Jackie Shroff) back with a churning stick to ease an itch. Their [son] knocks on the door and asks them to be quit. He further informs them that he will be out late. Girdharilal replies humorously that instead of telling so [he] could have texted them. In the kitchen, Roopmati ignites the gas stove as her aged grandmother is walking towards washroom behind her. The twist in the plot comes when Jackie finds a pair of pink handcuffs in his young son's bedroom. Scandalised and angry, he shows his find to his wife. His tirade however, is interrupted when Neena smiles slyly and tells him she knows the handcuffs are used for BDSM, because she had read Fifty Shades of Grey.
Cast
Jackie Shroff as Girdharilal
Neena Gupta as Roopmati
Rani Patwar as grandma
Archak Chhabra as son of Girdharilal and Roopmati
Soundtrack
The film's background score is composed by Somesh Saha and it features vocals by singer Garima Yagnik.
Awards
Jackie Shroff won Best Actor Male Award at Filmfare Awards 2018 for his role in the film.
References
External links
2017 short films
Indian short films
Indian drama films
2010s Hindi-language films
2017 drama films
2017 films
Hindi-language drama films |
Potekhin () is a surname. It may refer to:
Aleksei Potekhin (born 1972), Russian pop musician
Alexei Potekhin (1829–1908), Russian dramatist and novelist
Bogdan Potekhin (born 1992), Russian professional ice hockey player
Vasili Potekhin (born 1974), retired Russian professional footballer
Russian-language surnames |
Rita El Khayat () also known as "Ghita". Ghita El Khayat, (altern. translit. Rita), (born 1944, Rabat, Morocco) is Moroccan psychiatrist, anthro-psychoanalyst, writer, and anthropologist.
She studied at modern schools of Rabat and completed her graduation in the field of Psychiatry, Psychoanalyst and Medical Aerospace from Paris whereas graduation in Ergonomics and Occupational Medicine were completed from Bordeaux. She did her PhD in Anthropology of Arab World from (School of High Studies in Social Sciences, EHESS in Paris).
Rita added that apart from being a medical doctor, she has served a Professor as well as conceiver of Anthropology at the University if Milano, Women Studies member at Quebec Canada a French Language University, UQUAM abbreviated as Université du Québec à Montréal, a journalist as well as an author of not only the articles but books too, who had published thirty six books till 2012.
While in Paris she studied ethnopsychiatry under George Devereux and also studied Classical Arabic at École spéciale des Langues orientales and began to write.
In 1999 she founded the Association Ainï Bennaï to broaden the culture in Morocco and Maghreb. In 2000, the Association became a publishing house.
She is known for her strong involvement in favour of women's emancipation and social rights.
She is author of more than 350 articles and 36 books.
She is professor of anthropology of the knowledge at the Faculty of Letters and Philosophy of the D'Annunzio University of Chieti–Pescara in Italy.
Career and awards
She spent almost 10 years in France, Europe after that she returned to the city where she was born.
During her studies she was also active as radio speaker, TV and cinema artist. She has also served as lecturer of Anthropology of Knowledge at the University of Chieti in Italy, as an Ambassador of Mediterranean Games of Pescara, Italy in year 2009, she received the Nobel Peace Prize and honored as Laureate in Maiori, Italy 2007, a Council of Directors member of the International Festival Film of Marrakech, African Women's Development and Communication Network (FEMNET) member since 2007 and host of Moroccan national radio daily program known as, A Book, a Friend.
Rita El Khayat is known for her participation in emancipation and social rights for women. Most of her writings including books and articles revolve around women rights and the world for them like La Femme dans le Monde Arabe (Women in the Arab World), Le Maghreb des Femmes (The Maghreb for Women),Le Somptueux Maroc des Femmes (The Sumptuous Morocco of Women), etc.
Books
Rita is an author of 36 books and more than 350 articles . Her books are written in French language. Books published by the author:
Le Monde Arabe au Féminin - (L’Harmattan, Paris, 1985).
Une Psychiatrie Moderne pour le Maghreb (A Modern Psychiatry for the Maghreb) - (L’Harmattan, Paris,1994)
Les sept jardins - Ed. L’Harmattan Parigi, 1995.
La Folie, El Hank – (Eddif, Casablanca, 2000)
Le Maghreb des Femmes - (Marsam, Rabat 2001).
La Femme dans le Monde Arabe (Women in the Arab World) published in 2001.
Le 11 septembre 2001 des Arabes (Editions Aïni Bennaï, août 2002)
Le Somptueux Maroc des Femmes - (Marsam, Rabat, 2002).
Le Livre des Prénoms du Monde Arabe (The Book of First Names of the Arab World) - (Eddif, Casablanca 2002 alla settima edizione).
La Donna nel mondo arabo, (essay published in Italian, Jaca Book WIDE, Milan, 2003)
Le Désenfantement - (Editions Ainï Bennaï, Casablanca 2003)
Le Sein (Editions Ainï Bennaï, Casablanca, 2003)
Métissages culturels (Culture Mixing) - (co-author: Alain Goussot), (Editions Ainï Bennaï, Casablanca, 2003)
La liaison (a novel, Ed. Aïni Bennaï December 2003) translated in English (The Affair, 2018 by Peter Thompson )
Les Arabes riches de Marbella, The rich Arabs of Marbella - (Editions Ainï Bennaï, Casablanca, 2004)
L’Oeil du Paon (The Eye of the Peacock) - (Editions Ainï Bennaï, Casablanca, 2004)
Psychiatrie, culture et politique (Psychiatry, Culture and Politics)(co-author: Alain Goussot), Editions Ainï Bennaï, Casablanca, 2005
La nonagénaire, ses chèvres et l’îlot de Leila – (Editions Ainï Bennaï, Casablanca, 2006)
Le Fastueux Maroc des traditions(The Sumptuous Morocco of Traditions)- (Editions Ainï Bennaï, Casablanca, 2007).
Her books are mostly written in the French language but as she is loved for her work around the world. Her works have also been translated and published in Italy, Germany, Malta, USA
« Le Livre des Prénoms du Monde Arabe»
The Book of First Names of the Arab World published in 2002.
As its title the book explains the phenomenon of First name. The first name is a name attached to the patronymic name. It is used to distinguish members of the same family. It's the usual name someone is called, referred to, and responds to.
Giving a child a "first name" is a normal universal human phenomenon.
The need and importance of naming individuals , accopagned the emergence of the language. In Morocco the surname was systematically imposed around the 20th century, when the civil status was introduced in the country.
From an anthropological point of view the first name corresponds to something very profound in the considered culture . It is related to the language of the ethnic group or group of peoples considered, to its history, references, religion, beliefs, evolution, sense of symbol and trace.
The first name marks an individual as something permanent; just like a tattoo or a skin color.
The book had also shown influence in the Moroccan law. Since it was published in 1996, reissued in 1998 and 1999, laws have been voted by the Moroccan Parliament prohibiting all non-Arabic names, all foreign names. For so a list of "controlled" first names was made and provided only to fathers, since they are the only ones who can declare the child to civil registrars.
According to the author First names can be classified into three categories:
1-those derived from Arabic
2- those from the three Moroccan Berber dialects, Tachelhit, Tamazight or Tarifi.
3-those from the Moroccan Jewish minority,
There are no specific origine to First names, but in the book the anthropologiste tried to classify them;
- Very rare, uncommon first names, without very precise meanings;
- religious first names, they are very common and known, in both male and female (Mohammed,Zineb, Myriem,)
- Names taken from Arab-Muslim history; such as Omar, Hamza, Abdallah..etc.
- First names originated in forgotten tales and legends, songs or even proverbs.
- Old names but still in force.
- Recent or "invented" first names.
- Names related to the region (Zérouala, Doukkalas region near Casablanca).
- First names of foreign origin, for example Jordan, Jessica et Naomi.
- Names referring to animals, things, stars, precious stones, plants.
The book show some conflict between parents made because of giving the first name to their child. For example women in Morocco cannot transmit or give their "Patronymic" surname to their child, for so they often demande to give the first name for the child, in order to claim that she's the one who bore him and, therefore, her motherhood begins when she gives a social and real existence to the child. In some other countries women are forced to follow the desire of their husbands, but in other cases where women really love their husband she will accept any first name given to the child by his father . This event shows 2 things: that the woman requires recognition of her maternal role, and secondly that she only gives birth to the husband.
To give a name to the child is really important as it offers him an identity, a singularity, and to make him live, sharing, the symbols of the environment that makes him what he is.
Another anthropological and social aspect of Moroccan society which is; the case of naming an abandonment child.
The abandonment of children is a tragic subject in Morocco where the child born out of marriage is a sin. He is somehow condemned to the worst of lives, because he is only the child of a woman whose surname he does not even have the right to carry. The government gives the mother the right to choose an imaginary family name from a third party patrony list, the same for all children without a father. Or give him the surname of her own father or any living male member of her paternal family with their permission.
« Diversités et métissages culturels »
The book Diversités et métissages culturels written by Rita El khayat which is an edition of Métissages culturels (Diversity and Culture Mixing) which was published back in the year 2003 talks about how the world has become fast-paced, growing continuously and constantly and the changes it leaves behind are immense.
These changes are brought up by the diversities of people present all around the globe. This book moreover talks about the relationship which exists between people and eras of different times and studies their relation of past, present and future and what the population of the world was in past and what it is today.
Lastly, it sees how the vast diversity has blended people together in good or strange ways.
« Le Désenfantement »
The book (The Defeatment) published in 2002, written by Rita El Khayat is actually about the author's true story on how she lost her child on 15 February 1997. The pain and loss the mother went through after her daughter named "Aïni" got lost. The feelings and cry of a mother is described in the book as she grieves about her lost child and visits all the places her child might have crossed. The sufferings of the poor mother, the sorrow and tears are felt who refuse to accept the reality that her child is lost and the defeat that she couldn't find her, as the chapters goes on.
« Le somptueux Maroc des femmes »
The book, (The sumptuous Morocco of women) was published in 1994. As from the name this book is dedicated to the magnificent and gorgeous women of Morocco. The book shows how the authors have gone into the depths of the traditions and customs followed by women in Morocco. Sumptuous events like birth of a child, marriage, daily traditions like clothing and living and the art the Moroccan women followed in their daily lives all are well explained in this book of "Le somptueux Maroc". So if anyone wants to know about Moroccan Women and traditions, they must read this book written by Rita El Khayat.
References
Le Maghreb littéraire, Éditions La Source, 2002, p. 172
External links
Official website [broken link] (retrieved February 1, 2009)
Interview with Rita El Khayet (Radio Canada)
1944 births
Living people
Moroccan anthropologists
Moroccan women anthropologists
Moroccan non-fiction writers
Moroccan psychiatrists
Moroccan medical writers
Writers from Rabat
Academic staff of the D'Annunzio University of Chieti–Pescara
Moroccan women psychiatrists
20th-century Moroccan physicians
21st-century Moroccan physicians
20th-century Moroccan women writers
21st-century Moroccan women writers |
Hysgjokaj is a village and a former municipality in the Fier County, western Albania. At the 2015 local government reform it became a subdivision of the municipality Lushnjë. The population at the 2011 census was 2,603.
References
Former municipalities in Fier County
Administrative units of Lushnjë
Villages in Fier County |
Sir Eric Eastwood CBE FRS, (12 March 1910 – 6 October 1981) was a British scientist and engineer who helped develop radar technology during World War II.
Early years
Eastwood was educated at Oldham High School and then attended Manchester University studying under Lawrence Bragg. Following graduation he began research in Spectroscopy at Christ's College, Cambridge, with C. P. Snow as his supervisor, gaining a PhD in 1935. He taught physics at the Liverpool Collegiate School for a while.
RAF career
Eastwood joined the Royal Air Force, and attained the rank of Squadron Leader. He worked throughout the war on the technical issues related to radar and its uses by the Fighter Defences.
Postwar career
Following the end of the war, he was recruited to English Electric Company by his former supervisor at Cambridge, C. P. Snow. Initially he worked at the Nelson Research Laboratory working on synchrotron generators high-voltage impulse X ray tubes. After the English Electric Company acquired the Marconi Company in 1946, Eastwood joined the Marconi Research Laboratory in Great Baddow. Here he concentrated on extending the Laboratory's activities in communications, radar and applied physics. In 1954 he was promoted to Director of Research of the Marconi Company, and became then in 1962 Research Director of the English Electric Group.
In 1967 he presented the Bernard Price Memorial Lecture and was elected President of the Institution of Electrical Engineers in 1972. He was elected a Fellow of the Royal Society in 1968 and delivered their first Clifford Paterson Lecture in 1976 on the subject of radar.
Eastwood was appointed a Commander of the Order of the British Empire (CBE) in 1962 and knighted in 1973.
He also received an Honorary Doctorate from Heriot-Watt University in 1977.
References
External links
1910 births
1981 deaths
Commanders of the Order of the British Empire
English scientists
English electrical engineers
Fellows of the Royal Society
Knights Bachelor
People associated with radar
Telecommunications in World War II |
Made Up Mind is the second studio album from blues-rock group Tedeschi Trucks Band. It was released August 20, 2013 by Masterworks Records.
In 2014, it won a Blues Music Award in the 'Rock Blues Album of the Year' category.
Reception
Thom Jurek of AllMusic wrote " Made Up Mind is tight; it maintains the gritty, steamy, Southern heart displayed on Revelator, but the growth in songwriting, arrangement, and production is immeasurable. Everything these players have assimilated throughout their individual careers is filtered through a group consciousness. When it expresses itself musically, historical and cultural lineages are questioned and answered incessantly in the tension of their dialogue, creating a sound that is not only instantly recognizable, but offers a nearly limitless set of sonic possibilities." Julian Ring of Rolling Stone called the album "equal parts Stax and Muscle Shoals without the dilution of either." PopMatters called the album "a brilliant throwback without ever truly sounding anachronistic."
The album debuted at No. 11 on Billboard chart in its first week, and it also debuted at No. 9 on the album sales chart, as well as No. 2 on Billboard’s Rock chart and No. 1 on the Blues chart. The album has sold 113,000 copies in the United States as of December 2015.
Track listing
Personnel
Derek Trucks – lead guitar
Susan Tedeschi – lead vocals, rhythm guitar
Bakithi Kumalo – bass guitar, conga, percussion
Dave Monsey – bass guitar
Pino Palladino – bass guitar
George Reiff – bass guitar
Kofi Burbridge – clavinet, Flute, Hammond B3, piano, Wurlitzer
Tyler Greenwell – drums, percussion
J. J. Johnson – drums, percussion
Mike Mattison – harmony vocals
Mark Rivers – harmony vocals
Kebbi Williams – saxophone
Maurice "Mobetta" Brown – trumpet
Saunders Sermons – trombone
Doyle Bramhall II – guitar, background vocals
John Leventhal – guitar
Chart positions
References
External links
Tedeschi Trucks Band albums
2013 albums
Albums produced by Jim Scott (producer) |
Peter Strauss (born 1947) is an American television and movie actor.
Peter Strauss may also refer to:
Peter L. Strauss (born 1940), Columbia Law School professor
Peter Strauss Ranch, Santa Monica mountains
See also
R. Peter Straus (1923–2012), American media proprietor |
Machu Pitumarka (hispanicized spelling Machu Pitumarca, Machupitumarca) is an archaeological site with ruins of walls in Peru. It is situated in the Cusco Region, Canchis Province, Pitumarca District. Machu Pitumarka lies on a hill northeast of Pitumarka (Pitumarca) at the southern shore of the river Ch'illkamayu.
See also
Ayamach'ay
Llamachayuq Qaqa
References
Archaeological sites in Peru
Archaeological sites in Cusco Region |
Songs of Pain is the first album by folk singer-songwriter Daniel Johnston, recorded on a simple tape recorder and released on Compact Cassette. Johnston recorded these songs in the basement of his parents' house in West Virginia. Johnston recorded the tape between 1980 and 1981, and it was later mass produced on cassette by Stress Records in 1988, and on Compact Disc in 2003 by the label Dual Tone, together with More Songs of Pain as Early Recordings Volume 1.
Background
Songs of Pain was recorded between 1980 and 1981 during Daniel Johnston's Freshman, Sophomore and Junior years studying at Kent State University in East Liverpool, Ohio. During this period, Johnston lived in his parents' basement in West Virginia, where he would make recordings to share with friends and fellow students.
In late 1979, Johnston wrote the song "Lazy" after dropping out of Abilene Christian University in West Texas; the only song he wrote during that period. In 1980, he enrolled in Kent State University in East Liverpool, Ohio, where he met Laurie Allen, who would become something of a muse for Johnston. Johnston had a crush on Allen and equated her with true love and all that was good with the world. He became romantically obsessed with her, and after being complimented on his piano playing by Allen, was inspired to take up piano playing as a daily routine record his work and compile it onto cassettes to share with his peers. The material was recorded on a $59 Sanyo cassette recorder with Radio Shack tape stock. Johnston performed most of the instrumentation and overdubbed the vocals himself.
Shortly after this, Allen relocated to Florida after her boyfriend, who was studying in Florida, graduated and became a mortician there. The departure left Johnston emotionally distraught. He saw Allen shortly afterward when he accompanied a friend to a funeral hosted at the home where she was employed. The awkward encounter which ensued inspired the song "Grievances," written in early 1980 - which in November he jokingly described as a "fluke." In the Summer of 1980, Johnston wrote "Wicked World," which he described as giving him more confidence in his songwriting. He was 'lost in limbo land,' writing music '24 hours' with lyrics devised by his friends.
By the time the album was finished in 1981, Johnston was already in his Junior year of University. As he had no way of copying tapes at the time, each version featured a recording unique to the person to whom it was gifted. The later mass-copied version was given to musician/painter Katy McCarty, who met Johnston circa 1985. This version was released in 1988 by Jeff Tartakov's Stress Records.
Sound
All songs feature Johnston on vocals and piano, except for "Premarital Sex", where he plays the organ. The opening track, "Grievances", introduces themes that reoccur throughout Johnston's career. He sings about his unrequited love for "the librarian", which refers to a girl named Laurie Allen who has functioned as a muse in many of Johnston's songs; this has been described as the quintessential Daniel Johnston song, including by Johnston himself. The lyrical and the musical themes of the song have been alluded to in later works, some examples include 'Museum of Love''' which features an identical chord progression in its verses, as well as 'Love Defined', (From both The Lost Recordings and Yip/Jump Music) which features part of the same progression during the line 'Love does not insist on its own way'. The word "grievances" has also been reused in the song title "Don't Let the Sun Go Down on Your Grievances".
Other themes on the album are premarital sex ("Joy Without Pleasure" and "Premarital Sex"), Christianity ("A Little Story") and cannabis ("Pot Head") - the latter of which was directed at a friend of Johnston's.
As a way to fuel his art, Johnston seemingly to record every conversation he had, re-using phrases from these recordings as lyrics and, most notably, sampling confrontations between himself and his mother on the tapes.
Bob Dylan was an influence on the album; Johnston described "Grievances" as his "Like a Rolling Stone," took inspiration from the 'Budokan' version of "I Want You" for the 'high-piercing sound' of "Urge," and wrote "Hate Song" after being inspired by lyrics in the song "Dirge." Another influence was Slim Whitman, who inspired "Wild West Virginia."
David Raposa for Pitchfork also noted an influence from The Kinks' "Lola" on the track "Wicked Will", and Billboard Magazine compared 'Urge' to material by Plastic Ono Band, as well as "Joy Without Pleasure" to the 'prim' song-writing of Paul McCartney.
Legacy
In a 2003 review of the 'Songs of Pain' CD compilation (Which collects both this album and its 1983 sequel 'More Songs of Pain'), David Raposa for Pitchfork discussed the album's tracks positively, describing the material as 'chilling,' 'jaunty' and 'happy-go-lucky.'
In Pitchfork's 2010 review of 'The Story of an Artist' (A 6 disc collection of Johnston's early material), Douglas Wolk described "Never Relaxed" as 'The funniest thing that Johnston ever recorded,' and 'Living Life' as 'A bloodied but unbowed power-pop tune.' Wolk also compared the album to 'More Songs of Pain,' which he called 'A more accomplished if less bracing take on a lot of the same themes.' On Billboard's '12 essential Daniel Johnston Tracks' article, both 'Urge' and 'Joy Without Pleasure' were included. Willoughby Thom, writing for The Observer's retrospective on Daniel Johnston, describes Songs of Pain favorably, calling it 'Emotional and intensely beautiful,' praising its sincerity, truth, and simplistic lyrics.In July 2021, the RO2 Gallery in Dallas, Texas, hosted an exhibition of Johnston's art named after the album, 'Story of an Artist & Songs of Pain'. In 2023, a 2xLP version of the album was released, featuring eight bonus tracks.
Influence
In Hi How Are You, a book written on Johnston's career, Songs of Pain was listed as one of Kathy McCarty's most favored albums by the artist and she included five songs from the album on her 1994 tribute to Johnston, Dead Dog's Eyeball. In 1995, her cover of "Living Life" was featured in the romantic drama Film, Before Sunrise.''
Track listing
2023 vinyl re-issue bonus tracks
Release history
References
External links
Daniel Johnston - Songs of Pain from the Daniel Johnston fansite RejectedUnknown.com
Daniel Johnston albums
1981 debut albums
Albums recorded in a home studio
Self-released albums |
Windy Hill Open Space Preserve is a regional park located in San Mateo County, California and operated by the Midpeninsula Regional Open Space District (MROSD). It is readily identifiable from the flatlands of the South Bay, as it is the only "naked" part of the peninsula range (not forested).
The Windy Hill Preserve comprises an important 1132 acre (4.6 km2) stretch of conservation land on the eastward side of the Peninsula Range (Santa Cruz Mountains), rising from the valley road near Portola Valley to the 1905 ft (581 m) summit from which it gets its name. Access to the summit is easy (0.5 mile moderate grade) from State Route 35, the ridge road along the Peninsula Range. Facilities focus on trails for hiking and mountain biking, with around 14 miles (22 km) of hiking trails. Paragliding and hang gliding are permitted with a special use permit, and are popular activities in the winter months when there are East winds. In clear weather there are magnificent views from the summit, and indeed the entire upper end of the park, across the campus of Stanford University to the San Francisco Bay and beyond to Mount Tamalpais and Mount Diablo. Downtown San Francisco is visible, as well as the Pacific Ocean.
Most of Windy Hill is sheltered from the prevailing weather, which comes in off of the Pacific Ocean. A nice day further down can be very cold, windy, foggy or rainy at the summit.
The area is rich in wildlife; among the species likely to be seen are California mule deer, coyote, California vole, white-tailed kite, American kestrel, band-tailed pigeon and California quail. There are signs warning about mountain lions, but bobcats are more common. Rattlesnakes and gopher snakes may also be found. Banana slugs and, in season, California newts are common.
Spring Ridge Trail runs from the Portola Valley trailhead to Skyline Boulevard through the open, grassy part of the preserve. It, like most of the lower trails, is a fire road, open to cyclists as well as hikers and equestrians. Two trails further to the south (Hamms Gulch and the Lost Trail-Razorback Ridge-Eagle Trail combination), are single-tracks not open to cyclists. These trails run through forested country: oak, fir, buckeye, bay laurel, madrone and one or two redwoods.
Because the far shore rises so steeply, Sausal Pond appears to be black or murky green, rather than sky-blue. This marshy pond is home to a few coots and the occasional mallard, to dragonflies and bullfrogs. Shoreline access is limited to not more than one or two hundred feet, much of that surrounded by bush and accessible only to the determined.
Picture gallery
References
External links
MROSD official website about Windy Hill
Windy Hill at Bay Area Hiker
Summitpost - Windy Hill
Protected areas of San Mateo County, California
Regional parks in California
Bay Area Ridge Trail
1979 establishments in California
Protected areas established in 1979 |
The meridian 102° west of Greenwich is a line of longitude that extends from the North Pole across the Arctic Ocean, North America, the Pacific Ocean, the Southern Ocean, and Antarctica to the South Pole.
The 102nd meridian west forms a great circle with the 78th meridian east.
In Canada, part of the border between the Northwest Territories and Nunavut is defined by the meridian, and part of the border between Saskatchewan and Manitoba runs about 400m west of the meridian. At the 60th parallel north, these borders form a (possible) quadripoint at the four corners of these provinces and territories. 102°W is the Second Meridian of Canada's Dominion Land Survey.
In the United States, the meridian formed the eastern border of the historic and extralegal Territory of Jefferson. The eastern border of Colorado with Nebraska and Kansas lies on the 25th meridian west from Washington, which lies a couple of miles west of the 102nd meridian west.
From Pole to Pole
Starting at the North Pole and heading south to the South Pole, the 102nd meridian west passes through:
{| class="wikitable plainrowheaders"
! scope="col" width="130" | Co-ordinates
! scope="col" | Country, territory or sea
! scope="col" | Notes
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Arctic Ocean
| style="background:#b0e0e6;" |
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Peary Channel
| style="background:#b0e0e6;" |
|-
|
! scope="row" |
| Nunavut — Ellef Ringnes Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Danish Strait
| style="background:#b0e0e6;" |
|-
|
! scope="row" |
| Nunavut — King Christian Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Unnamed waterbody
| style="background:#b0e0e6;" | Passing just west of Helena Island, Nunavut, (at )
|-
|
! scope="row" |
| Nunavut — Bathurst Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Erskine Inlet
| style="background:#b0e0e6;" |
|-
|
! scope="row" |
| Nunavut — Alexander Island and Bathurst Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Parry Channel
| style="background:#b0e0e6;" | Viscount Melville Sound
|-
|
! scope="row" |
| Nunavut — Prince of Wales Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | M'Clintock Channel
| style="background:#b0e0e6;" |
|-
|
! scope="row" |
| Nunavut — Victoria Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Albert Edward Bay
| style="background:#b0e0e6;" |
|-
|
! scope="row" |
| Nunavut — Victoria Island
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Queen Maud Gulf
| style="background:#b0e0e6;" |
|-
|
! scope="row" |
| Nunavut — Qikiqtaryuaq
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Queen Maud Gulf
| style="background:#b0e0e6;" |
|-valign="top"
|
! scope="row" |
| Nunavut Northwest Territories / Nunavut border — from Manitoba — from , running about 400m east of, and parallel to, the border with Saskatchewan Saskatchewan — from
|-valign="top"
|
! scope="row" |
| North Dakota South Dakota — from Nebraska — from Kansas — from Oklahoma — from Texas — from
|-valign="top"
|
! scope="row" |
| Coahuila Zacatecas — from San Luis Potosí — from Zacatecas — from Aguascalientes — from Jalisco — from Guanajuato — from Jalisco — from Guanajuato — from Michoacán — from , passing just east of Uruapan Guerrero — from
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Pacific Ocean
| style="background:#b0e0e6;" |
|-
| style="background:#b0e0e6;" |
! scope="row" style="background:#b0e0e6;" | Southern Ocean
| style="background:#b0e0e6;" |
|-
|
! scope="row" | Antarctica
| Unclaimed territory
|-
|}
See also
101st meridian west
103rd meridian west
w102 meridian west
Borders of Nunavut
Borders of the Northwest Territories
Borders of Saskatchewan
Borders of Manitoba |
National Cycle Network (NCN) Route 10 is a Sustrans National Route that runs from Cockermouth to North Shields in the United Kingdom. The route is long and is fully open and signed in both directions.
History
Route 10 forms the majority of the Reivers Cycle Route which was conceived to be a mirror image of the popular C2C cycle route. Originally Route 10 was designated as Sustrans regional route and signed with blue numbers. It has been reclassified as a national route with red numbers.
Route
Cockermouth to Carlisle
The western trailhead is at Cockermouth. It uses minor roads as far as Dalston where it joins Route 7 and follows the Caldew Cycleway riverside traffic-free path into central Carlisle.
Carlisle to Bellingham
Heading north out of Carlise the route continues to follow Route 7 on minor roads as far as Westlinton and continues as Route 10 into the Kershope Forest where it meets the Scottish border. Mainly traffic-free through the Kielder Forest to the reservoir where it continues on minor roads to Bellingham.
Bellingham to North Shields
Heading east the route follows minor roads to Ponteland. Passing to the north of Newcastle upon Tyne the route reaches its eastern trailhead at Percy Main, North Shields.
Related NCN routes
Route 10 is part of the Reivers Cycle Route along with:
Route 10 meets the following routes:
at Cockermouth
at Dalston and Westlinton
at Bellingham
at Percy Main
References
External links
Cycleways in England
National Cycle Routes |
The Lo Nuestro Award for Regional Mexican Male Artist of the Year is an award presented annually by American network Univision. The accolade was established to recognize the most talented performers of Latin music. The nominees and winners were originally selected by a voting poll conducted among program directors of Spanish-language radio stations in the United States and also based on chart performance on Billboard Latin music charts, with the results being tabulated and certified by the accounting firm Deloitte. At the present time, the winners are selected by the audience through an online survey. The trophy awarded is shaped in the form of a treble clef.
Prior to 1992, the award was known as Regional Mexican Artist of the Year, until the category was split to form this award and the Regional Mexican Female Artist of the Year award.
The award was first presented to Mexican singer Vicente Fernández in 1992. Mexican performers Marco Antonio Solis and Espinoza Paz hold the record for the most awards with 4 each. Mexican singer Julión Álvarez is the most nominated performer without a win, with five unsuccessful nominations.
Winners and nominees
Listed below are the winners of the award for each year, as well as the other nominees for the majority of the years awarded.
References
Regional Mexican Male Artist of the Year
Regional Mexican musicians
Awards established in 1992 |
```java
/*
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE 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 THE
* COPYRIGHT HOLDER 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.
*/
package com.oracle.truffle.llvm.parser.model.symbols.instructions;
import com.oracle.truffle.llvm.parser.model.SymbolImpl;
import com.oracle.truffle.llvm.parser.model.SymbolTable;
import com.oracle.truffle.llvm.parser.model.blocks.InstructionBlock;
import com.oracle.truffle.llvm.parser.model.visitors.SymbolVisitor;
import com.oracle.truffle.llvm.runtime.types.Type;
public final class PhiInstruction extends ValueInstruction {
private final SymbolImpl[] values;
private final InstructionBlock[] blocks;
private PhiInstruction(Type type, int size) {
super(type);
values = new SymbolImpl[size];
blocks = new InstructionBlock[size];
}
@Override
public void accept(SymbolVisitor visitor) {
visitor.visit(this);
}
public InstructionBlock getBlock(int index) {
return blocks[index];
}
public int getSize() {
return values.length;
}
public SymbolImpl getValue(int index) {
return values[index];
}
@Override
public void replace(SymbolImpl original, SymbolImpl replacment) {
for (int i = 0; i < values.length; i++) {
if (values[i] == original) {
values[i] = replacment;
}
}
}
public static PhiInstruction generate(SymbolTable symbols, Type type, int[] values, InstructionBlock[] blocks) {
final PhiInstruction phi = new PhiInstruction(type, values.length);
for (int i = 0; i < values.length; i++) {
phi.values[i] = symbols.getForwardReferenced(values[i], phi);
phi.blocks[i] = blocks[i];
}
return phi;
}
}
``` |
This is a list of Japanese football J1 League transfers in the winter transfer window 2018–19 by club.
J1 League
Kawasaki Frontale
In:
Out:
Sanfrecce Hiroshima
In:
Out:
Kashima Antlers
In:
Out:
Hokkaido Consadole Sapporo
In:
Out:
Urawa Red Diamonds
In:
Out:
FC Tokyo
In:
Out:
Cerezo Osaka
In:
Out:
Shimizu S-Pulse
In:
Out:
Gamba Osaka
In:
Out:
Vissel Kobe
In:
Out:
Vegalta Sendai
In:
Out:
Yokohama F. Marinos
In:
Out:
Shonan Bellmare
In:
Out:
Sagan Tosu
In:
Out:
Nagoya Grampus
In:
Out:
Jubilo Iwata
In:
Out:
Matsumoto Yamaga
In:
Out:
Oita Trinita
In:
Out:
References
2018-19
Transfers
Japan |
Sugar Blue (born James Joshua "Jimmie" Whiting, December 16, 1949, Harlem, New York City) is an American blues harmonica player. He is probably best known for playing on the Rolling Stones' single "Miss You", and in partnering Louisiana Red.
The Chicago Tribune said, "The sound of Sugar Blue's harmonica could pierce any night... it's the sound of a musician who transcends the supposed limitations of his instrument."
Biography
In the mid-1970s, Blue played as a session musician on Johnny Shines's Too Wet to Plow (1975) and with Roosevelt Sykes. While in the company of the latter, he met Louisiana Red, and the two toured and recorded in 1978.
Taking advice from Memphis Slim, in the late 1970s Blue traveled to Paris, France. According to Ronnie Wood, Blue was found by Mick Jagger busking on the city streets. This led to him playing on several of the tracks on The Rolling Stones' Some Girls and Emotional Rescue albums: "Some Girls", "Send It to Me", "Down in the Hole" and "Miss You".
Trombonist Mike Zwerin backed Blue on his solo debut album, Crossroads (1979). Following the release of his From Chicago to Paris (1982), Blue joined Willie Dixon's Chicago Blues All Stars. In 1984, Blue's track "Another Man Done Gone", appeared on the compilation album Blues Explosion. It won a Grammy in 1985 for Best Traditional Blues Album.
Blue appeared with Brownie McGhee in the film Angel Heart (1987).
Sugar Blue joined as a side musician recording with Willie Dixon on the Grammy Award winning album, Hidden Charms (1988).
His next album, Blue Blazes, was released in 1994 and it included his version of "Miss You". It was followed by In Your Eyes (1995) and Code Blue (2007).
He played on the album Down Too Long, by Southside Denny and the Skintones, in 1988. Sugar Blue's next album, Threshold, was released by Beeble Music on January 26, 2010.
Writing in the Chicago Tribune, music critic Howard Reich said, "There's no mistaking Sugar Blue incendiary virtuosity. The speed and ferocity of his playing are matched by its inventiveness, with Blue packing nearly every phrase with trills, glissandos, clusters and chords. At times, it sounds as if two harps were working at once... intense, melodically ornate, punctuated by growls and swooping pitches, it's the sound of a musician who transcends the limitations of his instrument."
Discography
Albums
|2019||Colors||Beeble||804||
Compilations and reissues
See also
List of harmonica blues musicians
List of Chicago blues musicians
List of contemporary blues musicians
List of harmonicists
References
External links
Official website
"Sugar Blue" in Gérard Herzhaft, Encyclopedia of the Blues, 2nd edition
1949 births
Living people
American blues singers
American blues harmonica players
Contemporary blues musicians
Grammy Award winners
Harmonica blues musicians
Songwriters from New York (state)
Musicians from Harlem |
```javascript
/*
*
* 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 Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE 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 THE COPYRIGHT
* OWNER 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.
*/
/**
* @constructor
* @extends {WebInspector.SDKModel}
*/
WebInspector.IndexedDBModel = function(target)
{
WebInspector.SDKModel.call(this, WebInspector.IndexedDBModel, target);
this._agent = target.indexedDBAgent();
/** @type {!Map.<!WebInspector.IndexedDBModel.DatabaseId, !WebInspector.IndexedDBModel.Database>} */
this._databases = new Map();
/** @type {!Object.<string, !Array.<string>>} */
this._databaseNamesBySecurityOrigin = {};
}
WebInspector.IndexedDBModel.KeyTypes = {
NumberType: "number",
StringType: "string",
DateType: "date",
ArrayType: "array"
};
WebInspector.IndexedDBModel.KeyPathTypes = {
NullType: "null",
StringType: "string",
ArrayType: "array"
};
/**
* @param {*} idbKey
* @return {?Object}
*/
WebInspector.IndexedDBModel.keyFromIDBKey = function(idbKey)
{
if (typeof(idbKey) === "undefined" || idbKey === null)
return null;
var key = {};
switch (typeof(idbKey)) {
case "number":
key.number = idbKey;
key.type = WebInspector.IndexedDBModel.KeyTypes.NumberType;
break;
case "string":
key.string = idbKey;
key.type = WebInspector.IndexedDBModel.KeyTypes.StringType;
break;
case "object":
if (idbKey instanceof Date) {
key.date = idbKey.getTime();
key.type = WebInspector.IndexedDBModel.KeyTypes.DateType;
} else if (Array.isArray(idbKey)) {
key.array = [];
for (var i = 0; i < idbKey.length; ++i)
key.array.push(WebInspector.IndexedDBModel.keyFromIDBKey(idbKey[i]));
key.type = WebInspector.IndexedDBModel.KeyTypes.ArrayType;
}
break;
default:
return null;
}
return key;
}
/**
* @param {?IDBKeyRange=} idbKeyRange
* @return {?{lower: ?Object, upper: ?Object, lowerOpen: *, upperOpen: *}}
*/
WebInspector.IndexedDBModel.keyRangeFromIDBKeyRange = function(idbKeyRange)
{
if (typeof idbKeyRange === "undefined" || idbKeyRange === null)
return null;
var keyRange = {};
keyRange.lower = WebInspector.IndexedDBModel.keyFromIDBKey(idbKeyRange.lower);
keyRange.upper = WebInspector.IndexedDBModel.keyFromIDBKey(idbKeyRange.upper);
keyRange.lowerOpen = idbKeyRange.lowerOpen;
keyRange.upperOpen = idbKeyRange.upperOpen;
return keyRange;
}
/**
* @param {!IndexedDBAgent.KeyPath} keyPath
* @return {?string|!Array.<string>|undefined}
*/
WebInspector.IndexedDBModel.idbKeyPathFromKeyPath = function(keyPath)
{
var idbKeyPath;
switch (keyPath.type) {
case WebInspector.IndexedDBModel.KeyPathTypes.NullType:
idbKeyPath = null;
break;
case WebInspector.IndexedDBModel.KeyPathTypes.StringType:
idbKeyPath = keyPath.string;
break;
case WebInspector.IndexedDBModel.KeyPathTypes.ArrayType:
idbKeyPath = keyPath.array;
break;
}
return idbKeyPath;
}
/**
* @param {?string|!Array.<string>|undefined} idbKeyPath
* @return {?string}
*/
WebInspector.IndexedDBModel.keyPathStringFromIDBKeyPath = function(idbKeyPath)
{
if (typeof idbKeyPath === "string")
return "\"" + idbKeyPath + "\"";
if (idbKeyPath instanceof Array)
return "[\"" + idbKeyPath.join("\", \"") + "\"]";
return null;
}
WebInspector.IndexedDBModel.EventTypes = {
DatabaseAdded: "DatabaseAdded",
DatabaseRemoved: "DatabaseRemoved",
DatabaseLoaded: "DatabaseLoaded"
}
WebInspector.IndexedDBModel.prototype = {
enable: function()
{
if (this._enabled)
return;
this._agent.enable();
this.target().resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginAdded, this._securityOriginAdded, this);
this.target().resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.SecurityOriginRemoved, this._securityOriginRemoved, this);
var securityOrigins = this.target().resourceTreeModel.securityOrigins();
for (var i = 0; i < securityOrigins.length; ++i)
this._addOrigin(securityOrigins[i]);
this._enabled = true;
},
refreshDatabaseNames: function()
{
for (var securityOrigin in this._databaseNamesBySecurityOrigin)
this._loadDatabaseNames(securityOrigin);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
*/
refreshDatabase: function(databaseId)
{
this._loadDatabase(databaseId);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} objectStoreName
* @param {function()} callback
*/
clearObjectStore: function(databaseId, objectStoreName, callback)
{
this._agent.clearObjectStore(databaseId.securityOrigin, databaseId.name, objectStoreName, callback);
},
/**
* @param {!WebInspector.Event} event
*/
_securityOriginAdded: function(event)
{
var securityOrigin = /** @type {string} */ (event.data);
this._addOrigin(securityOrigin);
},
/**
* @param {!WebInspector.Event} event
*/
_securityOriginRemoved: function(event)
{
var securityOrigin = /** @type {string} */ (event.data);
this._removeOrigin(securityOrigin);
},
/**
* @param {string} securityOrigin
*/
_addOrigin: function(securityOrigin)
{
console.assert(!this._databaseNamesBySecurityOrigin[securityOrigin]);
this._databaseNamesBySecurityOrigin[securityOrigin] = [];
this._loadDatabaseNames(securityOrigin);
},
/**
* @param {string} securityOrigin
*/
_removeOrigin: function(securityOrigin)
{
console.assert(this._databaseNamesBySecurityOrigin[securityOrigin]);
for (var i = 0; i < this._databaseNamesBySecurityOrigin[securityOrigin].length; ++i)
this._databaseRemoved(securityOrigin, this._databaseNamesBySecurityOrigin[securityOrigin][i]);
delete this._databaseNamesBySecurityOrigin[securityOrigin];
},
/**
* @param {string} securityOrigin
* @param {!Array.<string>} databaseNames
*/
_updateOriginDatabaseNames: function(securityOrigin, databaseNames)
{
var newDatabaseNames = databaseNames.keySet();
var oldDatabaseNames = this._databaseNamesBySecurityOrigin[securityOrigin].keySet();
this._databaseNamesBySecurityOrigin[securityOrigin] = databaseNames;
for (var databaseName in oldDatabaseNames) {
if (!newDatabaseNames[databaseName])
this._databaseRemoved(securityOrigin, databaseName);
}
for (var databaseName in newDatabaseNames) {
if (!oldDatabaseNames[databaseName])
this._databaseAdded(securityOrigin, databaseName);
}
},
/**
* @return {!Array.<!WebInspector.IndexedDBModel.DatabaseId>}
*/
databases: function()
{
var result = [];
for (var securityOrigin in this._databaseNamesBySecurityOrigin) {
var databaseNames = this._databaseNamesBySecurityOrigin[securityOrigin];
for (var i = 0; i < databaseNames.length; ++i) {
result.push(new WebInspector.IndexedDBModel.DatabaseId(securityOrigin, databaseNames[i]));
}
}
return result;
},
/**
* @param {string} securityOrigin
* @param {string} databaseName
*/
_databaseAdded: function(securityOrigin, databaseName)
{
var databaseId = new WebInspector.IndexedDBModel.DatabaseId(securityOrigin, databaseName);
this.dispatchEventToListeners(WebInspector.IndexedDBModel.EventTypes.DatabaseAdded, databaseId);
},
/**
* @param {string} securityOrigin
* @param {string} databaseName
*/
_databaseRemoved: function(securityOrigin, databaseName)
{
var databaseId = new WebInspector.IndexedDBModel.DatabaseId(securityOrigin, databaseName);
this.dispatchEventToListeners(WebInspector.IndexedDBModel.EventTypes.DatabaseRemoved, databaseId);
},
/**
* @param {string} securityOrigin
*/
_loadDatabaseNames: function(securityOrigin)
{
/**
* @param {?Protocol.Error} error
* @param {!Array.<string>} databaseNames
* @this {WebInspector.IndexedDBModel}
*/
function callback(error, databaseNames)
{
if (error) {
console.error("IndexedDBAgent error: " + error);
return;
}
if (!this._databaseNamesBySecurityOrigin[securityOrigin])
return;
this._updateOriginDatabaseNames(securityOrigin, databaseNames);
}
this._agent.requestDatabaseNames(securityOrigin, callback.bind(this));
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
*/
_loadDatabase: function(databaseId)
{
/**
* @param {?Protocol.Error} error
* @param {!IndexedDBAgent.DatabaseWithObjectStores} databaseWithObjectStores
* @this {WebInspector.IndexedDBModel}
*/
function callback(error, databaseWithObjectStores)
{
if (error) {
console.error("IndexedDBAgent error: " + error);
return;
}
if (!this._databaseNamesBySecurityOrigin[databaseId.securityOrigin])
return;
var databaseModel = new WebInspector.IndexedDBModel.Database(databaseId, databaseWithObjectStores.version, databaseWithObjectStores.intVersion);
this._databases.set(databaseId, databaseModel);
for (var i = 0; i < databaseWithObjectStores.objectStores.length; ++i) {
var objectStore = databaseWithObjectStores.objectStores[i];
var objectStoreIDBKeyPath = WebInspector.IndexedDBModel.idbKeyPathFromKeyPath(objectStore.keyPath);
var objectStoreModel = new WebInspector.IndexedDBModel.ObjectStore(objectStore.name, objectStoreIDBKeyPath, objectStore.autoIncrement);
for (var j = 0; j < objectStore.indexes.length; ++j) {
var index = objectStore.indexes[j];
var indexIDBKeyPath = WebInspector.IndexedDBModel.idbKeyPathFromKeyPath(index.keyPath);
var indexModel = new WebInspector.IndexedDBModel.Index(index.name, indexIDBKeyPath, index.unique, index.multiEntry);
objectStoreModel.indexes[indexModel.name] = indexModel;
}
databaseModel.objectStores[objectStoreModel.name] = objectStoreModel;
}
this.dispatchEventToListeners(WebInspector.IndexedDBModel.EventTypes.DatabaseLoaded, databaseModel);
}
this._agent.requestDatabase(databaseId.securityOrigin, databaseId.name, callback.bind(this));
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} objectStoreName
* @param {?IDBKeyRange} idbKeyRange
* @param {number} skipCount
* @param {number} pageSize
* @param {function(!Array.<!WebInspector.IndexedDBModel.Entry>, boolean)} callback
*/
loadObjectStoreData: function(databaseId, objectStoreName, idbKeyRange, skipCount, pageSize, callback)
{
this._requestData(databaseId, databaseId.name, objectStoreName, "", idbKeyRange, skipCount, pageSize, callback);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} objectStoreName
* @param {string} indexName
* @param {?IDBKeyRange} idbKeyRange
* @param {number} skipCount
* @param {number} pageSize
* @param {function(!Array.<!WebInspector.IndexedDBModel.Entry>, boolean)} callback
*/
loadIndexData: function(databaseId, objectStoreName, indexName, idbKeyRange, skipCount, pageSize, callback)
{
this._requestData(databaseId, databaseId.name, objectStoreName, indexName, idbKeyRange, skipCount, pageSize, callback);
},
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} databaseName
* @param {string} objectStoreName
* @param {string} indexName
* @param {?IDBKeyRange} idbKeyRange
* @param {number} skipCount
* @param {number} pageSize
* @param {function(!Array.<!WebInspector.IndexedDBModel.Entry>, boolean)} callback
*/
_requestData: function(databaseId, databaseName, objectStoreName, indexName, idbKeyRange, skipCount, pageSize, callback)
{
/**
* @param {?Protocol.Error} error
* @param {!Array.<!IndexedDBAgent.DataEntry>} dataEntries
* @param {boolean} hasMore
* @this {WebInspector.IndexedDBModel}
*/
function innerCallback(error, dataEntries, hasMore)
{
if (error) {
console.error("IndexedDBAgent error: " + error);
return;
}
if (!this._databaseNamesBySecurityOrigin[databaseId.securityOrigin])
return;
var entries = [];
for (var i = 0; i < dataEntries.length; ++i) {
var key = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].key));
var primaryKey = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].primaryKey));
var value = WebInspector.RemoteObject.fromLocalObject(JSON.parse(dataEntries[i].value));
entries.push(new WebInspector.IndexedDBModel.Entry(key, primaryKey, value));
}
callback(entries, hasMore);
}
var keyRange = WebInspector.IndexedDBModel.keyRangeFromIDBKeyRange(idbKeyRange);
this._agent.requestData(databaseId.securityOrigin, databaseName, objectStoreName, indexName, skipCount, pageSize, keyRange ? keyRange : undefined, innerCallback.bind(this));
},
__proto__: WebInspector.SDKModel.prototype
}
/**
* @constructor
* @param {!WebInspector.RemoteObject} key
* @param {!WebInspector.RemoteObject} primaryKey
* @param {!WebInspector.RemoteObject} value
*/
WebInspector.IndexedDBModel.Entry = function(key, primaryKey, value)
{
this.key = key;
this.primaryKey = primaryKey;
this.value = value;
}
/**
* @constructor
* @param {string} securityOrigin
* @param {string} name
*/
WebInspector.IndexedDBModel.DatabaseId = function(securityOrigin, name)
{
this.securityOrigin = securityOrigin;
this.name = name;
}
WebInspector.IndexedDBModel.DatabaseId.prototype = {
/**
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @return {boolean}
*/
equals: function(databaseId)
{
return this.name === databaseId.name && this.securityOrigin === databaseId.securityOrigin;
},
}
/**
* @constructor
* @param {!WebInspector.IndexedDBModel.DatabaseId} databaseId
* @param {string} version
* @param {number} intVersion
*/
WebInspector.IndexedDBModel.Database = function(databaseId, version, intVersion)
{
this.databaseId = databaseId;
this.version = version;
this.intVersion = intVersion;
this.objectStores = {};
}
/**
* @constructor
* @param {string} name
* @param {*} keyPath
* @param {boolean} autoIncrement
*/
WebInspector.IndexedDBModel.ObjectStore = function(name, keyPath, autoIncrement)
{
this.name = name;
this.keyPath = keyPath;
this.autoIncrement = autoIncrement;
this.indexes = {};
}
WebInspector.IndexedDBModel.ObjectStore.prototype = {
/**
* @type {string}
*/
get keyPathString()
{
return WebInspector.IndexedDBModel.keyPathStringFromIDBKeyPath(this.keyPath);
}
}
/**
* @constructor
* @param {string} name
* @param {*} keyPath
* @param {boolean} unique
* @param {boolean} multiEntry
*/
WebInspector.IndexedDBModel.Index = function(name, keyPath, unique, multiEntry)
{
this.name = name;
this.keyPath = keyPath;
this.unique = unique;
this.multiEntry = multiEntry;
}
WebInspector.IndexedDBModel.Index.prototype = {
/**
* @type {string}
*/
get keyPathString()
{
return WebInspector.IndexedDBModel.keyPathStringFromIDBKeyPath(this.keyPath);
}
}
/**
* @param {!WebInspector.Target} target
* @return {?WebInspector.IndexedDBModel}
*/
WebInspector.IndexedDBModel.fromTarget = function(target)
{
var model = /** @type {?WebInspector.IndexedDBModel} */ (target.model(WebInspector.IndexedDBModel));
if (!model)
model = new WebInspector.IndexedDBModel(target);
return model;
}
``` |
```makefile
libavfilter/vf_lut.o: libavfilter/vf_lut.c libavutil/attributes.h \
libavutil/bswap.h libavutil/avconfig.h libavutil/attributes.h config.h \
libavutil/common.h libavutil/macros.h libavutil/version.h \
libavutil/intmath.h libavutil/common.h libavutil/mem.h libavutil/error.h \
libavutil/avutil.h libavutil/rational.h libavutil/mathematics.h \
libavutil/intfloat.h libavutil/log.h libavutil/pixfmt.h \
libavutil/internal.h libavutil/timer.h libavutil/cpu.h libavutil/dict.h \
libavutil/libm.h libavutil/eval.h libavutil/opt.h libavutil/samplefmt.h \
libavutil/pixdesc.h libavfilter/avfilter.h libavutil/avutil.h \
libavutil/buffer.h libavutil/dict.h libavutil/frame.h libavutil/buffer.h \
libavutil/log.h libavutil/samplefmt.h libavutil/pixfmt.h \
libavutil/rational.h libavfilter/version.h libavutil/version.h \
libavfilter/drawutils.h libavfilter/formats.h libavfilter/internal.h \
libavutil/internal.h libavfilter/avfiltergraph.h libavfilter/framepool.h \
libavfilter/thread.h libavfilter/version.h libavfilter/video.h \
libavcodec/avcodec.h libavutil/cpu.h libavutil/channel_layout.h \
libavcodec/version.h
``` |
The Bishop of Ebbsfleet is a suffragan bishop who fulfils the role of a provincial episcopal visitor in the Church of England. From its creation in 1994 to 2022, the Bishop of Ebbsfleet served conservative Anglo-Catholic parishes that reject the ordination of women as priests and bishops. Since 2023, the bishop has served conservative evangelical parishes that reject the ordination and/or leadership of women due to complementarian beliefs.
Conservative catholic bishop
The see was erected under the Suffragans Nomination Act 1888 by Order in Council dated 8 February 1994 and licensed by the Archbishop of Canterbury as a "flying bishop" to provide episcopal oversight for parishes throughout the province which do not accept the sacramental ministry of bishops who have participated in the ordination of women. The position is named after Ebbsfleet in Thanet, Kent. In the southern province, the bishops of Ebbsfleet and of Richborough each ministered in 13 of the 40 dioceses; the Bishop of Ebbsfleet served the western 13 dioceses: Bath and Wells, Birmingham, Bristol, Coventry, Derby, Exeter, Gloucester, Hereford, Lichfield, Oxford, Salisbury, Truro and Worcester. Until the creation of the suffragan See of Richborough in 1995, the Bishop of Ebbsfleet served the entire area of the Province of Canterbury with the exceptions of the dioceses of London, Rochester and Southwark which came under the oversight of the Bishop of Fulham.
Jonathan Goodall was announced as the fifth Bishop of Ebbsfleet on 2 August 2013. His episcopal consecration took place on 25 September 2013 at Westminster Abbey. He had been the chaplain and ecumenical secretary to the Archbishop of Canterbury. He was the fourth of the five bishops to be affiliated with the Society of the Holy Cross. On 3 September 2021 he resigned his episcopacy in order to be received into the Roman Catholic Church.
Conservative evangelical bishop
In June 2022, it was announced that, from January 2023, oversight of traditionalist Anglo-Catholics in the west of Canterbury province (formerly the Bishop of Ebbsfleet's area) would be taken by a new Bishop of Oswestry, suffragan to the Bishop of Lichfield. Oversight of conservative evangelicals would be taken by the next Bishop of Ebbsfleet; the See of Maidstone (the original conservative evangelical flying bishop) would be left vacant, available for other uses. As such, from 2023, the Bishop of Ebbsfleet will provide alternative episcopal oversight to parishes who have passed resolutions that reject the ordination and/or leadership of women due to complementarian beliefs. On 9 December 2022 the appointment was announced of Rob Munro as the next Bishop of Ebbsfleet and he was consecrated bishop on 2 February 2023.
List of bishops
See also
Bishop of Beverley
Bishop of Richborough
List of Anglo-Catholic churches in England
References
External links
Bishop of Ebbsfleet website
Crockford's Clerical Directory – listings
Ebbsfleet
Christian organizations established in 1994 |
Louis-Nathaniel Rossel (9 September 1844 28 November 1871) was a French army officer and a politician. On 19 March 1871, he became the only senior French officer to join up with the Paris Commune, playing an important role as Minister of War.
Biography
He was born on 9 September 1844 in Saint-Brieuc, Côtes-d'Armor, but his father was a scion of a strongly republican Huguenot (Protestant) Nîmes family, and descended from Saint-Jean-du-Gard Camisards. His mother, born Sarah Campbell, was from Scotland. Rossel was educated at the Prytanée Militaire, and was executed on 28 November 1871 at the Satory military centre at Versailles.
When Rossel became Minister of War, replacing Gustave Paul Cluseret after the abandonment of Fort Issy, he immediately ordered the construction of a new ring of barricades within the existing ramparts in case the Government forces penetrated the first line of defense. Rossel also tried to concentrate and centralize the 1,100 artillery pieces scattered throughout the city. Many were out of commission with their breechblocks stored in arsenals elsewhere in Paris, so that the only readily available guns were light pieces that fared poorly against the Government's heavy artillery. Furthermore, Rossel began work within the city on three citadels: at the Trocadero, on Montmartre, and at the Pantheon on the Left Bank. Here, the Communards would be able to make a final stand if necessary. He put the defense of the city ramparts under the direct tactical command of a pair of his most talented Polish emigres, youthful veterans of the 1863 Polish rebellion. These were men accustomed to desperate fighting against hopeless odds. Recognizing that a purely passive defense would enable the Government forces to mass at any given point, Rossel developed a plan to organize National Guard battalions into "combat groups," each of five battalions, commanded by a colonel, and supported by some 40 guns. Unfortunately, the National Guard units remained suspicious of central direction and for the most part refused to serve in parts of Paris other than those in which they lived.
On 9 May 1871 Rossel resigned from his position after a tenure of nine days, despairing of the barren prolonged deliberations of the Commune, which precluded any serious action. He was replaced by Charles Delescluze.
After the fall of the Commune, Rossel fled and lived for a short while under an assumed identity. He was later apprehended and executed by a firing squad on 28 November 1871.
References
1844 births
1871 deaths
Politicians from Saint-Brieuc
French people of Scottish descent
People from Nîmes
French Protestants
People executed by the French Third Republic
Communards |
Othenin (died 1338), called the Mad, was a Count of Montbéliard. He was the only son of Reginald of Burgundy and his wife, Guillemette of Neufchâtel. Othenin could not intervene in the affairs of the county because of his mental problems. He was placed under the tutelage of his uncle, Hugh of Chalon. He lived in the reclusive Château de Montfaucon (Castle of Montfaucon), near Besançon, until his death.
Othenin died in 1338. He was buried in the church of Saint-Maimbœuf Montbéliard. Henry I of Mountfacon was named his successor by the Holy Roman Emperor Louis IV.
House of Montfaucon
Counts of Montbéliard
1338 deaths
Year of birth missing
Chalon-Arlay
French royalty and nobility with disabilities |
Acraea vuilloti is a butterfly in the family Nymphalidae. It is found in Tanzania, from the eastern part of the country to Usambara, Uluguru, Usagara and Bagamayo.
Description
A. vuilloti Mab. (56 d). Very close to Acraea pharsalus. The ground-colour of the forewing is often completely broken up into spots and the hindwing has a large white spot at the inner margin in cellules 1 b to 2 (to 3). Hindwing also beneath with dark marginal band. Marginal streaks thick, but not triangular. German East Africa.
Taxonomy
It is a member of the Acraea pharsalus species group.
References
External links
Die Gross-Schmetterlinge der Erde 13: Die Afrikanischen Tagfalter. Plate XIII 56 d
Images representing Acraea vuilloti at Bold
Butterflies described in 1889
vuilloti
Endemic fauna of Tanzania
Butterflies of Africa
Taxa named by Paul Mabille |
```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';
/**
* Create `test.validate.js` contents.
*
* @module @stdlib/_tools/scaffold/test-validate-js
*
* @example
* var create = require( '@stdlib/_tools/scaffold/test-validate-js' );
*
* var code = [
* '/**',
* '* Validates function options.',
* '*',
* '* @private',
* '* @param {Object} opts - destination object',
* '* @param {Options} options - function options',
* '* @param {string} [options.sep] - separator',
* '* @returns {(Error|null)} null or an error object',
* '*\/'
* ];
* code = code.join( '\n' );
*
* var tests = create( code );
*/
// MODULES //
var main = require( './main.js' );
// EXPORTS //
module.exports = main;
``` |
Pakistan competed at the 2014 Asian Games held in Incheon, South Korea between 19 September and 5 October 2014. It sent 182 athletes to compete in 23 sports. It was defending its title in hockey (men's), squash (men's team) and cricket (women's) but successfully managed to defend the women's cricket title only.
Medalists
Badminton
Men's Squad
Muhammad Irfan Saeed Bhatti
Umer Zeeshan
Men's singles
Men's doubles
Women's Squad
Palwasha Bashir
Mahoor Shahzad
Women's singles
Women's doubles
Mixed
Mixed doubles
Baseball
Men's Squad
Muhammad Ahsan Baig
Umair Imdad Bhatti
Adnan Butt
Nasir Nadeem Butt
Atif Dar
Muhammad Waqas Ismail
Burhan Johar
Khurram Raza Khan
Tariq Nadeem
Zubair Nawaz
Adil Sardar
Muhammad Abu Bakar Siddiqui
Dur I Hussain Syed
Fazal ur Rehman
Muhammad Usman
Muhammad Sumair Zawar
Preliminary
Pool A
Boxing
Pakistan Boxing Federation announced only one change to the 6 member squad which competed at the 2014 Commonwealth Games at Glasgow, UK, with Sanaullah (91 kg) added in place of Muhammad Asif (69 kg).
Men's Squad
Cricket
The PCB has decided to send the women's team only to these Games so as to give them exposure as well as defend their title. On July 16, 2014, PCB announced the following squad for the Games. Pakistan got direct entry to the knockout stage.
Women's Squad
Sana Mir (Captain)
Bismah Maroof (Vice Captain)
Nain Abidi
Sidra Nawaz (Wicket-Keeper)
Nida Dar
Javeria Khan
Asmavia Iqbal
Marina Iqbal
Aliya Riaz
Kainat Imtiaz
Sumaiya Siddiqi
Qanita Jalil
Sania Khan
Anam Amin
Sadia Yousuf
Quarterfinals
Semifinals
Final
Cycling
Pakistan sent only one athlete, who will be competing in both road and track events.
Men's Squad
ammar imtiaz
Muhammad Shakeel
Track
Road
Track
Road
Field hockey
Men's Squad
Muhammad Imran (captain) (full back)
Shafqat Rasool (vice captain) (forward)
Imran Butt (goalkeeper)
Muhammad Irfan (full back)
Ammad Shakeel Butt (half back)
Muhammad Tousiq (half back)
Fareed Ahmed (half back)
Rashid Mehmood (half back)
Muhammad Rizwan Jr. (half back)
Kashif Shah (half back)
Muhammad Waqas (forward)
Muhammad Umar Bhutta (forward)
Abdul Haseem Khan (forward)
Muhammad Dilber (forward)
Shakeel Abbasi (forward)
Muhammad Rizwan Sr. (forward)
Preliminary
Group B
Semifinal
Final
Football
Men's tournament
Squad
Kaleemullah (FW) (Captain)
Saqib Hanif (GK)
Ahsanullah (GK)
Muzammil Hussain (GK)
Mohammad Ahmed (DF)
Mohammad Sohail (DF)
Mohammad Bilal (DF)
Naveed Ahmed (MF)
Mohsin Ali (DF)
Saddam Hussain (FW)
Ahsan Ullah (DF)
Mehmood Khan (MF)
Mohammad Riaz (MF)
Sher Ali (MF)
Mansoor Khan (FW)
Ashfaq Uddin (MF)
Mohammad Zeeshan (MF)
First round
Gymnastics
Men's Artistic Squad
Muhammad Afzal
Muhammad Yasir
Qualifying
Judo
Men's Squad
Shah Hussain Shah
Kabaddi
Men's Squad
Shabbir Ahmed
Hassan Ali
Nasir Ali
Wajid Ali
Muhammad Shahbaz Anwar
Syed Aqeel Hassan
Ibrar Hussain
Muhammad Kashif
Muhammad Nisar
Muhammad Rizwan
Wasim Sajjad
Atif Waheed
Preliminary
Group A
Semifinals
Karate
Men's Squad
Women's Squad
Rowing
Men's Squad
Tanveer Arif
Muhammad Masood
Abdul Rehman
Qualification Legend: F=Final; FA=Final A (medal); FB=Final B (non-medal); R=Repechage
Rugby
Men's Squad
Ahmed Wasim Akram
Muhammad Basit
Daud Gill
Mian Hamza Hayaud Din
Muhammad Ghalib Javed
Muhammad Ali Khan
Muhammad Tahir Rafi
Sair Riaz
Syed Xeeshan Rizvi
Umer Usman
Ahmed Khalid Waqas
Ayub Zafar
Preliminary
Group B
9th-12th Place Semifinal
11th place match
Shooting
Men's Squad
Pistol
Kalim Khan
Ghulam Mustafa Bashir
Uzair Ahmed
Shotgun
Khurram Inam
Usman Chand
Fakhar-ul-Islam Qureshi
Aamer Iqbal
Rifle
Siddique Umar
Muhammad Ayaz Tahir
Zeeshan Ul Shakir Farid
Women's Squad
Pistol
Mahwish Farhan
Rifle
Nadira Raees
Minhal Sohail
Squash
Men's Squad
Nasir Iqbal
Farhan Zaman
Danish Atlas Khan
Farhan Mehboob
Men's singles
Men's team
Preliminary
Pool A
Women's Squad
Maria Toorpakay Wazir
Sammer Anjum
Moqaddas Ashraf
Riffat Khan
Women's singles
Women's team
Pool B
Swimming
Men's Squad
Nisar Ahmed
Nasir Ali
Muhammad Asif
Muhammad Saad
Women's Squad
Anushe Dinyar Engineer
Simrah Nasir
Soha Sanjrani
Areeba Shaikh
Table tennis
Men's Squad
Muhammad Asim Qureshi
Syed Saleem Abbas Kazmi
Mohammad Rameez Khan
Men's singles
Men's doubles
Men's team
Group C
Women's Squad
Shabnam Bilal
Ayesha Iqbal Ansari
Rahila Kashif
Women's singles
Women's doubles
Women's team
Group C
Mixed
Mixed doubles
Taekwondo
Men's Squad
Women's Squad
Tennis
Men's Squad
Aqeel Khan
Muhammad Abid
Men's singles
Men's doubles
Men's team
Women's Squad
Ushna Suhail
Sara Mansoor
Women's singles
Women's doubles
Women's team
Volleyball
Men
Muhammad Ismail Khan
Naseer Ahmed
Nasir Khan
Asif Nadeem
Aimal Khan
Syed Shujah Abbas Naqvi
Mohib Rasool
Imran Sultan
Mubashir Raza
Akhtar Ali
Muhammad Idrees
Murad Jehan
Preliminary
Pool B
Playoff
Pool H
9th–12th semifinals
11th place match
Weightlifting
Men's Squad
Wrestling
Men's Squad
Muhammad Inam
Bilal Hussain Awan
Muhammad Bilal
Muhammad Asad Butt
Sheraz Mohammed Ahmed Khan Qasuri
Freestyle
Wushu
Men's Sanda
Women's Sanda
See also
2014 Asian Games
References
Nations at the 2014 Asian Games
2014
Asian Games |
```python
#############################################################################################
# File: rust_version_database.py
# Origin: Rust Repository path_to_url
#
# Description:
# This file serves as a comprehensive reference, capturing the commit hashes associated with Rust versions over time.
# It facilitates tracking the commit history and enables the precise association of specific versions with their respective commits.
#
# Regeneration Instructions:
#
# To regenerate or update this file, you can follow these steps:
# 1. Navigate to the script directory.
# 2. Execute the script 'extract_rust_hashes.py'.
# Example command: python extract_rust_hashes.py
#############################################################################################
rust_commit_hash = {
"a28077b28a02b92985b3a3faecf92813155f1ea1": "1.74.1",
"79e9716c980570bfd1f666e3b16ac583f0168962": "1.74.0",
"cc66ad468955717ab92600c770da8c1601a4ff33": "1.73.0",
"d5c2e9c342b358556da91d61ed4133f6f50fc0c3": "1.72.1",
"5680fa18feaa87f3ff04063800aec256c3d4b4be": "1.72.0",
"eb26296b556cef10fb713a38f3d16b9886080f26": "1.71.1",
"8ede3aae28fe6e4d52b38157d7bfe0d3bceef225": "1.71.0",
"90c541806f23a127002de5b4038be731ba1458ca": "1.70.0",
"84c898d65adf2f39a5a98507f1fe0ce10a2b8dbc": "1.69.0",
"9eb3afe9ebe9c7d2b84b71002d44f4a0edac95e0": "1.68.2",
"8460ca823e8367a30dda430efda790588b8c84d3": "1.68.1",
"2c8cc343237b8f7d5a3c3703e3a87f2eb2c54a74": "1.68.0",
"d5a82bbd26e1ad8b7401f6a718a9c57c96905483": "1.67.1",
"fc594f15669680fa70d255faec3ca3fb507c3405": "1.67.0",
"90743e7298aca107ddaa0c202a4d3604e29bfeb6": "1.66.1",
"69f9c33d71c871fc16ac445211281c6e7a340943": "1.66.0",
"897e37553bba8b42751c67658967889d11ecd120": "1.65.0",
"a55dd71d5fb0ec5a6a3a9e8c27b2127ba491ce52": "1.64.0",
"4b91a6ea7258a947e59c6522cd5898e7c0a6a88f": "1.63.0",
"e092d0b6b43f2de967af0887873151bb1c0b18d3": "1.62.1",
"a8314ef7d0ec7b75c336af2c9857bfaf43002bfc": "1.62.0",
"fe5b13d681f25ee6474be29d748c65adcd91f69e": "1.61.0",
"7737e0b5c4103216d6fd8cf941b7ab9bdbaace7c": "1.60.0",
"9d1b2106e23b1abd32fce1f17267604a5102f57a": "1.59.0",
"db9d1b20bba1968c1ec1fc49616d4742c1725b4b": "1.58.1",
"02072b482a8b5357f7fb5e5637444ae30e423c40": "1.58.0",
"f1edd0429582dd29cccacaf50fd134b05593bd9c": "1.57.0",
"59eed8a2aac0230a8b53e89d4e99d55912ba6b35": "1.56.1",
"09c42c45858d5f3aedfa670698275303a3d19afa": "1.56.0",
"c8dfcfe046a7680554bf4eb612bad840e7631c4b": "1.55.0",
"a178d0322ce20e33eac124758e837cbd80a6f633": "1.54.0",
"53cb7b09b00cbea8754ffb78e7e3cb521cb8af4b": "1.53.0",
"9bc8c42bb2f19e745a63f3445f1ac248fb015e53": "1.52.1",
"88f19c6dab716c6281af7602e30f413e809c5974": "1.52.0",
"2fd73fabe469357a12c2c974c140f67e7cdd76d0": "1.51.0",
"cb75ad5db02783e8b0222fee363c5f63f7e2cf5b": "1.50.0",
"e1884a8e3c3e813aada8254edfa120e85bf5ffca": "1.49.0",
"7eac88abb2e57e752f3302f02be5f3ce3d7adfb4": "1.48.0",
"18bf6b4f01a6feaf7259ba7cdae58031af1b7b39": "1.47.0",
"04488afe34512aa4c33566eb16d8c912a3ae04f9": "1.46.0",
"d3fb005a39e62501b8b0b356166e515ae24e2e54": "1.45.2",
"c367798cfd3817ca6ae908ce675d1d99242af148": "1.45.1",
"5c1f21c3b82297671ad3ae1e8c942d2ca92e84f2": "1.45.0",
"c7087fe00d2ba919df1d813c040a5d47e43b0fe7": "1.44.1",
"49cae55760da0a43428eba73abcb659bb70cf2e4": "1.44.0",
"8d69840ab92ea7f4d323420088dd8c9775f180cd": "1.43.1",
"4fb7144ed159f94491249e86d5bbd033b5d60550": "1.43.0",
"b8cedc00407a4c56a3bda1ed605c6fc166655447": "1.42.0",
"f3e1a954d2ead4e2fc197c7da7d71e6c61bad196": "1.41.1",
"5e1a799842ba6ed4a57e91f7ab9435947482f7d8": "1.41.0",
"73528e339aae0f17a15ffa49a8ac608f50c6cf14": "1.40.0",
"4560ea788cb760f0a34127156c78e2552949f734": "1.39.0",
"625451e376bb2e5283fc4741caa0a3e8a2ca4d54": "1.38.0",
"eae3437dfe991621e8afdc82734f4a172d7ddf9b": "1.37.0",
"a53f9df32fbb0b5f4382caaad8f1a46f36ea887c": "1.36.0",
"3c235d5600393dfe6c36eeed34042efad8d4f26e": "1.35.0",
"6c2484dc3c532c052f159264e970278d8b77cdc9": "1.34.2",
"fc50f328b0353b285421b8ff5d4100966387a997": "1.34.1",
"91856ed52c58aa5ba66a015354d1cc69e9779bdf": "1.34.0",
"2aa4c46cfdd726e97360c2734835aa3515e8c858": "1.33.0",
"9fda7c2237db910e41d6a712e9a2139b352e558b": "1.32.0",
"b6c32da9b0481e3e9d737153286b3ff8aa39a22c": "1.31.1",
"abe02cefd6cd1916df62ad7dc80161bea50b72e8": "1.31.0",
"1433507eba7d1a114e4c6f27ae0e1a74f60f20de": "1.30.1",
"da5f414c2c0bfe5198934493f04c676e2b23ff2e": "1.30.0",
"17a9dc7513b9fea883dc9505f09f97c63d1d601b": "1.29.2",
"b801ae66425cf7c3c71052b19ef8f145b0d0513d": "1.29.1",
"aa3ca1994904f2e056679fce1f185db8c7ed2703": "1.29.0",
"9634041f0e8c0f3191d2867311276f19d0a42564": "1.28.0",
"58cc626de3301192d5d8c6dcbde43b5b44211ae2": "1.27.2",
"5f2b325f64ed6caa7179f3e04913db437656ec7e": "1.27.1",
"3eda71b00ad48d7bf4eef4c443e7f611fd061418": "1.27.0",
"594fb253c2b02b320c728391a425d028e6dc7a09": "1.26.2",
"827013a31b88e536e85b8e6ceb5b9988042ec335": "1.26.1",
"a7756804103447ea4e68a71ccf071e7ad8f7a03e": "1.26.0",
"84203cac67e65ca8640b8392348411098c856985": "1.25.0",
"d3ae9a9e08edf12de0ed82af57ba2a56c26496ea": "1.24.1",
"4d90ac38c0b61bb69470b61ea2cccea0df48d9e5": "1.24.0",
"766bd11c8a3c019ca53febdcd77b2215379dd67d": "1.23.0",
"05e2e1c41414e8fc73d0f267ea8dab1a3eeeaa99": "1.22.1",
"328886ba2eaf0d3ac7e78ef3ba27eb296d0af3c0": "1.22.0",
"3b72af97e42989b2fe104d8edbaee123cdf7c58f": "1.21.0",
"f3d6973f41a7d1fb83029c9c0ceaf0f5d4fd7208": "1.20.0",
"0ade339411587887bf01bcfa2e9ae4414c8900d4": "1.19.0",
"03fc9d622e0ea26a3d37f5ab030737fcca6928b9": "1.18.0",
"56124baa9e73f28c0709e59e74783cf234a978cf": "1.17.0",
"30cf806ef8881c41821fbd43e5cf3699c5290c16": "1.16.0",
"021bd294c039bd54aa5c4aa85bcdffb0d24bc892": "1.15.1",
"10893a9a349cdd423f2490a6984acb5b3b7c8046": "1.15.0",
"e8a0123241f0d397d39cd18fcc4e5e7edde22730": "1.14.0",
"2c6933acc05c61e041be764cb1331f6281993f3f": "1.13.0",
"d4f39402a0c2c2b94ec0375cd7f7f6d7918113cd": "1.12.1",
"3191fbae9da539442351f883bdabcad0d72efcb6": "1.12.0",
"9b21dcd6a89f38e8ceccb2ede8c9027cb409f6e3": "1.11.0",
"cfcb716cf0961a7e3a4eceac828d94805cf8140b": "1.10.0",
"e4e8b666850a763fdf1c3c2c142856ab51e32779": "1.9.0",
"db2939409db26ab4904372c82492cd3488e4c44e": "1.8.0",
"a5d1e7a59a2a3413c377b003075349f854304b5e": "1.7.0",
"c30b771ad9d44ab84f8c88b80c25fcfde2433126": "1.6.0",
"3d7cd77e442ce34eaac8a176ae8be17669498ebc": "1.5.0",
"8ab8581f6921bc7a8e3fa4defffd2814372dcb15": "1.4.0",
"9a92aaf19a64603b02b4130fe52958cc12488900": "1.3.0",
"082e4763615bdbe7b4dd3dfd6fc2210b7773edf5": "1.2.0",
"35ceea3997c79a3b7562e89b462ab76af5b86b22": "1.1.0",
"a59de37e99060162a2674e3ff45409ac73595c0e": "1.0.0",
"522d09dfecbeca1595f25ac58c6d0178bbd21d7d": "1.0.0-alpha.2",
"44a287e6eb22ec3c2a687fc156813577464017f7": "1.0.0-alpha",
"ba4081a5a8573875fed17545846f6f6902c8ba8d": "0.12.0",
"aa1163b92de7717eb7c5eba002b4012e0574a7fe": "0.11.0",
"46867cc3e4ddcbb1d359a315805de00094dacaf9": "0.10",
"7613b15fdbbb9bf770a2c731f4135886b0ff3cf0": "0.9",
"8a4f0fa6c518eb634687abe9659601d9d2a61899": "0.8",
"a2db7c15ce9f586164cabb15d83fb3f6bbeb3cf5": "0.7",
"00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9": "0.6",
"8b98e5a296d95c5e832db0756828e5bec31c6f50": "0.5",
"39c0d3591e0326874b7263a621ce09ecd64f0eb2": "0.4",
"2f32a1581f522e524009138b33b1c7049ced668d": "0.3",
"0622a74c48a708aec28d25964f4e9b4489580bc7": "0.2",
"16e4369fe3b5f00aa3cdc584a4e41c51c0d3ca8a": "0.1",
}
``` |
```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.
*/
// Code generated by client-gen. DO NOT EDIT.
package v1beta1
type CSIDriverExpansion interface{}
type CSINodeExpansion interface{}
type StorageClassExpansion interface{}
type VolumeAttachmentExpansion interface{}
``` |
Hubert "Hugh" Thompson (29 April 1914 – 23 February 1943) was a Canadian middle-distance runner. He competed in the men's 1500 metres at the 1936 Summer Olympics. He was killed in action during World War II.
References
External links
1914 births
1943 deaths
Athletes (track and field) at the 1936 Summer Olympics
Canadian male middle-distance runners
Olympic track and field athletes for Canada
Place of birth missing
Royal Air Force personnel killed in World War II |
In early December 2020, an acute neurological disease broke out in Eluru, a city located in the southern Indian state of Andhra Pradesh. The first case was reported on 5 December, with hundreds more falling ill and one person dying over the next week. The cause was initially unknown, but on 20 December, AIIMS and NEERI Research Institute came to a conclusion that pesticides leaching into the water supply is the most likely reason.
Symptoms
Reported symptoms include headache, vomiting, dizziness, convulsions, seizures, nausea, anxiety, loss of consciousness, mental confusion, miosis and other neurological symptoms, which have been described as being similar to epilepsy. The individuals who have been reported to have the disease, especially children, have reported a sudden onset of vomiting after complaining of burning eyes.
Outbreak
The first case was recorded on the evening of 5 December. By the next day, a few hundred more people were admitted to hospital with similar symptoms. The only reported death was a 45-year-old man who had reported similar symptoms. According to CNN, he died of an unrelated cardiac arrest on 5 December, but the Eluru hospital superintendent stated he died due to the symptoms and put him on the official death toll for the illness. The disease was originally found in the One Town area before spreading to other parts of the city as well as the rural area and Denduluru village. Most patients were admitted in the Eluru government hospital, but some that needed better care were sent to institutions in Vijayawada and Guntur.
By the night of 7 December, more than 400 people had been stricken by the disease. While the disease affects all age groups, over 300 of the infected are children. The total reported number of infected had risen to 450 and the discharged to 200 by 7 December. While the symptoms have been reported as being "the same across age groups and gender," a majority of patients are in the age group of 20-30 years old. Hundreds of children were affected by the disease.
The rate of new cases drastically decreased on 8 December, although six people who were previously discharged suffered a second seizure and were readmitted. On 10 December, two other people who got the disease died, causing some media to speculate that their deaths were due to the disease. However, the district's health commissioner announced they had died from unrelated conditions - one from a stroke and one from COVID-19 - and that only the original death remained on the official count. Only two people were admitted into the hospital the next day, with most patients having recovered and thirteen still requiring treatment as of 12 December. On 12 December, no new cases were recorded, and state health minister Alla Kali Krishna Srinivas stated that "the city is heading towards a zero mystery illness situation."
Investigation of cause
Samples from patients and of the local water were collected the same day to determine the cause of the outbreak. Specialists from several worldwide and Indian scientific and medical institutions, such as the National Centre for Disease Control, All India Institutes of Medical Sciences, the World Health Organization, the Indian Council of Medical Research, the National Institute of Nutrition, Centre for Cellular and Molecular Biology, and the Indian Institute of Chemical Technology had been sent to assess the situation and analyze the samples. However, the tests did not detect any water pollution or known virus infections (including COVID-19) upon analysis.
Andhra Pradesh's Health Department reported that "initial blood test[s] did not find any evidence of viral infection." Blood samples have also been tested for antibodies and for bacterial infections such as meningitis. Viruses such as SARS-CoV-2, Japanese encephalitis, dengue, chikungunya, hepatitis and rabies were ruled out as the cause. Since "people not linked to the municipal water supply [have also] fallen ill", water contamination was also initially discarded, and so was air pollution. Blood tests and CT scans were not able to establish the cause or origin of the disease and cerebrospinal fluid tests "turned out to be normal." As of 7 December 2020, the disease has been determined to be non-contagious.
BJP Member of Parliament Narasimha Rao suspected that organochlorides might be the cause after talking to medical experts. Organochlorides are used as pesticides as well as in anti-mosquito fogging. On 7 December 2020, Indian health authorities unofficially declared: "Mostly yes, but we are waiting for the laboratory report [for confirmation]" when asked about organochlorine being the disease-triggering agent. This theory was later ruled out by authorities because there would have been a higher rate of respiratory issues and fatalities.
Later preliminary results pointed to high lead and nickel content in drinking water and milk as possible agents via lead poisoning. Blood tests also found high concentrations of the same materials in patients. State authorities later ruled out air and water as the medium for heavy metals and started testing vegetable and fruit samples. It has also been speculated that pesticides may have leached into the water supply after flash floods. Other theories include improper disposal of batteries as well as excessive bleaching and chlorinating of the water supply to prevent COVID-19 transmission.
On December 16, the Andhra Pradesh government concluded that pesticide residue in the water was the "main reason" for the illness, based on findings from studies conducted by the All India Institute of Medical Sciences (AIIMS) and the National Environmental Engineering and Research Institute (NEERI). AIIMS also reported on high heavy metal content in milk, while NEERI found mercury in surface water higher than the allowed concentration.
Mahesh Kumar Mummadi et al. concluded that Triazofos (Organophosphate) pesticide contamination of water as a probable cause of the outbreak.
Responses and reactions
Y. S. Jaganmohan Reddy, the current chief minister of Andhra Pradesh, has faced criticism from the opposition for his perceived failure to prevent the outbreak by neglecting water sanitation in the area.
Chandrababu Naidu, the leader of the state's opposition Telugu Desam Party, blamed the ruling government for the outbreak, claiming that it had not taken action to decontaminate the local drinking water. The Telugu Desam Party called for a full enquiry, claiming that the spread of the illness was caused by contamination.
Srinivas initially reported “[a]ll the patients are out of danger. Of the 300-odd affected, about 125 have been discharged by Sunday evening."
On 7 December, the government announced it had commenced "a door-to-door survey". The same day, CM Reddy visited the patients in Eluru and gave instructions to his ministers on patient care and supervision, ordering that discharged patients be observed for a month afterwards. The central government announced that a three-person team would be sent to Eluru on 8 December to probe the situation. The state government later formed a 21-member council which included representatives from the All India Institutes of Medical Sciences and the World Health Organization to investigate the outbreak.
Due to reports that lead in vegetables was possibly causing the illness, sales by local vendors were severely reduced as people bought more meat and went to other cities to buy vegetables instead.
See also
2019 Bihar encephalitis outbreak
2017 Gorakhpur hospital deaths
COVID-19 pandemic in Andhra Pradesh
References
2020 disasters in India
2020 disease outbreaks
2020s in Andhra Pradesh
December 2020 events in India
Disasters in Andhra Pradesh
Disease outbreaks in India
Outbreak
Idiopathic diseases
West Godavari district |
```smalltalk
"
Adds accessors (getter and setter) for a variable in a class, if they do not exist.
Usage:
| transformation |
transformation := (RBAddVariableAccessorTransformation
variable: 'variableName'
class: #RBVariableTransformation
classVariable: false)
transform.
(ChangesBrowser changes: transformation model changes changes) open
Preconditions:
- the variable with which the accessors will be created shall exist. The parameter isClassVariable indicates whether to look in the instance or class variables.
"
Class {
#name : 'RBAddVariableAccessorTransformation',
#superclass : 'RBVariableTransformation',
#instVars : [
'getterMethod',
'setterMethod'
],
#category : 'Refactoring-Transformations-Model',
#package : 'Refactoring-Transformations',
#tag : 'Model'
}
{ #category : 'preconditions' }
RBAddVariableAccessorTransformation >> applicabilityPreconditions [
class := self model classObjectFor: className.
^ { (isClassVariable
ifTrue: [
RBCondition definesClassVariable: variableName asSymbol in: class ]
ifFalse: [
RBCondition definesInstanceVariable: variableName in: class ]) }
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> createGetterAccessor [
(self definingClass getterMethodFor: variableName) ifNil: [ self defineGetterMethod ]
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> createSetterAccessor [
(self definingClass setterMethodFor: variableName)
ifNil: [ self defineSetterMethod ]
ifNotNil: [ setterMethod := self definingClass setterMethodFor: variableName ]
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> defineGetterMethod [
getterMethod := self safeMethodNameFor: self definingClass basedOn: variableName asString.
self generateChangesFor: (RBAddMethodTransformation
model: self model
sourceCode: ('<1s><r><r><t>^ <2s>' expandMacrosWith: getterMethod with: variableName)
in: self definingClass
withProtocol: 'accessing').
^ getterMethod
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> defineSetterMethod [
| sourceCode |
sourceCode := '<1s> anObject<r><r><t><2s> := anObject'.
setterMethod := self safeMethodNameFor: self definingClass basedOn: variableName asString , ':'.
self generateChangesFor: (RBAddMethodTransformation
model: self model
sourceCode: (sourceCode expandMacrosWith: setterMethod with: variableName)
in: self definingClass
withProtocol: 'accessing').
^ setterMethod
]
{ #category : 'accessing' }
RBAddVariableAccessorTransformation >> definingClass [
"Usually a shared variable is defined on the instance side and instance
variables on both instance and class side."
^ isClassVariable
ifTrue: [ super definingClass classSide ]
ifFalse: [ super definingClass ]
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> getterMethod [
^ getterMethod
]
{ #category : 'executing' }
RBAddVariableAccessorTransformation >> privateTransform [
self
createGetterAccessor;
createSetterAccessor
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> safeMethodNameFor: aClass basedOn: aString [
"Creates an unused method name containing aString"
| baseString newString hasParam i |
baseString := aString copy.
baseString at: 1 put: baseString first asLowercase.
newString := baseString.
hasParam := newString last = $:.
hasParam
ifTrue: [baseString := newString copyFrom: 1 to: newString size - 1].
i := 0.
[aClass hierarchyDefinesMethod: newString asSymbol] whileTrue:
[i := i + 1.
newString := baseString , i printString
, (hasParam ifTrue: [':'] ifFalse: [''])].
^newString asSymbol
]
{ #category : 'private' }
RBAddVariableAccessorTransformation >> setterMethod [
^ setterMethod
]
``` |
The 2003 WNBA season was the seventh for the New York Liberty. The Liberty fell one game short for the playoffs, also missing the postseason for the first time since 1998.
Offseason
Dispersal Draft
WNBA draft
Regular season
Season standings
Season schedule
Player stats
References
New York Liberty seasons
New York
New York Liberty |
```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.
*/
// Code generated by informer-gen. DO NOT EDIT.
package v1
import (
"context"
time "time"
cephrookiov1 "github.com/rook/rook/pkg/apis/ceph.rook.io/v1"
versioned "github.com/rook/rook/pkg/client/clientset/versioned"
internalinterfaces "github.com/rook/rook/pkg/client/informers/externalversions/internalinterfaces"
v1 "github.com/rook/rook/pkg/client/listers/ceph.rook.io/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
runtime "k8s.io/apimachinery/pkg/runtime"
watch "k8s.io/apimachinery/pkg/watch"
cache "k8s.io/client-go/tools/cache"
)
// CephRBDMirrorInformer provides access to a shared informer and lister for
// CephRBDMirrors.
type CephRBDMirrorInformer interface {
Informer() cache.SharedIndexInformer
Lister() v1.CephRBDMirrorLister
}
type cephRBDMirrorInformer struct {
factory internalinterfaces.SharedInformerFactory
tweakListOptions internalinterfaces.TweakListOptionsFunc
namespace string
}
// NewCephRBDMirrorInformer constructs a new informer for CephRBDMirror type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewCephRBDMirrorInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
return NewFilteredCephRBDMirrorInformer(client, namespace, resyncPeriod, indexers, nil)
}
// NewFilteredCephRBDMirrorInformer constructs a new informer for CephRBDMirror type.
// Always prefer using an informer factory to get a shared informer instead of getting an independent
// one. This reduces memory footprint and number of connections to the server.
func NewFilteredCephRBDMirrorInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
return cache.NewSharedIndexInformer(
&cache.ListWatch{
ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.CephV1().CephRBDMirrors(namespace).List(context.TODO(), options)
},
WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
if tweakListOptions != nil {
tweakListOptions(&options)
}
return client.CephV1().CephRBDMirrors(namespace).Watch(context.TODO(), options)
},
},
&cephrookiov1.CephRBDMirror{},
resyncPeriod,
indexers,
)
}
func (f *cephRBDMirrorInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
return NewFilteredCephRBDMirrorInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
}
func (f *cephRBDMirrorInformer) Informer() cache.SharedIndexInformer {
return f.factory.InformerFor(&cephrookiov1.CephRBDMirror{}, f.defaultInformer)
}
func (f *cephRBDMirrorInformer) Lister() v1.CephRBDMirrorLister {
return v1.NewCephRBDMirrorLister(f.Informer().GetIndexer())
}
``` |
Christine Edzard (born 15 February 1945) is a film director, writer, and costume designer, nominated for BAFTA and Oscar awards for her screenwriting. She has been based in London for most of her career.
Early life
Edzard was born and raised in Paris by her German-born father, Dietz Edzard, and Polish mother, Suzanne Eisendieck, both painters. After a degree in economics she trained as a set and costume designer with Lila De Nobili and Rotislav Duboujinsky. She assisted Di Nobili on Franco Zeffirelli's productions of Aida and Romeo and Juliet at La Scala in 1963 and 1968.
Career
Edzard co-wrote and designed the film Tales of Beatrix Potter (1971), for which she was nominated for two BAFTA awards for Best Costume Design and Best Art Direction.
With her husband, the film producer Richard B. Goodwin, she founded the Sands Films studio and production company in Rotherhithe, London in 1975. The studios include the Rotherhithe Picture Research Library, a free resource for the general public, and the building was awarded a Blue Plaque in 2009, unveiled in January that year by Derek Jacobi. Over the years Sands Films has made and supplied period costumes for international film and TV productions.
Edzard is best known for her film adaptation of Charles Dickens's novel, Little Dorrit (1988), a British film for which she was nominated for an Oscar, a BAFTA Award, and a Los Angeles Film Critics Award.
Director and writer filmography
The Good Soldier Schwejk (2018) direction, screenplay)
The Children's Midsummer Night's Dream (2001) (direction, design)
The IMAX Nutcracker (1997) (screenplay, design, direction)
Amahl and the Night Visitors (1996) - filmed opera by Gian Carlo Menotti (direction, set and costume design)
As You Like It (1991) (direction, design)
The Fool (1990) (screenplay adapted from Henry Mayhew, design, direction)
Little Dorrit (1987) (screenplay, direction, design)
Biddy (1983) (screenplay, direction)
The Nightingale (1981) (screenplay, direction)
Stories from a Flying Trunk (1979) (three short films, Little Ida (1975), The Kitchen (1975) and The Little Match Girl (1975))
Tales of Beatrix Potter (1971)
Making and Supplying of period costumes
References
External links
Sands Films official website
Guardian article
Financial Times article
Greenwich Society history of Sands Films
The Costume Society
The Guardian South Side Story, on The Children's Midsummer Night's Dream, Dec 8, 2000
Warwick University Shakespeare Project
Rotislav Doboujinsky in the V&A Collections
Lila De Nobili in the V&A Collections
1945 births
Living people
British women film directors
British women screenwriters
Film people from Paris
British costume designers
British film producers
British film directors |
Sportitalia 24 was an Italian sports channel, the third owned by LT Multimedia after Sportitalia.
It was broadcast FTA on DTT in Italy channel 62 on Mux Tivuitalia, a company of Screen Service group and on Mux TIMB 2, a company of Telecom Italia Media group. It is also available on SKY Italia and on IPTV.
It was launched as sports-news channel on 10 June 2010.
External links
Official website
Italian-language television stations
Television channels and stations established in 2010
Sports television in Italy
Television channels and stations disestablished in 2013
Defunct television channels in Italy
2010 establishments in Italy
2013 disestablishments in Italy |
The Public Policy Forum (PPF) is an independent, non-profit Canadian think tank for public-private dialogue. The organization's stated aim is "to serve as a neutral, independent forum for open dialogue on public policy."
The Forum was founded in 1987 by Shelly (Sheldon) Ehrenworth, Geoff Poapst and a group of public and private sector leaders. The inaugural board meeting took place in Toronto, where members endorsed what became the Forum's credo: that the business of government is too important to leave in the hands of government alone.
In its early years, the Forum brought together leaders from business, the trade union movement, academe and the not-for-profit sector for meetings in cities across Canada. The idea was to share perspectives on public sector management questions and discuss ways to build a more collaborative approach to policy making.
The PPF has grown to more than 200 members from business, federal and provincial governments, academia, organized labour and the voluntary and not-for-profit sectors.
Its current president and CEO is Edward Greenspon.
Activities
The PPF functions primarily as an independent, non-partisan facilitator of multi-sector dialogue.
Convening
In conjunction with members and partners from all sectors, the PPF convenes dialogues aimed at producing actionable outcomes in key policy areas, such as: innovation, public engagement, public service and governance.
Research
The PPF regularly produces and publishes research and reports in areas related to its policy dialogues. The Forum also conducts original research in areas such as public service innovation, government leadership, and media.
Annual Events & Awards
Throughout the year the PPF hosts gatherings of senior leadership from all sectors to celebrate excellence in public policy leadership. Four events run annually across Canada:
The Testimonial Dinner (Toronto, April)
The Gordon Osbaldeston Lecture (Ottawa, November)
The Western Dinner
Atlantic Dinner & Awards
Since 1988 the Testimonial Dinner Awards pay tribute to distinguished Canadians who have made an outstanding contribution to the quality of public policy and public management. As of 1992 the Hyman Solomon Award is giving to an outstanding journalist and in 2005 the Emerging Leaders Award was introduced. These Testimonial Dinner Awards are adjudicated by the PPF, based upon submissions by member organizations.
References
External links
Non-profit organizations based in Alberta
Organizations established in 1987
Political and economic think tanks based in Canada |
Cabragh House (school and residence) is a late Victorian, timber house at 48 Weka Street in Nelson, New Zealand built circa 1897. It is an historic site for exemplarising late Victorian furnishings and provincial New Zealand vernacular architecture. The neighbouring Amber House, the former site of the Cabragh House School, is pending registration as a New Zealand Historic Place.
Location
Satellite imagery clearly shows how land reclamation to the North of Cabragh House has moved the shoreline considerably northwards from when the house was originally built on the shores of the Nelson Inlet.
Ownership history
According to provincial records, on 7 August 1901, John Pearson Hornsby, a Nelson accountant, purchased land in Weka Street (part sections of Section 258 and 260 and, later, Section 262. These sections already held two dwellings (now numbered 46 and 48) but then known as 36 and 38 Weka Street respectively. Originally, it seems, the larger two-storey house at 36 was the dwelling and residence of Mr Hornsby and his daughters (known as the Misses Hornsby. Then the single-storey house at 38 was used as a private boarding and day school for girls and "little" boys, as indicated by the 1910 Electoral Register.
According to a Prize Day speech delivered by the Principal in the Druids Hall on 10 December 1917 and reported in The Colonist the next day, The school was founded in 1906. However, this is in conflict with an article in the same newspaper that appeared on 21 August 1905 that indicates an opening date of 15 September 1905. Between 1909 and 1917 Cabragh House School was heavily promoted in local almanacs, street directories and the Post & Telegraph New Zealand Directory.
Although this Hornsby land transfer was registered in 1901, it is probable that both buildings existed before this time. The Architectural design of both Cabragh House and the adjoining Amber House indicates a date of construction for both houses somewhere between 1895 and 1905. To support this contention, an original photograph, principally of the two-storey house then at 36 Weka Street, has printed on its reverse “CABRAGH House school & home, Weka Street, Nelson NZ. Late 1890s school started & staffed by Hornsby sisters Charlotte (Lizzy), Ruth & Janetta”. Municipal drain layer plans and sheets also indicate a probable date of erection for both houses in early 1897.
The private school business was successful in provincial Nelson - especially for people with the right qualifications. An advertisement in the Nelson Streets Directory indicates that Miss Jannetta M Hornsby B.A., N.Z.U., A.R.C.M. (London) also had rooms at 50 Trafalgar Street as a teacher of pianoforte, theory, singing, elocution and languages as well as being Principal of Cabragh House School.
However, a search of the deeds reveals that none of the sisters Hornsby ever owned legal title to either the School or Dwelling House located at either 36 or 38 Weka Street.
In February 1908, John Hornsby mortgaged 38 Weka Street for government advances for unknown purposes. The money could have been put towards improvements for both structures. Such improvements may have included a two-storey porch and bracketed awnings added to Amber House sometime between 1906 and 1920. In 1918, Amber House (renumbered from 36 to 46 Weka Street) was used exclusively as classrooms and boarding accommodation and Cabragh House (renumbered from 38 to 48 Weka Street) became a residence.
School
The Amber House was known as Cabragh House School during the first decades of the twentieth century, not to be confused with the dwelling known as the Cabragh House next door.
On 28 April 1919 John Hornsby died at his residence in Weka Street, aged 85 years.
The Obituary in The Colonist the next day included the following: "Prior to coming to New Zealand about 25 years ago, he held several important positions on the Irish railways. Although he never took much interest in civic affairs, he was a keen advocate of the through freights system, on the subject of which he contributed several valuable articles. His daughters conducted the Cabragh House School successfully for many years."
In October of that year a Certificate of Addendum was issued. The Public Trustee conveyed a portion of the property for private sale. Now the renumbered 46 and 48 Weka Street were passed to daughter Charlotte, who sold it to Henry Canning in 1928.
The last listing for Cabragh House School in Lucas's Nelson Almanac is for 1927 and there is no entry for the School in the 1928 Post Office Directory. Certainly by 1928 Cabragh House School was no longer operating as a school, its scholastic function and commercial viability having been rendered superfluous by the steady growth of, what is now called, Nelson Central School.
Etymology
The word Cabragh probably has Irish or other Gaelic roots due to the Hornsby's Irish origins and may be an unorthodox spelling of Gabragh meaning an area of rough grazing.
References
+
+
External links
Edwardian photos of Cabragh House School
Nelson Central School
Placenames in the north of Ireland
New Zealand Historic Places Trust Pouhere Taonga Register
New Zealand Architecture
Original Acrylic Paintings, Watercolours and Pen & Ink Drawings of Colonial Architecture by Kathy Reilly, Golden Bay, New Zealand
Buildings and structures in Nelson, New Zealand
Houses in New Zealand
Defunct schools in New Zealand
1890s architecture in New Zealand |
```smalltalk
using Chloe.DbExpressions;
using Chloe.RDBMS;
using Chloe.RDBMS.MethodHandlers;
namespace Chloe.SQLite.MethodHandlers
{
class TrimEnd_Handler : TrimEnd_HandlerBase
{
public override void Process(DbMethodCallExpression exp, SqlGeneratorBase generator)
{
PublicHelper.EnsureTrimCharArgumentIsSpaces(exp.Arguments[0]);
generator.SqlBuilder.Append("RTRIM(");
exp.Object.Accept(generator);
generator.SqlBuilder.Append(")");
}
}
}
``` |
Reginald Charles Stuart (September 1, 1943 – April 29, 2018) was a Canadian historian. The main focus of his work is on two major topics: the American experience with war as an instrument of policy and the relations of Canadians and Americans in what he terms Upper North America. He retired in 2013 and lived in Halifax, Nova Scotia.
Career
Stuart was born on September 1, 1943, in Vancouver, British Columbia. He received his B.A. and M.A. at the University of British Columbia, and his PhD. at the University of Florida. He taught at Prince of Wales College from 1968 to 1969 and at the University of Prince Edward Island from 1969 to 1988. He came to Mount Saint Vincent University in Halifax as Dean of Arts and Science in 1988 and became a full-time faculty member in 1996.
Awards
Reginald C. Stuart won twice Merit Award for Scholarly Achievement at the University of Prince Edward Island (1982-1983) and (1987-1988).
His United States Expansionism and British North America (1988) won the 1990 The Albert Corey Prize. This book is also one of the references to War of 1812.
He won the MSVU Award for Research Excellence (2004).
He won a Canadian-American Fulbright award in 2003 and became the distinguished Chair in North American Studies at the Woodrow Wilson International Center for Scholars in Washington, D.C., from January to June, 2004.
Selected publications
Transnationalism in Canada-United States History Montreal: McGill-Queen's University Press, 2010. Co-editor with Michael D. Behiels.
Civil-Military Relations during the War of 1812. Westport, CT: Praeger, 2009. This book is listed as one of the references to Vermont National Guard.
Dispersed Relations: Americans and Canadians in Upper North America. Washington, DC: Co-published by Woodrow Wilson Center Press; and Baltimore, MD: Johns Hopkins University Press, 2007.
Too Close? Too Far? Just Right? False Dichotomies and Canada-US Policy Making. Orono, Maine: Canadian-American Center, No. 66, April 2006.
United States Expansionism and British North America, 1775-1871. Chapel Hill: the University of North Carolina Press, 1988. This book is also listed in the references to Manifest destiny.
The First Seventy-Five Years. Vancouver: the Certified General Accountants Association of Canada, 1988.
War and American Thought: From the Revolution to the Monroe Doctrine. Kent, Ohio: the Kent State University Press, 1982.
The Half-way Pacifist: Thomas Jefferson's View of War. Toronto: University of Toronto Press, 1978.
Both Transnationalism in Canada-United States History and Dispersed Relations: Americans and Canadians in Upper North America are listed in the Further Reading to Canada–United States relations.
Dr. Stuart's articles and reviews have appeared in The American Review of Canadian Studies, Diplomatic History, Canadian Journal of History, International History Review, Canadian Review of American Studies, the Journal of Church and State, Canadian Review of Studies in Nationalism, and the Tennessee Historical Quarterly. He contributed a chapter, "A Thousand Points of Partnership: Upper North America to 1931," in the book,Forgotten Partnership Redux: Canada-U.S. Relations in the 21st Century. Amherst, NY: Cambria Press, 2011, PP. 305–340. His article "Prologue to Manifest Destiny: Anglo-American Relations in the 1840s" is in the references to Louis McLane.
References
External links
The Mount website
1943 births
2018 deaths
20th-century Canadian historians
Historians of Atlantic Canada
Writers from Halifax, Nova Scotia
Writers from Vancouver
Academic staff of Mount Saint Vincent University
University of Florida alumni
University of British Columbia alumni
Academic staff of the University of Prince Edward Island
21st-century Canadian historians |
```python
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# A super basic python webhook receiver
# Run in a new terminal as:
#
# ./hook.py 0.0.0.0 8123
#
# Then setup your runserver.py with `-wh path_to_url`
import sys
import time
import json
import pprint
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
HOST_NAME = sys.argv[1]
HOST_PORT = int(sys.argv[2])
class S(BaseHTTPRequestHandler):
def do_POST(self):
data_string = self.rfile.read(int(self.headers['Content-Length']))
self.send_response(200)
self.end_headers()
pprint.pprint(json.loads(data_string))
if __name__ == '__main__':
httpd = HTTPServer((HOST_NAME, HOST_PORT), S)
print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, HOST_PORT)
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
print time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, HOST_PORT)
``` |
Bernard Yack (born 1952) is a Canadian born American political theorist.
He received his B.A. from the University of Toronto and his Ph.D. in Philosophy from Harvard University, where he was a student of Judith Shklar. Yack has taught at numerous universities including Princeton University and the University of Wisconsin–Madison. He is the author of works of political and social philosophy such as The Problems of a Political Animal, and The Longing for Total Revolution: The Philosophic Sources of Social Discontent from Rousseau to Marx and Nietzsche. His most recent book is titled Nationalism and the Moral Psychology of Community. He is currently the Lerman Neubauer Professor of Democracy and Public Policy at Brandeis University.
Selected publications
Yack, Bernard. Nationalism and the Moral Psychology of Community. Chicago: University of Chicago Press, 2012.
Yack, Bernard. The Fetishism of Modernities: Epochal Self-Consciousness in Contemporary Social and Political Thought. University of Notre Dame Press, 1997.
Yack, Bernard. Liberalism without Illusions: Essays on Liberal Theory and the Political Vision of Judith N. Shklar. University of California Press, 1996.
Yack, Bernard. The Problems of a Political Animal: Community, Conflict, and Justice in Aristotelian Political Thought. University of California Press, 1993.
Yack, Bernard. The Longing for Total Revolution: Philosophic Sources of Social Discontent from Rousseau to Marx and Nietzsche. Princeton University Press, 1986.
References
External links
Brandeis University page
1952 births
University of Toronto alumni
Harvard Graduate School of Arts and Sciences alumni
Scholars of nationalism
Moral psychologists
Canadian political philosophers
Brandeis University faculty
Princeton University faculty
Living people
Jewish philosophers
20th-century Canadian philosophers
21st-century Canadian philosophers |
Arkansas Highway 35 is a northwest–southeast state highway in southeast Arkansas. The route runs from Dewey near the Mississippi River northwest to Arkansas Highway 5 in Benton.
Route description
The route begins in Dewey at Macon Lake Road near Island number 81 on the Mississippi River. AR 35 runs through bayous and fields in Chicot County, briefly entering Desha County for a junction with AR 159/AR 208 in Halley.
Returning to Chicot County, AR 35 intersects the four-lane divided US 65/US 278 and US 165 east of Dermott, before entering the city. AR 35 serves Dermott as Speedway St before entering Drew County. The highway runs south of the Seven Devils Swamp WMA along the Arkansas Midland Railroad tracks until Monticello. AR 35 is concurrent with US 278, and later US 425 until the northwest corner of Monticello, where AR 35 turns northwest away from US 425. The highway continues northwest, intersecting AR 530, which is an under-construction segment of the future Monticello Bypass (the bypass itself is a portion of the long-term plan to extend Interstate 69 through Arkansas). A sign exists at where AR 32 will meet I-69 that states "Future I-69 Corridor <--->".
AR 35 continues northwest to enter Cleveland County, where a concurrency with US 63 begins north to Pansy. After Pansy, AR 35 runs northwest through Toledo to Rison, where it passes the American Legion Hut, Texaco Service Station, and Cities Service Station, each on the National Register of Historic Places. East of downtown, AR 35 has a junction with US 79, after which the route serves the rural northwest corner of the county.
The route next enters Grant County, passing through forest/clear cut land to a rural junction with AR 190. West of the AR 190 intersection, AR 35 begins a northbound concurrency with US 167 at Crossroads. This concurrency includes the city of Sheridan including a junction with US 270/AR 46. AR 35 turns west onto West Vine Street, ending the concurrency with US 167. The route runs northwest through rural country, entering Saline. Running past the brine springs for which the county is named, AR 35 enters Benton. In the city, the highway passes near the Gann Row Historic District, the Saline County Courthouse, and the Independent Order of Odd Fellows Building, all NRHP properties. After a large intersection with I-30/US 67/US 70/AR 5, AR 35 continues north to terminate at AR 5 in north Benton.
Major intersections
See also
List of state highways in Arkansas
References
External links
035
Transportation in Chicot County, Arkansas
Transportation in Desha County, Arkansas
Transportation in Drew County, Arkansas
Transportation in Cleveland County, Arkansas
Transportation in Grant County, Arkansas
Transportation in Saline County, Arkansas |
The 1883 NYU Violets football team was an American football team that represented New York University in the 1883 college football season. The team played two games, the score for week one is unknown while the score for the game against Paterson was a 4–2 win.
Schedule
References
NYU
NYU Violets football seasons
NYU Violets football |
Red Hot Romance is a 1922 American silent comedy film directed by Victor Fleming. A fragmentary print survives in the Library of Congress.
Plot
As described in a film magazine, young American Rowland Stone (Sydney) receives $50 per week from the estate of his rich uncle until he reaches age 25, at which time, according to the will, he is to hear of further bequests. He is in love with Anna Mae (Collins), the daughter of an old Virginia family, the head of which, Colonel Cassius Byrd (Connelly), has been waiting 40 years for a diplomatic post. The young man pawns all of his furniture to get her presents. When the day of his big inheritance arrives, Rowland discovers that he is to receive $25 per week and must serve one year as an insurance agent to prove his worth before he can secure his fortune. His sweetheart has gone with her father to the nation of Bunkonia in South America, so the new insurance agent sees there some fertile fields and sets sail with his valet Thomas (Wilson). In Bunkonia he meets the villainous Jim Conwell (Atwell), the best families, King Caramba XIII (Lalor) and his cabinet, and he insures everyone in sight. Jim knows the terms of the will and plots a revolution, knowing that the insured king and cabinet will be the first to die and thus ruin the insurance agent. The Colonel, now a counsel, is imprisoned by the plotters and Jim kidnaps Anna Mae, compelling Rowland to save the king, cabinet, sweetheart, and counsel for the sake of insurance, love, and country. During the revolution Rowland is in the difficult position of being unable to kill any of the plotters since they carry policies with his insurance companies. In spite of this handicap, they are all saved with the arrival of the U.S. Marines.
Cast
Basil Sydney as Rowland Stone
Henry Warwick as Lord Howe-Greene
Frank Lalor as King Caramba XIII
Carl Stockdale as General De Castanet
Olive Valerie as Madame Puloff de Plotz
Edward Connelly as Colonel Cassius Byrd
May Collins as Anna Mae Byrd
Roy Atwell as Jim Conwell
Tom Wilson as Thomas Snow
Lillian Leighton as Mammy
Snitz Edwards as Signor Frijole
Production
An early working title for the film was Wife Insurance. The full scenario for the film was published in Emerson's and Loos's book Breaking Into the Movies (1921).
References
External links
Advert for the film
1922 films
Films directed by Victor Fleming
American black-and-white films
American silent feature films
Films with screenplays by Anita Loos
Silent American comedy films
1922 comedy films
1920s American films |
Nacht und Träume (Night and Dreams) is the last television play written and directed by Samuel Beckett. It was written in English (mid-1982) for the German channel Süddeutscher Rundfunk, recorded in October 1982 and broadcast on 19 May 1983 where it attracted "an audience of two million viewers." The mime artist Helfrid Foron played both parts.
It was published by Faber in Collected Shorter Plays in 1984. Originally entitled Nachtstück (Night Piece), it is a wordless play, the only sound that of a male voice humming, then singing, from the last seven bars of Schubert’s lied Nacht und Träume, words by Matthäus Casimir von Collin: "Holde Träume, kehret wieder!" ("Sweet dreams, come back"). Schubert was a composer much loved by Beckett – "the composer who spoke most to him … whom he considered a friend in suffering" – and this lied was one of the author’s favourites.
James Knowlson, in his biography of Beckett, states that the actual text used however was a slightly modified version by Heinrich Joseph von Collin, Matthäus’s brother.
Synopsis
Beckett lists five elements that make up the play: evening light, the dreamer (A), his dreamt self (B), a pair of dreamt hands and the last seven bars of Schubert’s lied. It reads more like a formula or a list of ingredients than a cast.
The action begins with a dreamer sitting alone in a dark empty room; his hands are resting on the table before him. He is on the far left of the screen and we are presented with his right profile. A male voice hums the last seven bars of the Schubert lied. Then we hear the same section sung, the man rests his head on his hands and the light fades until the words "Holde Träume" whereupon it fades up on the man’s dreamt self who is seated on an invisible podium four feet higher and well to the right of him. We see his left profile, a mirror image of his waking self. His is bathed in what Beckett describes as a "kinder light." The dreamer is still faintly visible throughout though.
A left hand appears out of the darkness and gently rests on B. As the man raises his head it withdraws. The right appears with a cup from which B drinks. It vanishes and then reappears to gently wipe his brow with a cloth. Then it disappears again. B raises his head to gaze upon the invisible face and holds out his right hand, palm upward. The right hand returns and rests on B’s right hand. He looks at the two hands together and adds his left hand. Together the three hands sink to the table and B rests his head on them. Finally the left hand comes out of the darkness and rests gently on his head.
The dream fades as A awakens but when the music is replayed the sequence is replayed, in close-up and slower.
Afterwards the camera withdraws leaving us with an image of a "recovering" A before the light fades away completely.
Interpretation
The play finds its origin in Beckett’s fascination with Albrecht Dürer's famous etching of praying hands, a reproduction of which had hung in his room at Cooldrinagh as a child, however "the dark, empty room with its rectangle of light and its black-coated figure hunched over the table, resembled a schematised seventeenth century Dutch painting even more explicitly than Ohio Impromptu.".
Beckett insisted to Dr Müller-Freinfels that "the sex of the hands must remain uncertain. One of our numerous teasers". He did, however concede to James Knowlson that these "sexless hands … might perhaps be a boy’s hands". In the end, practicality demanded that he opt for female hands with the proviso, "Large but female. As more conceivably male than male conceivably female."
"Beckett never endorses a belief in salvation from, or redemption for, suffering. But the need for some temporary comfort from suffering becomes acute in his late work, especially in the work for television." The helping hand is an image of consolation. It suggests a kind of benediction. In ritualistic and sacramental fashion the blessed shade offers him first a cup from which he drinks and then gently wipes his brow with a cloth.
"The screen layout calls to mind certain religious paintings where a vision often appears in a top corner of the canvas, normally the Virgin Mary, Christ ascended in his glory or a ministering angel. The chalice, cloth and comforting hand are similarly images commonly found in religious paintings." Beckett’s cameraman, Jim Lewis said that:
"… at the moment when the drops of perspiration are wiped from the brow of the character, Beckett simply said that the cloth alluded to the veil that Veronica used to wipe the brow of Jesus on the Way of the Cross. The imprint of Christ’s face remains on the cloth."
"The play could have been sentimental, even maudlin. The mysterious quality of the action, the beauty of the singing … and the specificity of the repeated, almost ritualistic patterns avoid this. What, on the printed page, seems a very slight piece, acquires on the screen a strange, haunting beauty." One has to assume, using the same logic as Beckett did with Quad II, that the dream/memory/fantasy is winding down and that, if it was to receive a third run through, it would be slower again suggesting that it is fading away. Perhaps even now it is no longer accessible consciously, only via the unconscious. "In Beckett’s production for German television a central door, not mentioned in the text, was shown in the shots of A, disappearing in the shots of B, as though A had entered the world of B through the door of memory."
But why use such Judeo-Christocentric imagery when so much of his more famous work revolves around life in a godless universe? As he conceded to Colin Duckworth, "Christianity is a mythology with which I am perfectly familiar, so I naturally use it". One might imagine Beckett appending the same disclaimer he applied to Berkeley’s philosophy in Film: "No truth value attaches to above, regarded as of merely structural and dramatic convenience"
References
1983 plays
Plays by Samuel Beckett
Theatre of the Absurd |
Union Sportive Cognaçaise is a French rugby union club, based in Cognac in the Charente département (Nouvelle-Aquitaine region). They play at the Parc des Sports (capacity 2,800), and wear white and red.
They were founded on 2 December 1898 and regularly competed in the first division in the 1950s and 1960s. They played in the 1954 French championship final, going down narrowly to FC Grenoble 3-5. They are currently competing in the fifth level of the French league system, Fédérale 3.
Club honours
French premiership : runner-up 1954
Challenge Yves-du-Manoir (French cup) 1965
Second division champions 1995
Famous players
Jacques Fouroux
Gérald Merceron
David Esnault
External links
Official site (work in progress)
Cognac
Union Sportive Cognacaise
1899 establishments in France |
Ferenc András Völgyesi (11 February 1895, Budapest – 3 July 1967, Uccle) was a controversial Hungarian physician, psychiatrist and hypnotist who published dozens of articles and books, had a prosperous private practice, and gained fame in Hungary and abroad. Völgyesi, along with Ara Jeretzian, established a medical clinic during the latter days of World War II credited with saving the lives of approximately 400 Jews. Völgyesi also served as an agent of the Hungarian Secret Service, codenamed "Viktor", starting in 1962.
Early life
Ferenc Völgyesi was born in 1895 to Ábrahám (Adolf) Völgyesi and Hermina (Mária) Klein. His father was the owner of the Zöldvadász restaurant and the Trieszti nők pub in Budapest. After his death, Völgyesi's mother ran the establishments, and invested in apartment houses. Völgyesi was Jewish but in 1938 Völgyesi and his family converted to Lutheranism.
Völgyesi claimed that at the age of 17 he first discovered his ability to hypnotize. He hypnotized an 18-year-old girl who remained catatonic for three days.
Medical training and military service
Völgyesi started medical studies in 1912 at the University of Medicine in Budapest. He was deployed in 1916, before graduating from medical school, to the battle fought between Hungarian and Russian troops on the Dniester River, where he recounts, "I was doing my medical supervising circuit on horseback on a beautiful sunny morning in May, and listening with a smile to the trivial complaints of the healthy sunburnt young artillerymen from Budapest...suddenly the Russian artillery opened fire...That was the first time I heard the terrible, agonized death-cry of HELP -- break forth simultaneously from a whole crowd of men...I had to amputate limbs with a penknife, and without any local anesthetic." Völgyesi received his medical degree in 1917 and soon after established a successful private practice, which was initially shared with the celebrated lay hypnotist Alfréd Pethes.
In 1912–1914, Völgyesi was an intern, and later teaching assistant at the Anatomical Institute of the University of Budapest. After his graduation, he served as a surgeon, and was later certified as a neurologist. In 1917, he was one of the founders of the Trade Union of Physicians and of the Újpest and Rákospalota National Ambulance Association. He served at the Military Command, and was later transferred to the 72nd Artillery Battalion, the 1st Division, and in 1918-1919 was the Chief Paramedic of the Hungarian Red Army. He attained First Lieutenant and later Major rank (in 1945 he was commissioned Major in reserve). In a letter written in 1944 requesting exemption from anti-Jewish regulations, he asserted that he had incited the paramedic corps against the Communist regime, was sentenced to death, but managed to flee to Transdanubia, and volunteered to the Hungarian National Army, led by Miklós Horthy, becoming Chief Paramedic of the Szombathely and Budapest Artillery Corps. He received a number of decorations during his service, and after the Soviet occupation of Hungary in 1945 was also awarded the Commemorative Medal for the Hungarian Soviet Republic. In the interwar period, he served as an assistant physician at the Departments of Neurology and Orthopedy of the Szt. János Hospital. After obtaining a certificate in medical forensics in 1927, he also served as a forensic expert.
Hypnosis Practice
Initially Völgyesi focused his practice on treating trauma from the recent war. But he discovered, to his surprise, that the "victims of so-called peace" were as numerous as the victims of war.
He often scheduled his patients so that they would spend lengthy amounts of time in the waiting room with other patients, who were instructed to "talk about anything except your illness." He saw this as a useful form of informal group therapy.
In 1920, Völgyesi published the book Hypnosis: the Place and Application of Hypnosis in Modern Medicine.
During 50 years of medical practice Völgyesi's writings were widely published and reprinted, with 250 articles and 25 books in Hungarian, English, French, German, Spanish and Russian. According to him, between 1917 and 1963 he treated more than 62,000 patients, using hypno-suggestive therapy more than 800,000 times. However, his broader fame came from his experiments in animal hypnosis rather than with human subjects, an important aspect of hypnosis research largely forgotten by historians.
In his works, Völgyesi described and gave photographic evidence for the hypnosis of lobsters, crocodiles, birds, bears, lions, monkeys, and other animals to become frozen in a state of hypnotic catalepsy. He aimed to prove the common biological origins of hypnotic states in both man and animals. He maintained in this written works that the ability to hypnotize animals suggested that verbal suggestion was not the only method of hypnosis, and that these nonverbal techniques were applicable to humans as well.
In 1939 the photographer Andor Fischer filed a lawsuit against Völgyesi, claiming that Völgyesi did not pay for the photos that Fischer was hired to take of hypnotized animals. Fischer further asserted that the photos were copies of drawings of hypnotized animals, or photos of animals that were not hypnotized. The photo of the bear, for example, that Völgyesi claimed had hypnotized, was, according to Fischer, actually taken in a Hungarian circus after the chained animal had been tortured, and the chains were subsequently erased from the photo. The court denied Fischer's claims.
In 1939 Völgyesi toured North America and Europe and gave a lecture at Yale University. He was also received by Clark Hull, William Brown, Julian Huxley, and Carl Jung, among others.
Völgyesi's writings also veered into discussions of the temperaments of women and men, mysticism, love, war, happiness, civilization, and personal anecdotes. For instance, a 1942 published review of one of Völgyesi's books describes that, "the opus as a whole is uninterpretable, moreover, it is even not clearcut because of its mosaic-like nature in which professional knowledge is merged with anecdotes, and mysticism is implanted into natural science."
German Recruiting Attempts
German psychiatrist (and active National Socialist) Matthias Göring attempted to recruit Völgyesi in 1938 to form a "national group" of psychiatrists in Hungary to affiliate with the Nazi regime. Völgyesi responded to Göring with reasons that he could not support the establishment of such a group.
Hungarian newspapers during this period of time made reference to Völgyesi's academic relationship with Göring. An attempt was made to parlay Völgyesi's correspondence with Göring into a "protected Jew" status for Völgyesi during the Arrow Cross period in Hungary. Also referring to his relations with Göring, Völgyesi wrote a petition in June 1944, requesting exemption from anti-Jewish regulations on account of his "counterrevolutionary conduct" against the Hungarian Soviet Republic, and his military service and decorations.
In 1942, Völgyesi volunteered to the Hungarian Army as a regiment paramedic in reserve, but was only allowed to serve for a short period of time. Between April and November 1944, he did labor service at the Szt. János Hospital but soon established his own clinic at his apartment.
Yellow Star House at 1 Zichy Jenő Street
In late 1944 the Nazi-allied Arrow Cross Party took control of Hungary and accelerated efforts to round up and deport Jews. Völgyesi co-led the conversion of an apartment building at 1 Zichy Jenő utca in Budapest, where Völgyesi and his family resided, into a medical clinic staffed by mostly Jewish doctors and nurses. The clinic took in all patients in need of care, including Jews, Arrow Cross soldiers, and (later) Russian soldiers. While the effort was mainly led by an Armenian-born Christian named Ara Jeretzian, who obtained false and real permits at great personal risk to operate the clinic in defiance of official orders to resettle all Jews in another part of town, Völgyesi also played a key role, and put himself and his family at great risk. Völgyesi's reputation as a world-famous psychiatrist helped to keep the clinic from being shut down by the authorities. A life-sized portrait of Völgyesi in a gold-plated frame was covered with a life-sized portrait of Ferenc Szálasi, leader of the Arrow Cross Party.The clinic managed to stay open up until the Russian occupation of Budapest, saving the lives of approximately 400 Jews who had been harbored there. According to Jeretzian's memoir, Jeretzian obtained papers in order for Völgyesi, a Jew, to avoid being detained during the Arrow Cross period, and he also harbored Völgyesi's wife in his apartment to avoid surprise raids and deportation. Later, Völgyesi turned angry toward Jeretzian for delaying the restoration Volgyesi's apartment to his personal use, as the space was still being used to treat patients. This caused Volgyesi to complain about Jeretzian to the Soviet occupying forces, who imprisoned and tortured Jeretzian for six months.
Postwar life
In 1945, Völgyesi reportedly praised the Red Army in a newspaper article, and later claimed that he had been in contact with the Soviet military counterintelligence services. Between 1945 and 1948 he was a member of the Social Democratic Party, but was expelled before its merger with the Communist Party of Hungary in 1948. In 1950, Völgyesi began working at the Péterfy Hospital, while continuing to receive patients at his private practice. In 1949, Völgyesi was criticized in the newspaper of the Communist Party of Hungary for his allegedly unscientific methods, and was expelled from the Trade Union of Physicians. However, he was quickly readmitted.
In 1949, Cardinal József Mindszenty, the leader of the Catholic Church in Hungary, was convicted of treason against the Communist People's Republic of Hungary in a show trial widely condemned by the international community. Mindszenty was extensively tortured and was forced to sign a confession. Völgyesi was repeatedly accused of playing a role in "preparing" Cardinal József Mindszenty, Archbishop of Esztergom and leader of the Catholic Church in Hungary, for his 1949 show trial. Notably, however, there seems to be no evidence to his involvement in the trial in the Historical Archives of the Hungarian State Security, the memoirs of Mindszenty, or in the books in which the documents of the case were published. According to Margit Balogh's monumental biography of Mindszenty, the story of Mindszenty's hypnosis by Völgyesi was made up László Sulner, a handwriting expert involved in the trial. Sulner presented his claims of using hypnosis and drugs on Mindszenty to the US Consulate in Austria, who were suspicious of the allegations. Later, Sulner published the story in the Chicago Sun-Times. A document from the Radio Free Europe archives dated 1956 claims that Völgyesi "prepared" Mindszenty for the trial. Völgyesi's wife was reported to have complained that Völgyesi's colleagues cut off social contact with them as a result of his role in the Mindszenty trial. In the spring of 1963 the Voice of America relayed a similar report, claiming that Völgyesi hypnotized Mindszenty following orders from the leader of the State Protection Authority (ÁVH), Gábor Péter, and ÁVH Colonel István Bálint, a torture expert, and later Head of the Medical Division of the ÁVH. This report seems to have resulted in Völgyesi and his wife being denied entry visas to Canada, and a delay in being issued visas to the United States, making it impossible for them to visit their daughter and her newborn daughter there.
The Hungarian Secret Service began conducting surveillance on Völgyesi not later than 1957 (codename "Charlatan"), and continued to do so until at least May 1963. Starting in 1962, Völgyesi, codenamed "Viktor," agreed to participate as an informant to the Hungarian Secret Service. Völgyesi was asked or offered to spy on a variety of people with whom he had family, professional, and social ties, such as his sons-in-law (one of whom was a language interpreter for the Cabinet of the European Common Market in Brussels), his patients (including the First Secretary of the Austrian Embassy in Hungary), "American millionaire" Bruce Gelb, and economist and art historian John Michael Montias. Volgyesi's primary motivation for agreeing to spy for the regime was to obtain permission for him and his wife to travel abroad, as all three of their children had emigrated from Hungary. Völgyesi also co-led spiritualist circles aiming to convince patients to choose specific surgeons to perform operations in exchange for large payments, warning that the patients would otherwise die. He also, it was claimed, attempted to contact deceased Nazi leaders from the spirit world, to ask for regime change in Hungary.
References
1967 deaths
20th-century Hungarian physicians
1895 births
Hungarian Jews
Hungarian psychiatrists
Hungarian hypnotists |
Governor Brough may refer to:
Charles Hillman Brough (1876–1935), 25th Governor of Arkansas
John Brough (1811–1865), 26th Governor of Ohio |
Willie Spencer Myrick, known as W. Spencer Myrick (November 23, 1918 – November 24, 1991), was a conservative Democratic member of both houses of the Louisiana State Legislature for West Carroll Parish in northeastern Louisiana.
Political life
Myrick first entered state politics as an elected member of the House of Representatives, having served from 1956 to 1960 during the final administration of Governor Earl Kemp Long. During the following second administration of Governor Jimmie Davis, Myrick was an investigator for the Louisiana Sovereignty Commission. Voelker ran in the 1963 Democratic gubernatorial primary but polled few votes. In that same election, Myrick was nominated and then elected without opposition to the Louisiana State Senate. He served a single term from 1964 to 1968. Myrick also worked periodically as an aide to Governor Earl Long, a confidant and friend.
After his legislative years, Myrick and his wife, the former Marie Gammill (May 13, 1918–June 19, 1998) resided in Baton Rouge, where Myrick died.
See also
References
Further reading
Michael L. Kurtz and Morgan D. Peoples, Earl K. Long: The Saga of Uncle Earl and Louisiana Politics. Louisiana State University Press, 1992. (, )
1918 births
1991 deaths
People from Simpson County, Mississippi
Baptists from Mississippi
People from Oak Grove, Louisiana
Politicians from Baton Rouge, Louisiana
Democratic Party Louisiana state senators
Democratic Party members of the Louisiana House of Representatives
Farmers from Louisiana
20th-century American businesspeople
20th-century American politicians
Baptists from Louisiana
20th-century Baptists
American anti-communists |
Mounes Abdul Wahab (born 1947) is a civil rights activist, author and pioneer of disability rights movement in Lebanon. He has been blind since birth.
Early life
Mounes was born to Fadwa and Kifli Abdul Wahab in the Lebanese city of El-Mina, and is a grandson of Kheireddine Abdul Wahab. Blind at birth, Mounes spent his early years in El Mina, mostly home schooled. Later during his teens, he was schooled in specialized schools in Beirut and Cairo, Egypt, where he learned braille. He then enrolled at the American University of Beirut, where he received a bachelor's degree in Arabic literature in 1974 and later a master's degree in the same subject in 1983.
Civil Rights Activism
Abdul Wahab's civil activism began while he was still a student at the American University of Beirut. He joined the Lebanese Association of Blind Workers (established in 1935) and was elected to its board of governors in 1974. While still a student at the university, in 1975, he founded the Lebanese Association of Blind University Graduates and represented Lebanon in the international conference for the blind in Berlin, Germany that same year, which saw participation of
over 130 countries.
With Lebanese Civil War breaking out in 1975, Abdul Wahab was forced to suspend his graduate studies and return to his hometown of El-Mina. He later resumed his graduate studies in 1981, and continued his activism by hosting a radio show With the Handicapped for three years that helped raise awareness of issues faced by the disability community and bring them to the general public. That same year, he was appointed to the National Committee of the Disabled, and represented Lebanon in regional conferences for the disabled between 1981 and 1984 in Amman, Sharja and Riyadh respectively.
Upon his graduation with an MA in Arabic Literature in 1983, he returned to his hometown of El-Mina in North Lebanon, and was, alongside professor Nawaf Kabbara, a founding member of the North Lebanon branch of The Friends of the Handicapped Association, the largest non-governmental organization for people with disabilities in Lebanon. With Kabbara, he played a vital role in pioneering events such as the Handicapped Peacewalk from North to South Lebanon in 1987 and the 1988 Oxfam
Lebanon Peace conference which formed a significant step in the disability rights movement in the country. Abdul Wahab again represented his country in numerous
conferences in Belarus, Egypt and Jordan.
Abdul Wahab remains active on the civil rights scene and was the first disabled man to be elected to municipal committee of El-Mina in the 1996 general elections.
He published his memoirs in 2003 and remains a regular contributor to numerous publications and newspapers.
References
Ayam Mou'nes." (Days of Mounes) - M. Abdul Wahab, 2003, Friends of the Handicapped Press.
Lebanese activists
1947 births
Living people
Blind activists |
The following is a list of notable events and releases of the year 1913 in Norwegian music.
Events
Deaths
April
20 – Theodor Løvstad, musician, magazine editor and revue writer (born 1843).
Births
March
9 – Beate Asserson, mezzo-soprano opera singer (died 2000).
July
5 – Eline Nygaard Riisnæs, pianist and musicologist (died 2011).
December
21 – Amalie Christie, pianist (died 2010).
See also
1913 in Norway
Music of Norway
References
Norwegian music
Norwegian
Music
1910s in Norwegian music |
```asciidoc
//
include::{generated}/meta/{refprefix}VK_NV_private_vendor_info.adoc[]
=== Other Extension Metadata
*Last Modified Date*::
2022-08-10
*Contributors*::
- Daniel Koch, NVIDIA
- Jonathan McCaffrey, NVIDIA
- Jeff Bolz, NVIDIA
=== Description
This extension provides the application with access to vendor-specific enums
and structures that are not expected to be publicly documented.
include::{generated}/interfaces/VK_NV_private_vendor_info.adoc[]
=== Issues
1) What should we call this extension?
RESOLVED.
`apiext:VK_NV_private_vendor_info` as this contains details of NVIDIA's
implementation that we do not expect to publicly document.
=== Version History
* Revision 1, 2022-05-03 (Daniel Koch)
** Internal revisions
* Revision 2, 2022-08-10 (Daniel Koch)
** change number for extension (373 to 52) to avoid conflict
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.