text
stringlengths 1
22.8M
|
|---|
Pua'a-2 Agricultural Fields Archeological District is a historic site of Ancient Hawaii agriculture on the Big Island of Hawaii.
The site
Coordinates are approximate; it is within the Ahupuaa of Puaa 2, on a Kona coffee farm known as Ariana Farms Ono Coffee.
A 1985 survey found several stone platforms, several agricultural terraces, and a 50 by feature thought to be an agricultural heiau.
The site is state archaeological site number 10-28-10,229 (the last part of this site designation, plus "50HA" to indicate the state of Hawaii, was appended to its name on the National registry). It was added to the National Register of Historic Places on October 14, 1986, as site number 86002804.
Severe damage in 2000
The site was damaged and possibly destroyed in 2000 when a permit was mistakenly given to clear the area for planting coffee. The State Historic Preservation District officials approve each grading permit, but with several vacancies for archaeologists in the district, the property owners were not aware of any site on their property.
References
Archaeological sites in Hawaii
Geography of Hawaii (island)
Agriculture in Hawaii
Archaeological sites on the National Register of Historic Places in Hawaii
Heiau
Protected areas of Hawaii (island)
Protected areas established in 1986
1986 establishments in Hawaii
Historic districts on the National Register of Historic Places in Hawaii
|
Gandabad (, also Romanized as Gandābād) is a village in Poshtdarband Rural District, in the Central District of Kermanshah County, Kermanshah Province, Iran. At the 2006 census, its population was 386, in 114 families.
References
Populated places in Kermanshah County
|
Louis "Lou" Hirshman (1905-1986) was an American artist known for his witty and imaginative use of found objects for caricatures of celebrities and politicians and, in later years, for scenes of everyday life.
Unlike sketched or painted two-dimensional caricatures, these collages, known as constructions, are reliefs on glass-covered, framed flat boards created using common items and discarded junk, a genre which Bostonia magazine once dubbed the "Out-of-the-Ashcan School." His creations exaggerated the icons of his day, ranging from Adolf Hitler to Groucho Marx and President John F. Kennedy to Cuba's Fidel Castro, revealing their essence with gloves, spools of thread, peanut shells, and chains.
Museum acquires Einstein
Hirshman's most famous artwork was arguably his 1940 representation of Albert Einstein, with the genius mathematician sporting a wild mop of hair, an abacus chest and shirt collar scribbled with the equation 2+2 = 2+2. In 1977, the piece was purchased by the Philadelphia Museum of Art.
Although his pieces often engendered laughter as viewers recognized the parts of familiar items that informed the subject as a whole, Hirshman – as well as colleagues—considered these representations serious works of art. In his last period, he shifted into caricaturizing scenes of everyday life and archetypes, all with his clever mix of found objects.
Birth and early life
Hirshman was born in 1905 in western Russia, now part of Ukraine, to Jewish parents. Trying to escape hard times, his mother and father decided to take their nine children to the United States. After his father, along with several of Hirshman's older siblings, emigrated to Philadelphia, Pennsylvania, on the East Coast of the U.S., he found work in a sweatshop, saving enough money to reunite the family. In 1909, four-year-old Louis, the second youngest in the family, sailed to the U.S. through Ellis Island with his mother and the remaining siblings to join his father. From that point on, except for a stint in the U.S. Army during World War II, he lived his entire life in Philadelphia.
As a child of a poor family, Hirshman claimed he would sometimes ease his pangs of hunger by drawing pictures of food, a skill that became useful for his later artworks that often contained what appeared to be perishables, such as bananas and spiders, but were actually created in his studio.
Training in art and brief career in filmmaking
Hirshman left school at the end of 10th grade and started doing art professionally in 1920. While little is known about his artistic activities during the decade, at some point Hirshman received a grant from the Barnes Foundation, an art institute in Philadelphia, to study art in Paris, as well as in Italy. He also attended the Pennsylvania Academy of Fine Arts in Philadelphia. A lover of movies—the Marx Brothers and Charlie Chaplin would later become subjects of his witty constructions–-Hirshman co-founded the avant-garde Cinema Crafters of Philadelphia in 1928. In 1930, Hirshman, taking on the nom de plume of Hershell Louis, and several colleagues made the experimental film Story of a Nobody, in which the camera takes the subjective view of an invisible protagonist. It has since been hailed as one of the first examples of avant-garde filmmaking in the US. The only copy, archived at the Museum of Modern Art in New York, deteriorated and was discarded in 1956.
In the mid-1930s, Hirshman joined the Graphic Sketch Club, an art school in Philadelphia for local artists. While Hirshman had been doing oil paintings, he shifted toward drawing caricatures. In 1938, a premier ballerina, Catherine Littlefield, incensed by an unflattering caricature, entered Hirshman's studio, slapped him on the cheek and tore up the drawing.
A new kind of caricature
Hirshman had already been experimenting with his constructions. His first major piece was in 1935, a biting caricature of the rich business magnate, John D. Rockefeller, the co-founder Standard Oil (coat and cap of crushed rock and a silver dime for an eye). By 1938, with an increased portfolio, Hirshman was approached by Look Magazine. The popular weekly journal ran a two-page, black-and-white spread featuring four of his pieces--Adolf Hitler with a house painter's brush for nose and mustache (Hitler was rumored to be a house painter) and a dustpan of manure for the shirt; Harpo Marx with tomatoes for hair; Italian dictator Benito Mussolini with a toilet plunger for a scowling mouth; and the Duchess and Duke of Windsor, the well-off American divorcee Wallis Simpson with a pocketbook face, and milquetoast-timid former King Edward VIII with a slice-of-toast head and sunny-side-up egg eye. His work also appeared in several other publications, including Vanity Fair. In May 2015, the New York-based Society of illustrators hosted a lecture on forgotten caricaturists, which highlighted Hirshman's work.
Jobs and wartime
Married in 1939, the following year Hirshman began working at a commercial artist studio doing portraits, murals, cartoons and landscapes, as well as painting designs on plates. As World War II raged, he also created posters for the Works Project Administration (WPA), a federal program started during the Great Depression, as part of the Federal Art Project. In 1943, Hirshman went into the U.S. Army and was stationed in Texas, largely doing graphics duties, such as training aids.
Teaching career
After his discharge in 1946, Hirshman moved back to Philadelphia, eventually joining the faculty at the highly respected Samuel S. Fleisher Art Memorial, a free art school with evening and Saturday classes (now administered by the Philadelphia Museum of Art). He was appointed faculty director in 1960, serving until his retirement in 1977.
There are very few known pieces created by Hirshman from 1950 through 1961. But in 1962, he produced Tap Dancer, his first construction featuring an archetype rather than a public figure. Hirshman still occasionally did caricatures of politicians – pre-assassination President John F. Kennedy with a coconut forelock of hair (Hirshman put the piece in storage for many years after Kennedy's death); USSR leader Nikita Khrushchev with a potato nose and garlic clove teeth; and Cuban leader Fidel Castro with a beard of chain and a doughnut mouth holding a hotdog Havana. His last caricature of a public figure was a 1964 portrayal of a rat-like French President Charles de Gaulle in profile with the foot part a large upside-down sock representing his large proboscis.
A shift in subject matter
During this transition period, Hirshman began using his found objects to mimic the world he saw around him—and the world in his head—a shift in direction that was to last until the end of his life. Largely unknown, this large collection of collages reveal an artist finding caricature, both humorous and serious, in a vase of flowers (Still Life); animals (Elephant and The Hunt); loneliness (Brooding Young Girl); and dozens of other motifs. Anything could be anything – handcuffs as glasses (The Psychiatrist); tin can lids for tree leaves (The Storm); a pair children's scissors as crossed swords (The Duel); or halved peach pits for breasts (Topless Waitress).
Death
Hirshman died on July 26, 1986, at his home in Philadelphia. An unfinished construction was still on his easel.Inquirer.com: Philadelphia local news, sports, jobs, cars, homes
References
External links
Lou Hirshman - Official website including gallery of Hirshman's artwork.
1905 births
1986 deaths
American caricaturists
Works Progress Administration workers
Emigrants from the Russian Empire to the United States
Federal Art Project artists
|
```c++
#include "splitoperation.h"
#include <vespa/storage/distributor/idealstatemanager.h>
#include <vespa/storageapi/message/bucketsplitting.h>
#include <vespa/storage/distributor/distributor_bucket_space.h>
#include <vespa/log/bufferedlogger.h>
LOG_SETUP(".distributor.operation.idealstate.split");
using namespace storage::distributor;
SplitOperation::SplitOperation(const ClusterContext& cluster_ctx, const BucketAndNodes& nodes,
uint32_t maxBits, uint32_t splitCount, uint32_t splitSize)
: IdealStateOperation(nodes),
_tracker(cluster_ctx),
_maxBits(maxBits),
_splitCount(splitCount),
_splitSize(splitSize)
{}
SplitOperation::~SplitOperation() = default;
void
SplitOperation::onStart(DistributorStripeMessageSender& sender)
{
_ok = false;
BucketDatabase::Entry entry = _bucketSpace->getBucketDatabase().get(getBucketId());
for (uint32_t i = 0; i < entry->getNodeCount(); i++) {
auto msg = std::make_shared<api::SplitBucketCommand>(getBucket());
msg->setMaxSplitBits(_maxBits);
msg->setMinDocCount(_splitCount);
msg->setMinByteSize(_splitSize);
msg->setTimeout(MAX_TIMEOUT);
setCommandMeta(*msg);
_tracker.queueCommand(std::move(msg), entry->getNodeRef(i).getNode());
_ok = true;
}
if (!_ok) {
LOGBP(debug, "Unable to split bucket %s, since no copies are available (some in maintenance?)", getBucketId().toString().c_str());
done();
} else {
_tracker.flushQueue(sender);
}
}
void
SplitOperation::onReceive(DistributorStripeMessageSender&, const api::StorageReply::SP& msg)
{
auto& rep = dynamic_cast<api::SplitBucketReply&>(*msg);
uint16_t node = _tracker.handleReply(rep);
if (node == 0xffff) {
LOG(debug, "Ignored reply since node was max uint16_t for unknown reasons");
return;
}
std::ostringstream ost;
if (_cancel_scope.node_is_cancelled(node)) {
_ok = false;
} else if (rep.getResult().success()) {
BucketDatabase::Entry entry = _bucketSpace->getBucketDatabase().get(rep.getBucketId());
if (entry.valid()) {
entry->removeNode(node);
if (entry->getNodeCount() == 0) {
LOG(spam, "Removing split bucket %s", getBucketId().toString().c_str());
_bucketSpace->getBucketDatabase().remove(rep.getBucketId());
} else {
_bucketSpace->getBucketDatabase().update(entry);
}
ost << getBucketId() << " => ";
}
// Add new buckets.
for (const auto & sinfo : rep.getSplitInfo()) {
if (!sinfo.second.valid()) {
LOG(error, "Received invalid bucket %s from node %d as reply to split bucket",
sinfo.first.toString().c_str(), node);
}
ost << sinfo.first << ",";
BucketCopy copy(_manager->operation_context().generate_unique_timestamp(), node, sinfo.second);
// Must reset trusted since otherwise trustedness of inconsistent
// copies would be arbitrarily determined by which copy managed
// to finish its split first.
_manager->operation_context().update_bucket_database(
document::Bucket(msg->getBucket().getBucketSpace(), sinfo.first), copy,
(DatabaseUpdate::CREATE_IF_NONEXISTING | DatabaseUpdate::RESET_TRUSTED));
}
} else if (
rep.getResult().getResult() == api::ReturnCode::BUCKET_NOT_FOUND
&& _bucketSpace->getBucketDatabase().get(rep.getBucketId())->getNode(node) != nullptr)
{
_manager->operation_context().recheck_bucket_info(node, getBucket());
LOGBP(debug, "Split failed for %s: bucket not found. Storage and distributor bucket databases might be out of sync: %s",
getBucketId().toString().c_str(), std::string(rep.getResult().getMessage()).c_str());
_ok = false;
} else if (rep.getResult().isBusy()) {
LOG(debug, "Split failed for %s, node was busy. Will retry later", getBucketId().toString().c_str());
_ok = false;
} else if (rep.getResult().isCriticalForMaintenance()) {
LOGBP(warning, "Split failed for %s: %s with error '%s'",
getBucketId().toString().c_str(), msg->toString().c_str(),
msg->getResult().toString().c_str());
_ok = false;
} else {
LOG(debug, "Split failed for %s with non-critical failure: %s",
getBucketId().toString().c_str(),
rep.getResult().toString().c_str());
}
if (_tracker.finished()) {
LOG(debug, "Split done on node %d: %s completed operation", node, ost.str().c_str());
done();
} else {
LOG(debug, "Split done on node %d: %s still pending on other nodes", node, ost.str().c_str());
}
}
bool
SplitOperation::isBlocked(const DistributorStripeOperationContext& ctx, const OperationSequencer& op_seq) const
{
return checkBlockForAllNodes(getBucket(), ctx, op_seq);
}
bool
SplitOperation::shouldBlockThisOperation(uint32_t msgType,
[[maybe_unused]] uint16_t node,
uint8_t pri) const
{
if (msgType == api::MessageType::SPLITBUCKET_ID && _priority >= pri) {
return true;
}
if (msgType == api::MessageType::JOINBUCKETS_ID) {
return true;
}
return false;
}
```
|
```c
/*your_sha256_hash---------
*
* nodeModifyTable.c
* routines to handle ModifyTable nodes.
*
*
*
* IDENTIFICATION
* src/backend/executor/nodeModifyTable.c
*
*your_sha256_hash---------
*/
/* INTERFACE ROUTINES
* ExecInitModifyTable - initialize the ModifyTable node
* ExecModifyTable - retrieve the next tuple from the node
* ExecEndModifyTable - shut down the ModifyTable node
* ExecReScanModifyTable - rescan the ModifyTable node
*
* NOTES
* The ModifyTable node receives input from its outerPlan, which is
* the data to insert for INSERT cases, or the changed columns' new
* values plus row-locating info for UPDATE cases, or just the
* row-locating info for DELETE cases.
*
* If the query specifies RETURNING, then the ModifyTable returns a
* RETURNING tuple after completing each row insert, update, or delete.
* It must be called again to continue the operation. Without RETURNING,
* we just loop within the node until all the work is done, then
* return NULL. This avoids useless call/return overhead.
*/
#include "postgres.h"
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "commands/trigger.h"
#include "executor/execPartition.h"
#include "executor/executor.h"
#include "executor/nodeModifyTable.h"
#include "foreign/fdwapi.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "rewrite/rewriteHandler.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/memutils.h"
#include "utils/rel.h"
typedef struct MTTargetRelLookup
{
Oid relationOid; /* hash key, must be first */
int relationIndex; /* rel's index in resultRelInfo[] array */
} MTTargetRelLookup;
static void ExecBatchInsert(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
TupleTableSlot **slots,
TupleTableSlot **planSlots,
int numSlots,
EState *estate,
bool canSetTag);
static bool ExecOnConflictUpdate(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
ItemPointer conflictTid,
TupleTableSlot *planSlot,
TupleTableSlot *excludedSlot,
EState *estate,
bool canSetTag,
TupleTableSlot **returning);
static TupleTableSlot *ExecPrepareTupleRouting(ModifyTableState *mtstate,
EState *estate,
PartitionTupleRouting *proute,
ResultRelInfo *targetRelInfo,
TupleTableSlot *slot,
ResultRelInfo **partRelInfo);
/*
* Verify that the tuples to be produced by INSERT match the
* target relation's rowtype
*
* We do this to guard against stale plans. If plan invalidation is
* functioning properly then we should never get a failure here, but better
* safe than sorry. Note that this is called after we have obtained lock
* on the target rel, so the rowtype can't change underneath us.
*
* The plan output is represented by its targetlist, because that makes
* handling the dropped-column case easier.
*
* We used to use this for UPDATE as well, but now the equivalent checks
* are done in ExecBuildUpdateProjection.
*/
static void
ExecCheckPlanOutput(Relation resultRel, List *targetList)
{
TupleDesc resultDesc = RelationGetDescr(resultRel);
int attno = 0;
ListCell *lc;
foreach(lc, targetList)
{
TargetEntry *tle = (TargetEntry *) lfirst(lc);
Form_pg_attribute attr;
Assert(!tle->resjunk); /* caller removed junk items already */
if (attno >= resultDesc->natts)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("table row type and query-specified row type do not match"),
errdetail("Query has too many columns.")));
attr = TupleDescAttr(resultDesc, attno);
attno++;
if (!attr->attisdropped)
{
/* Normal case: demand type match */
if (exprType((Node *) tle->expr) != attr->atttypid)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("table row type and query-specified row type do not match"),
errdetail("Table has type %s at ordinal position %d, but query expects %s.",
format_type_be(attr->atttypid),
attno,
format_type_be(exprType((Node *) tle->expr)))));
}
else
{
/*
* For a dropped column, we can't check atttypid (it's likely 0).
* In any case the planner has most likely inserted an INT4 null.
* What we insist on is just *some* NULL constant.
*/
if (!IsA(tle->expr, Const) ||
!((Const *) tle->expr)->constisnull)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("table row type and query-specified row type do not match"),
errdetail("Query provides a value for a dropped column at ordinal position %d.",
attno)));
}
}
if (attno != resultDesc->natts)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("table row type and query-specified row type do not match"),
errdetail("Query has too few columns.")));
}
/*
* ExecProcessReturning --- evaluate a RETURNING list
*
* resultRelInfo: current result rel
* tupleSlot: slot holding tuple actually inserted/updated/deleted
* planSlot: slot holding tuple returned by top subplan node
*
* Note: If tupleSlot is NULL, the FDW should have already provided econtext's
* scan tuple.
*
* Returns a slot holding the result tuple
*/
static TupleTableSlot *
ExecProcessReturning(ResultRelInfo *resultRelInfo,
TupleTableSlot *tupleSlot,
TupleTableSlot *planSlot)
{
ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
ExprContext *econtext = projectReturning->pi_exprContext;
/* Make tuple and any needed join variables available to ExecProject */
if (tupleSlot)
econtext->ecxt_scantuple = tupleSlot;
econtext->ecxt_outertuple = planSlot;
/*
* RETURNING expressions might reference the tableoid column, so
* reinitialize tts_tableOid before evaluating them.
*/
econtext->ecxt_scantuple->tts_tableOid =
RelationGetRelid(resultRelInfo->ri_RelationDesc);
/* Compute the RETURNING expressions */
return ExecProject(projectReturning);
}
/*
* ExecCheckTupleVisible -- verify tuple is visible
*
* It would not be consistent with guarantees of the higher isolation levels to
* proceed with avoiding insertion (taking speculative insertion's alternative
* path) on the basis of another tuple that is not visible to MVCC snapshot.
* Check for the need to raise a serialization failure, and do so as necessary.
*/
static void
ExecCheckTupleVisible(EState *estate,
Relation rel,
TupleTableSlot *slot)
{
if (!IsolationUsesXactSnapshot())
return;
if (!table_tuple_satisfies_snapshot(rel, slot, estate->es_snapshot))
{
Datum xminDatum;
TransactionId xmin;
bool isnull;
xminDatum = slot_getsysattr(slot, MinTransactionIdAttributeNumber, &isnull);
Assert(!isnull);
xmin = DatumGetTransactionId(xminDatum);
/*
* We should not raise a serialization failure if the conflict is
* against a tuple inserted by our own transaction, even if it's not
* visible to our snapshot. (This would happen, for example, if
* conflicting keys are proposed for insertion in a single command.)
*/
if (!TransactionIdIsCurrentTransactionId(xmin))
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
}
}
/*
* ExecCheckTIDVisible -- convenience variant of ExecCheckTupleVisible()
*/
static void
ExecCheckTIDVisible(EState *estate,
ResultRelInfo *relinfo,
ItemPointer tid,
TupleTableSlot *tempSlot)
{
Relation rel = relinfo->ri_RelationDesc;
/* Redundantly check isolation level */
if (!IsolationUsesXactSnapshot())
return;
if (!table_tuple_fetch_row_version(rel, tid, SnapshotAny, tempSlot))
elog(ERROR, "failed to fetch conflicting tuple for ON CONFLICT");
ExecCheckTupleVisible(estate, rel, tempSlot);
ExecClearTuple(tempSlot);
}
/*
* Compute stored generated columns for a tuple
*/
void
ExecComputeStoredGenerated(ResultRelInfo *resultRelInfo,
EState *estate, TupleTableSlot *slot,
CmdType cmdtype)
{
Relation rel = resultRelInfo->ri_RelationDesc;
TupleDesc tupdesc = RelationGetDescr(rel);
int natts = tupdesc->natts;
MemoryContext oldContext;
Datum *values;
bool *nulls;
Assert(tupdesc->constr && tupdesc->constr->has_generated_stored);
/*
* If first time through for this result relation, build expression
* nodetrees for rel's stored generation expressions. Keep them in the
* per-query memory context so they'll survive throughout the query.
*/
if (resultRelInfo->ri_GeneratedExprs == NULL)
{
oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
resultRelInfo->ri_GeneratedExprs =
(ExprState **) palloc(natts * sizeof(ExprState *));
resultRelInfo->ri_NumGeneratedNeeded = 0;
for (int i = 0; i < natts; i++)
{
if (TupleDescAttr(tupdesc, i)->attgenerated == ATTRIBUTE_GENERATED_STORED)
{
Expr *expr;
/*
* If it's an update and the current column was not marked as
* being updated, then we can skip the computation. But if
* there is a BEFORE ROW UPDATE trigger, we cannot skip
* because the trigger might affect additional columns.
*/
if (cmdtype == CMD_UPDATE &&
!(rel->trigdesc && rel->trigdesc->trig_update_before_row) &&
!bms_is_member(i + 1 - FirstLowInvalidHeapAttributeNumber,
ExecGetExtraUpdatedCols(resultRelInfo, estate)))
{
resultRelInfo->ri_GeneratedExprs[i] = NULL;
continue;
}
expr = (Expr *) build_column_default(rel, i + 1);
if (expr == NULL)
elog(ERROR, "no generation expression found for column number %d of table \"%s\"",
i + 1, RelationGetRelationName(rel));
resultRelInfo->ri_GeneratedExprs[i] = ExecPrepareExpr(expr, estate);
resultRelInfo->ri_NumGeneratedNeeded++;
}
}
MemoryContextSwitchTo(oldContext);
}
/*
* If no generated columns have been affected by this change, then skip
* the rest.
*/
if (resultRelInfo->ri_NumGeneratedNeeded == 0)
return;
oldContext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
values = palloc(sizeof(*values) * natts);
nulls = palloc(sizeof(*nulls) * natts);
slot_getallattrs(slot);
memcpy(nulls, slot->tts_isnull, sizeof(*nulls) * natts);
for (int i = 0; i < natts; i++)
{
Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
if (attr->attgenerated == ATTRIBUTE_GENERATED_STORED &&
resultRelInfo->ri_GeneratedExprs[i])
{
ExprContext *econtext;
Datum val;
bool isnull;
econtext = GetPerTupleExprContext(estate);
econtext->ecxt_scantuple = slot;
val = ExecEvalExpr(resultRelInfo->ri_GeneratedExprs[i], econtext, &isnull);
/*
* We must make a copy of val as we have no guarantees about where
* memory for a pass-by-reference Datum is located.
*/
if (!isnull)
val = datumCopy(val, attr->attbyval, attr->attlen);
values[i] = val;
nulls[i] = isnull;
}
else
{
if (!nulls[i])
values[i] = datumCopy(slot->tts_values[i], attr->attbyval, attr->attlen);
}
}
ExecClearTuple(slot);
memcpy(slot->tts_values, values, sizeof(*values) * natts);
memcpy(slot->tts_isnull, nulls, sizeof(*nulls) * natts);
ExecStoreVirtualTuple(slot);
ExecMaterializeSlot(slot);
MemoryContextSwitchTo(oldContext);
}
/*
* ExecInitInsertProjection
* Do one-time initialization of projection data for INSERT tuples.
*
* INSERT queries may need a projection to filter out junk attrs in the tlist.
*
* This is also a convenient place to verify that the
* output of an INSERT matches the target table.
*/
static void
ExecInitInsertProjection(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo)
{
ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
Plan *subplan = outerPlan(node);
EState *estate = mtstate->ps.state;
List *insertTargetList = NIL;
bool need_projection = false;
ListCell *l;
/* Extract non-junk columns of the subplan's result tlist. */
foreach(l, subplan->targetlist)
{
TargetEntry *tle = (TargetEntry *) lfirst(l);
if (!tle->resjunk)
insertTargetList = lappend(insertTargetList, tle);
else
need_projection = true;
}
/*
* The junk-free list must produce a tuple suitable for the result
* relation.
*/
ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc, insertTargetList);
/* We'll need a slot matching the table's format. */
resultRelInfo->ri_newTupleSlot =
table_slot_create(resultRelInfo->ri_RelationDesc,
&estate->es_tupleTable);
/* Build ProjectionInfo if needed (it probably isn't). */
if (need_projection)
{
TupleDesc relDesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
/* need an expression context to do the projection */
if (mtstate->ps.ps_ExprContext == NULL)
ExecAssignExprContext(estate, &mtstate->ps);
resultRelInfo->ri_projectNew =
ExecBuildProjectionInfo(insertTargetList,
mtstate->ps.ps_ExprContext,
resultRelInfo->ri_newTupleSlot,
&mtstate->ps,
relDesc);
}
resultRelInfo->ri_projectNewInfoValid = true;
}
/*
* ExecInitUpdateProjection
* Do one-time initialization of projection data for UPDATE tuples.
*
* UPDATE always needs a projection, because (1) there's always some junk
* attrs, and (2) we may need to merge values of not-updated columns from
* the old tuple into the final tuple. In UPDATE, the tuple arriving from
* the subplan contains only new values for the changed columns, plus row
* identity info in the junk attrs.
*
* This is "one-time" for any given result rel, but we might touch more than
* one result rel in the course of an inherited UPDATE, and each one needs
* its own projection due to possible column order variation.
*
* This is also a convenient place to verify that the output of an UPDATE
* matches the target table (ExecBuildUpdateProjection does that).
*/
static void
ExecInitUpdateProjection(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo)
{
ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
Plan *subplan = outerPlan(node);
EState *estate = mtstate->ps.state;
TupleDesc relDesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
int whichrel;
List *updateColnos;
/*
* Usually, mt_lastResultIndex matches the target rel. If it happens not
* to, we can get the index the hard way with an integer division.
*/
whichrel = mtstate->mt_lastResultIndex;
if (resultRelInfo != mtstate->resultRelInfo + whichrel)
{
whichrel = resultRelInfo - mtstate->resultRelInfo;
Assert(whichrel >= 0 && whichrel < mtstate->mt_nrels);
}
updateColnos = (List *) list_nth(node->updateColnosLists, whichrel);
/*
* For UPDATE, we use the old tuple to fill up missing values in the tuple
* produced by the subplan to get the new tuple. We need two slots, both
* matching the table's desired format.
*/
resultRelInfo->ri_oldTupleSlot =
table_slot_create(resultRelInfo->ri_RelationDesc,
&estate->es_tupleTable);
resultRelInfo->ri_newTupleSlot =
table_slot_create(resultRelInfo->ri_RelationDesc,
&estate->es_tupleTable);
/* need an expression context to do the projection */
if (mtstate->ps.ps_ExprContext == NULL)
ExecAssignExprContext(estate, &mtstate->ps);
resultRelInfo->ri_projectNew =
ExecBuildUpdateProjection(subplan->targetlist,
false, /* subplan did the evaluation */
updateColnos,
relDesc,
mtstate->ps.ps_ExprContext,
resultRelInfo->ri_newTupleSlot,
&mtstate->ps);
resultRelInfo->ri_projectNewInfoValid = true;
}
/*
* ExecGetInsertNewTuple
* This prepares a "new" tuple ready to be inserted into given result
* relation, by removing any junk columns of the plan's output tuple
* and (if necessary) coercing the tuple to the right tuple format.
*/
static TupleTableSlot *
ExecGetInsertNewTuple(ResultRelInfo *relinfo,
TupleTableSlot *planSlot)
{
ProjectionInfo *newProj = relinfo->ri_projectNew;
ExprContext *econtext;
/*
* If there's no projection to be done, just make sure the slot is of the
* right type for the target rel. If the planSlot is the right type we
* can use it as-is, else copy the data into ri_newTupleSlot.
*/
if (newProj == NULL)
{
if (relinfo->ri_newTupleSlot->tts_ops != planSlot->tts_ops)
{
ExecCopySlot(relinfo->ri_newTupleSlot, planSlot);
return relinfo->ri_newTupleSlot;
}
else
return planSlot;
}
/*
* Else project; since the projection output slot is ri_newTupleSlot, this
* will also fix any slot-type problem.
*
* Note: currently, this is dead code, because INSERT cases don't receive
* any junk columns so there's never a projection to be done.
*/
econtext = newProj->pi_exprContext;
econtext->ecxt_outertuple = planSlot;
return ExecProject(newProj);
}
/*
* ExecGetUpdateNewTuple
* This prepares a "new" tuple by combining an UPDATE subplan's output
* tuple (which contains values of changed columns) with unchanged
* columns taken from the old tuple.
*
* The subplan tuple might also contain junk columns, which are ignored.
* Note that the projection also ensures we have a slot of the right type.
*/
TupleTableSlot *
ExecGetUpdateNewTuple(ResultRelInfo *relinfo,
TupleTableSlot *planSlot,
TupleTableSlot *oldSlot)
{
ProjectionInfo *newProj = relinfo->ri_projectNew;
ExprContext *econtext;
/* Use a few extra Asserts to protect against outside callers */
Assert(relinfo->ri_projectNewInfoValid);
Assert(planSlot != NULL && !TTS_EMPTY(planSlot));
Assert(oldSlot != NULL && !TTS_EMPTY(oldSlot));
econtext = newProj->pi_exprContext;
econtext->ecxt_outertuple = planSlot;
econtext->ecxt_scantuple = oldSlot;
return ExecProject(newProj);
}
/* your_sha256_hash
* ExecInsert
*
* For INSERT, we have to insert the tuple into the target relation
* (or partition thereof) and insert appropriate tuples into the index
* relations.
*
* slot contains the new tuple value to be stored.
* planSlot is the output of the ModifyTable's subplan; we use it
* to access "junk" columns that are not going to be stored.
*
* Returns RETURNING result if any, otherwise NULL.
*
* This may change the currently active tuple conversion map in
* mtstate->mt_transition_capture, so the callers must take care to
* save the previous value to avoid losing track of it.
* your_sha256_hash
*/
static TupleTableSlot *
ExecInsert(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
TupleTableSlot *slot,
TupleTableSlot *planSlot,
EState *estate,
bool canSetTag)
{
Relation resultRelationDesc;
List *recheckIndexes = NIL;
TupleTableSlot *result = NULL;
TransitionCaptureState *ar_insert_trig_tcs;
ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
OnConflictAction onconflict = node->onConflictAction;
PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
MemoryContext oldContext;
/*
* If the input result relation is a partitioned table, find the leaf
* partition to insert the tuple into.
*/
if (proute)
{
ResultRelInfo *partRelInfo;
slot = ExecPrepareTupleRouting(mtstate, estate, proute,
resultRelInfo, slot,
&partRelInfo);
resultRelInfo = partRelInfo;
}
ExecMaterializeSlot(slot);
resultRelationDesc = resultRelInfo->ri_RelationDesc;
/*
* Open the table's indexes, if we have not done so already, so that we
* can add new index entries for the inserted tuple.
*/
if (resultRelationDesc->rd_rel->relhasindex &&
resultRelInfo->ri_IndexRelationDescs == NULL)
ExecOpenIndices(resultRelInfo, onconflict != ONCONFLICT_NONE);
/*
* BEFORE ROW INSERT Triggers.
*
* Note: We fire BEFORE ROW TRIGGERS for every attempted insertion in an
* INSERT ... ON CONFLICT statement. We cannot check for constraint
* violations before firing these triggers, because they can change the
* values to insert. Also, they can run arbitrary user-defined code with
* side-effects that we can't cancel by just not inserting the tuple.
*/
if (resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_insert_before_row)
{
if (!ExecBRInsertTriggers(estate, resultRelInfo, slot))
return NULL; /* "do nothing" */
}
/* INSTEAD OF ROW INSERT Triggers */
if (resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_insert_instead_row)
{
if (!ExecIRInsertTriggers(estate, resultRelInfo, slot))
return NULL; /* "do nothing" */
}
else if (resultRelInfo->ri_FdwRoutine)
{
/*
* GENERATED expressions might reference the tableoid column, so
* (re-)initialize tts_tableOid before evaluating them.
*/
slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
/*
* Compute stored generated columns
*/
if (resultRelationDesc->rd_att->constr &&
resultRelationDesc->rd_att->constr->has_generated_stored)
ExecComputeStoredGenerated(resultRelInfo, estate, slot,
CMD_INSERT);
/*
* If the FDW supports batching, and batching is requested, accumulate
* rows and insert them in batches. Otherwise use the per-row inserts.
*/
if (resultRelInfo->ri_BatchSize > 1)
{
/*
* When we've reached the desired batch size, perform the
* insertion.
*/
if (resultRelInfo->ri_NumSlots == resultRelInfo->ri_BatchSize)
{
ExecBatchInsert(mtstate, resultRelInfo,
resultRelInfo->ri_Slots,
resultRelInfo->ri_PlanSlots,
resultRelInfo->ri_NumSlots,
estate, canSetTag);
resultRelInfo->ri_NumSlots = 0;
}
oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
if (resultRelInfo->ri_Slots == NULL)
{
resultRelInfo->ri_Slots = palloc(sizeof(TupleTableSlot *) *
resultRelInfo->ri_BatchSize);
resultRelInfo->ri_PlanSlots = palloc(sizeof(TupleTableSlot *) *
resultRelInfo->ri_BatchSize);
}
/*
* Initialize the batch slots. We don't know how many slots will
* be needed, so we initialize them as the batch grows, and we
* keep them across batches. To mitigate an inefficiency in how
* resource owner handles objects with many references (as with
* many slots all referencing the same tuple descriptor) we copy
* the appropriate tuple descriptor for each slot.
*/
if (resultRelInfo->ri_NumSlots >= resultRelInfo->ri_NumSlotsInitialized)
{
TupleDesc tdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
TupleDesc plan_tdesc =
CreateTupleDescCopy(planSlot->tts_tupleDescriptor);
resultRelInfo->ri_Slots[resultRelInfo->ri_NumSlots] =
MakeSingleTupleTableSlot(tdesc, slot->tts_ops);
resultRelInfo->ri_PlanSlots[resultRelInfo->ri_NumSlots] =
MakeSingleTupleTableSlot(plan_tdesc, planSlot->tts_ops);
/* remember how many batch slots we initialized */
resultRelInfo->ri_NumSlotsInitialized++;
}
ExecCopySlot(resultRelInfo->ri_Slots[resultRelInfo->ri_NumSlots],
slot);
ExecCopySlot(resultRelInfo->ri_PlanSlots[resultRelInfo->ri_NumSlots],
planSlot);
resultRelInfo->ri_NumSlots++;
MemoryContextSwitchTo(oldContext);
return NULL;
}
/*
* insert into foreign table: let the FDW do it
*/
slot = resultRelInfo->ri_FdwRoutine->ExecForeignInsert(estate,
resultRelInfo,
slot,
planSlot);
if (slot == NULL) /* "do nothing" */
return NULL;
/*
* AFTER ROW Triggers or RETURNING expressions might reference the
* tableoid column, so (re-)initialize tts_tableOid before evaluating
* them. (This covers the case where the FDW replaced the slot.)
*/
slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
}
else
{
WCOKind wco_kind;
/*
* Constraints and GENERATED expressions might reference the tableoid
* column, so (re-)initialize tts_tableOid before evaluating them.
*/
slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
/*
* Compute stored generated columns
*/
if (resultRelationDesc->rd_att->constr &&
resultRelationDesc->rd_att->constr->has_generated_stored)
ExecComputeStoredGenerated(resultRelInfo, estate, slot,
CMD_INSERT);
/*
* Check any RLS WITH CHECK policies.
*
* Normally we should check INSERT policies. But if the insert is the
* result of a partition key update that moved the tuple to a new
* partition, we should instead check UPDATE policies, because we are
* executing policies defined on the target table, and not those
* defined on the child partitions.
*/
wco_kind = (mtstate->operation == CMD_UPDATE) ?
WCO_RLS_UPDATE_CHECK : WCO_RLS_INSERT_CHECK;
/*
* ExecWithCheckOptions() will skip any WCOs which are not of the kind
* we are looking for at this point.
*/
if (resultRelInfo->ri_WithCheckOptions != NIL)
ExecWithCheckOptions(wco_kind, resultRelInfo, slot, estate);
/*
* Check the constraints of the tuple.
*/
if (resultRelationDesc->rd_att->constr)
ExecConstraints(resultRelInfo, slot, estate);
/*
* Also check the tuple against the partition constraint, if there is
* one; except that if we got here via tuple-routing, we don't need to
* if there's no BR trigger defined on the partition.
*/
if (resultRelationDesc->rd_rel->relispartition &&
(resultRelInfo->ri_RootResultRelInfo == NULL ||
(resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_insert_before_row)))
ExecPartitionCheck(resultRelInfo, slot, estate, true);
if (onconflict != ONCONFLICT_NONE && resultRelInfo->ri_NumIndices > 0)
{
/* Perform a speculative insertion. */
uint32 specToken;
ItemPointerData conflictTid;
bool specConflict;
List *arbiterIndexes;
arbiterIndexes = resultRelInfo->ri_onConflictArbiterIndexes;
/*
* Do a non-conclusive check for conflicts first.
*
* We're not holding any locks yet, so this doesn't guarantee that
* the later insert won't conflict. But it avoids leaving behind
* a lot of canceled speculative insertions, if you run a lot of
* INSERT ON CONFLICT statements that do conflict.
*
* We loop back here if we find a conflict below, either during
* the pre-check, or when we re-check after inserting the tuple
* speculatively. Better allow interrupts in case some bug makes
* this an infinite loop.
*/
vlock:
CHECK_FOR_INTERRUPTS();
specConflict = false;
if (!ExecCheckIndexConstraints(resultRelInfo, slot, estate,
&conflictTid, arbiterIndexes))
{
/* committed conflict tuple found */
if (onconflict == ONCONFLICT_UPDATE)
{
/*
* In case of ON CONFLICT DO UPDATE, execute the UPDATE
* part. Be prepared to retry if the UPDATE fails because
* of another concurrent UPDATE/DELETE to the conflict
* tuple.
*/
TupleTableSlot *returning = NULL;
if (ExecOnConflictUpdate(mtstate, resultRelInfo,
&conflictTid, planSlot, slot,
estate, canSetTag, &returning))
{
InstrCountTuples2(&mtstate->ps, 1);
return returning;
}
else
goto vlock;
}
else
{
/*
* In case of ON CONFLICT DO NOTHING, do nothing. However,
* verify that the tuple is visible to the executor's MVCC
* snapshot at higher isolation levels.
*
* Using ExecGetReturningSlot() to store the tuple for the
* recheck isn't that pretty, but we can't trivially use
* the input slot, because it might not be of a compatible
* type. As there's no conflicting usage of
* ExecGetReturningSlot() in the DO NOTHING case...
*/
Assert(onconflict == ONCONFLICT_NOTHING);
ExecCheckTIDVisible(estate, resultRelInfo, &conflictTid,
ExecGetReturningSlot(estate, resultRelInfo));
InstrCountTuples2(&mtstate->ps, 1);
return NULL;
}
}
/*
* Before we start insertion proper, acquire our "speculative
* insertion lock". Others can use that to wait for us to decide
* if we're going to go ahead with the insertion, instead of
* waiting for the whole transaction to complete.
*/
specToken = SpeculativeInsertionLockAcquire(GetCurrentTransactionId());
/* insert the tuple, with the speculative token */
table_tuple_insert_speculative(resultRelationDesc, slot,
estate->es_output_cid,
0,
NULL,
specToken);
/* insert index entries for tuple */
recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
slot, estate, false, true,
&specConflict,
arbiterIndexes);
/* adjust the tuple's state accordingly */
table_tuple_complete_speculative(resultRelationDesc, slot,
specToken, !specConflict);
/*
* Wake up anyone waiting for our decision. They will re-check
* the tuple, see that it's no longer speculative, and wait on our
* XID as if this was a regularly inserted tuple all along. Or if
* we killed the tuple, they will see it's dead, and proceed as if
* the tuple never existed.
*/
SpeculativeInsertionLockRelease(GetCurrentTransactionId());
/*
* If there was a conflict, start from the beginning. We'll do
* the pre-check again, which will now find the conflicting tuple
* (unless it aborts before we get there).
*/
if (specConflict)
{
list_free(recheckIndexes);
goto vlock;
}
/* Since there was no insertion conflict, we're done */
}
else
{
/* insert the tuple normally */
table_tuple_insert(resultRelationDesc, slot,
estate->es_output_cid,
0, NULL);
/* insert index entries for tuple */
if (resultRelInfo->ri_NumIndices > 0)
recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
slot, estate, false,
false, NULL, NIL);
}
}
if (canSetTag)
(estate->es_processed)++;
/*
* If this insert is the result of a partition key update that moved the
* tuple to a new partition, put this row into the transition NEW TABLE,
* if there is one. We need to do this separately for DELETE and INSERT
* because they happen on different tables.
*/
ar_insert_trig_tcs = mtstate->mt_transition_capture;
if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture
&& mtstate->mt_transition_capture->tcs_update_new_table)
{
ExecARUpdateTriggers(estate, resultRelInfo, NULL,
NULL,
slot,
NULL,
mtstate->mt_transition_capture);
/*
* We've already captured the NEW TABLE row, so make sure any AR
* INSERT trigger fired below doesn't capture it again.
*/
ar_insert_trig_tcs = NULL;
}
/* AFTER ROW INSERT Triggers */
ExecARInsertTriggers(estate, resultRelInfo, slot, recheckIndexes,
ar_insert_trig_tcs);
list_free(recheckIndexes);
/*
* Check any WITH CHECK OPTION constraints from parent views. We are
* required to do this after testing all constraints and uniqueness
* violations per the SQL spec, so we do it after actually inserting the
* record into the heap and all indexes.
*
* ExecWithCheckOptions will elog(ERROR) if a violation is found, so the
* tuple will never be seen, if it violates the WITH CHECK OPTION.
*
* ExecWithCheckOptions() will skip any WCOs which are not of the kind we
* are looking for at this point.
*/
if (resultRelInfo->ri_WithCheckOptions != NIL)
ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate);
/* Process RETURNING if present */
if (resultRelInfo->ri_projectReturning)
result = ExecProcessReturning(resultRelInfo, slot, planSlot);
return result;
}
/* your_sha256_hash
* ExecBatchInsert
*
* Insert multiple tuples in an efficient way.
* Currently, this handles inserting into a foreign table without
* RETURNING clause.
* your_sha256_hash
*/
static void
ExecBatchInsert(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
TupleTableSlot **slots,
TupleTableSlot **planSlots,
int numSlots,
EState *estate,
bool canSetTag)
{
int i;
int numInserted = numSlots;
TupleTableSlot *slot = NULL;
TupleTableSlot **rslots;
/*
* insert into foreign table: let the FDW do it
*/
rslots = resultRelInfo->ri_FdwRoutine->ExecForeignBatchInsert(estate,
resultRelInfo,
slots,
planSlots,
&numInserted);
for (i = 0; i < numInserted; i++)
{
slot = rslots[i];
/*
* AFTER ROW Triggers or RETURNING expressions might reference the
* tableoid column, so (re-)initialize tts_tableOid before evaluating
* them.
*/
slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
/* AFTER ROW INSERT Triggers */
ExecARInsertTriggers(estate, resultRelInfo, slot, NIL,
mtstate->mt_transition_capture);
/*
* Check any WITH CHECK OPTION constraints from parent views. See the
* comment in ExecInsert.
*/
if (resultRelInfo->ri_WithCheckOptions != NIL)
ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate);
}
if (canSetTag && numInserted > 0)
estate->es_processed += numInserted;
}
/* your_sha256_hash
* ExecDelete
*
* DELETE is like UPDATE, except that we delete the tuple and no
* index modifications are needed.
*
* When deleting from a table, tupleid identifies the tuple to
* delete and oldtuple is NULL. When deleting from a view,
* oldtuple is passed to the INSTEAD OF triggers and identifies
* what to delete, and tupleid is invalid. When deleting from a
* foreign table, tupleid is invalid; the FDW has to figure out
* which row to delete using data from the planSlot. oldtuple is
* passed to foreign table triggers; it is NULL when the foreign
* table has no relevant triggers. We use tupleDeleted to indicate
* whether the tuple is actually deleted, callers can use it to
* decide whether to continue the operation. When this DELETE is a
* part of an UPDATE of partition-key, then the slot returned by
* EvalPlanQual() is passed back using output parameter epqslot.
*
* Returns RETURNING result if any, otherwise NULL.
* your_sha256_hash
*/
static TupleTableSlot *
ExecDelete(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
ItemPointer tupleid,
HeapTuple oldtuple,
TupleTableSlot *planSlot,
EPQState *epqstate,
EState *estate,
bool processReturning,
bool canSetTag,
bool changingPart,
bool *tupleDeleted,
TupleTableSlot **epqreturnslot)
{
Relation resultRelationDesc = resultRelInfo->ri_RelationDesc;
TM_Result result;
TM_FailureData tmfd;
TupleTableSlot *slot = NULL;
TransitionCaptureState *ar_delete_trig_tcs;
if (tupleDeleted)
*tupleDeleted = false;
/* BEFORE ROW DELETE Triggers */
if (resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_delete_before_row)
{
bool dodelete;
dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
tupleid, oldtuple, epqreturnslot);
if (!dodelete) /* "do nothing" */
return NULL;
}
/* INSTEAD OF ROW DELETE Triggers */
if (resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_delete_instead_row)
{
bool dodelete;
Assert(oldtuple != NULL);
dodelete = ExecIRDeleteTriggers(estate, resultRelInfo, oldtuple);
if (!dodelete) /* "do nothing" */
return NULL;
}
else if (resultRelInfo->ri_FdwRoutine)
{
/*
* delete from foreign table: let the FDW do it
*
* We offer the returning slot as a place to store RETURNING data,
* although the FDW can return some other slot if it wants.
*/
slot = ExecGetReturningSlot(estate, resultRelInfo);
slot = resultRelInfo->ri_FdwRoutine->ExecForeignDelete(estate,
resultRelInfo,
slot,
planSlot);
if (slot == NULL) /* "do nothing" */
return NULL;
/*
* RETURNING expressions might reference the tableoid column, so
* (re)initialize tts_tableOid before evaluating them.
*/
if (TTS_EMPTY(slot))
ExecStoreAllNullTuple(slot);
slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
}
else
{
/*
* delete the tuple
*
* Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check
* that the row to be deleted is visible to that snapshot, and throw a
* can't-serialize error if not. This is a special-case behavior
* needed for referential integrity updates in transaction-snapshot
* mode transactions.
*/
ldelete:;
result = table_tuple_delete(resultRelationDesc, tupleid,
estate->es_output_cid,
estate->es_snapshot,
estate->es_crosscheck_snapshot,
true /* wait for commit */ ,
&tmfd,
changingPart);
switch (result)
{
case TM_SelfModified:
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
* transaction. The former case is possible in a join DELETE
* where multiple tuples join to the same target tuple. This
* is somewhat questionable, but Postgres has always allowed
* it: we just ignore additional deletion attempts.
*
* The latter case arises if the tuple is modified by a
* command in a BEFORE trigger, or perhaps by a command in a
* volatile function used in the query. In such situations we
* should not ignore the deletion, but it is equally unsafe to
* proceed. We don't want to discard the original DELETE
* while keeping the triggered actions based on its deletion;
* and it would be no better to allow the original DELETE
* while discarding updates that it triggered. The row update
* carries some information that might be important according
* to business rules; so throwing an error is the only safe
* course.
*
* If a trigger actually intends this type of interaction, it
* can re-execute the DELETE and then return NULL to cancel
* the outer delete.
*/
if (tmfd.cmax != estate->es_output_cid)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
errmsg("tuple to be deleted was already modified by an operation triggered by the current command"),
errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
/* Else, already deleted by self; nothing to do */
return NULL;
case TM_Ok:
break;
case TM_Updated:
{
TupleTableSlot *inputslot;
TupleTableSlot *epqslot;
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
/*
* Already know that we're going to need to do EPQ, so
* fetch tuple directly into the right slot.
*/
EvalPlanQualBegin(epqstate);
inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc,
resultRelInfo->ri_RangeTableIndex);
result = table_tuple_lock(resultRelationDesc, tupleid,
estate->es_snapshot,
inputslot, estate->es_output_cid,
LockTupleExclusive, LockWaitBlock,
TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
&tmfd);
switch (result)
{
case TM_Ok:
Assert(tmfd.traversed);
epqslot = EvalPlanQual(epqstate,
resultRelationDesc,
resultRelInfo->ri_RangeTableIndex,
inputslot);
if (TupIsNull(epqslot))
/* Tuple not passing quals anymore, exiting... */
return NULL;
/*
* If requested, skip delete and pass back the
* updated row.
*/
if (epqreturnslot)
{
*epqreturnslot = epqslot;
return NULL;
}
else
goto ldelete;
case TM_SelfModified:
/*
* This can be reached when following an update
* chain from a tuple updated by another session,
* reaching a tuple that was already updated in
* this transaction. If previously updated by this
* command, ignore the delete, otherwise error
* out.
*
* See also TM_SelfModified response to
* table_tuple_delete() above.
*/
if (tmfd.cmax != estate->es_output_cid)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
errmsg("tuple to be deleted was already modified by an operation triggered by the current command"),
errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
return NULL;
case TM_Deleted:
/* tuple already deleted; nothing to do */
return NULL;
default:
/*
* TM_Invisible should be impossible because we're
* waiting for updated row versions, and would
* already have errored out if the first version
* is invisible.
*
* TM_Updated should be impossible, because we're
* locking the latest version via
* TUPLE_LOCK_FLAG_FIND_LAST_VERSION.
*/
elog(ERROR, "unexpected table_tuple_lock status: %u",
result);
return NULL;
}
Assert(false);
break;
}
case TM_Deleted:
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent delete")));
/* tuple already deleted; nothing to do */
return NULL;
default:
elog(ERROR, "unrecognized table_tuple_delete status: %u",
result);
return NULL;
}
/*
* Note: Normally one would think that we have to delete index tuples
* associated with the heap tuple now...
*
* ... but in POSTGRES, we have no need to do this because VACUUM will
* take care of it later. We can't delete index tuples immediately
* anyway, since the tuple is still visible to other transactions.
*/
}
if (canSetTag)
(estate->es_processed)++;
/* Tell caller that the delete actually happened. */
if (tupleDeleted)
*tupleDeleted = true;
/*
* If this delete is the result of a partition key update that moved the
* tuple to a new partition, put this row into the transition OLD TABLE,
* if there is one. We need to do this separately for DELETE and INSERT
* because they happen on different tables.
*/
ar_delete_trig_tcs = mtstate->mt_transition_capture;
if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture
&& mtstate->mt_transition_capture->tcs_update_old_table)
{
ExecARUpdateTriggers(estate, resultRelInfo,
tupleid,
oldtuple,
NULL,
NULL,
mtstate->mt_transition_capture);
/*
* We've already captured the OLD TABLE row, so make sure any AR
* DELETE trigger fired below doesn't capture it again.
*/
ar_delete_trig_tcs = NULL;
}
/* AFTER ROW DELETE Triggers */
ExecARDeleteTriggers(estate, resultRelInfo, tupleid, oldtuple,
ar_delete_trig_tcs);
/* Process RETURNING if present and if requested */
if (processReturning && resultRelInfo->ri_projectReturning)
{
/*
* We have to put the target tuple into a slot, which means first we
* gotta fetch it. We can use the trigger tuple slot.
*/
TupleTableSlot *rslot;
if (resultRelInfo->ri_FdwRoutine)
{
/* FDW must have provided a slot containing the deleted row */
Assert(!TupIsNull(slot));
}
else
{
slot = ExecGetReturningSlot(estate, resultRelInfo);
if (oldtuple != NULL)
{
ExecForceStoreHeapTuple(oldtuple, slot, false);
}
else
{
if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid,
SnapshotAny, slot))
elog(ERROR, "failed to fetch deleted tuple for DELETE RETURNING");
}
}
rslot = ExecProcessReturning(resultRelInfo, slot, planSlot);
/*
* Before releasing the target tuple again, make sure rslot has a
* local copy of any pass-by-reference values.
*/
ExecMaterializeSlot(rslot);
ExecClearTuple(slot);
return rslot;
}
return NULL;
}
/*
* ExecCrossPartitionUpdate --- Move an updated tuple to another partition.
*
* This works by first deleting the old tuple from the current partition,
* followed by inserting the new tuple into the root parent table, that is,
* mtstate->rootResultRelInfo. It will be re-routed from there to the
* correct partition.
*
* Returns true if the tuple has been successfully moved, or if it's found
* that the tuple was concurrently deleted so there's nothing more to do
* for the caller.
*
* False is returned if the tuple we're trying to move is found to have been
* concurrently updated. In that case, the caller must to check if the
* updated tuple that's returned in *retry_slot still needs to be re-routed,
* and call this function again or perform a regular update accordingly.
*/
static bool
ExecCrossPartitionUpdate(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
ItemPointer tupleid, HeapTuple oldtuple,
TupleTableSlot *slot, TupleTableSlot *planSlot,
EPQState *epqstate, bool canSetTag,
TupleTableSlot **retry_slot,
TupleTableSlot **inserted_tuple)
{
EState *estate = mtstate->ps.state;
TupleConversionMap *tupconv_map;
bool tuple_deleted;
TupleTableSlot *epqslot = NULL;
*inserted_tuple = NULL;
*retry_slot = NULL;
/*
* Disallow an INSERT ON CONFLICT DO UPDATE that causes the original row
* to migrate to a different partition. Maybe this can be implemented
* some day, but it seems a fringe feature with little redeeming value.
*/
if (((ModifyTable *) mtstate->ps.plan)->onConflictAction == ONCONFLICT_UPDATE)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("invalid ON UPDATE specification"),
errdetail("The result tuple would appear in a different partition than the original tuple.")));
/*
* When an UPDATE is run directly on a leaf partition, simply fail with a
* partition constraint violation error.
*/
if (resultRelInfo == mtstate->rootResultRelInfo)
ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
/* Initialize tuple routing info if not already done. */
if (mtstate->mt_partition_tuple_routing == NULL)
{
Relation rootRel = mtstate->rootResultRelInfo->ri_RelationDesc;
MemoryContext oldcxt;
/* Things built here have to last for the query duration. */
oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
mtstate->mt_partition_tuple_routing =
ExecSetupPartitionTupleRouting(estate, rootRel);
/*
* Before a partition's tuple can be re-routed, it must first be
* converted to the root's format, so we'll need a slot for storing
* such tuples.
*/
Assert(mtstate->mt_root_tuple_slot == NULL);
mtstate->mt_root_tuple_slot = table_slot_create(rootRel, NULL);
MemoryContextSwitchTo(oldcxt);
}
/*
* Row movement, part 1. Delete the tuple, but skip RETURNING processing.
* We want to return rows from INSERT.
*/
ExecDelete(mtstate, resultRelInfo, tupleid, oldtuple, planSlot,
epqstate, estate,
false, /* processReturning */
false, /* canSetTag */
true, /* changingPart */
&tuple_deleted, &epqslot);
/*
* For some reason if DELETE didn't happen (e.g. trigger prevented it, or
* it was already deleted by self, or it was concurrently deleted by
* another transaction), then we should skip the insert as well;
* otherwise, an UPDATE could cause an increase in the total number of
* rows across all partitions, which is clearly wrong.
*
* For a normal UPDATE, the case where the tuple has been the subject of a
* concurrent UPDATE or DELETE would be handled by the EvalPlanQual
* machinery, but for an UPDATE that we've translated into a DELETE from
* this partition and an INSERT into some other partition, that's not
* available, because CTID chains can't span relation boundaries. We
* mimic the semantics to a limited extent by skipping the INSERT if the
* DELETE fails to find a tuple. This ensures that two concurrent
* attempts to UPDATE the same tuple at the same time can't turn one tuple
* into two, and that an UPDATE of a just-deleted tuple can't resurrect
* it.
*/
if (!tuple_deleted)
{
/*
* epqslot will be typically NULL. But when ExecDelete() finds that
* another transaction has concurrently updated the same row, it
* re-fetches the row, skips the delete, and epqslot is set to the
* re-fetched tuple slot. In that case, we need to do all the checks
* again.
*/
if (TupIsNull(epqslot))
return true;
else
{
/* Fetch the most recent version of old tuple. */
TupleTableSlot *oldSlot;
/* ... but first, make sure ri_oldTupleSlot is initialized. */
if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
ExecInitUpdateProjection(mtstate, resultRelInfo);
oldSlot = resultRelInfo->ri_oldTupleSlot;
if (!table_tuple_fetch_row_version(resultRelInfo->ri_RelationDesc,
tupleid,
SnapshotAny,
oldSlot))
elog(ERROR, "failed to fetch tuple being updated");
*retry_slot = ExecGetUpdateNewTuple(resultRelInfo, epqslot,
oldSlot);
return false;
}
}
/*
* resultRelInfo is one of the per-relation resultRelInfos. So we should
* convert the tuple into root's tuple descriptor if needed, since
* ExecInsert() starts the search from root.
*/
tupconv_map = ExecGetChildToRootMap(resultRelInfo);
if (tupconv_map != NULL)
slot = execute_attr_map_slot(tupconv_map->attrMap,
slot,
mtstate->mt_root_tuple_slot);
/* Tuple routing starts from the root table. */
*inserted_tuple = ExecInsert(mtstate, mtstate->rootResultRelInfo, slot,
planSlot, estate, canSetTag);
/*
* Reset the transition state that may possibly have been written by
* INSERT.
*/
if (mtstate->mt_transition_capture)
mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
/* We're done moving. */
return true;
}
/* your_sha256_hash
* ExecUpdate
*
* note: we can't run UPDATE queries with transactions
* off because UPDATEs are actually INSERTs and our
* scan will mistakenly loop forever, updating the tuple
* it just inserted.. This should be fixed but until it
* is, we don't want to get stuck in an infinite loop
* which corrupts your database..
*
* When updating a table, tupleid identifies the tuple to
* update and oldtuple is NULL. When updating a view, oldtuple
* is passed to the INSTEAD OF triggers and identifies what to
* update, and tupleid is invalid. When updating a foreign table,
* tupleid is invalid; the FDW has to figure out which row to
* update using data from the planSlot. oldtuple is passed to
* foreign table triggers; it is NULL when the foreign table has
* no relevant triggers.
*
* slot contains the new tuple value to be stored.
* planSlot is the output of the ModifyTable's subplan; we use it
* to access values from other input tables (for RETURNING),
* row-ID junk columns, etc.
*
* Returns RETURNING result if any, otherwise NULL.
* your_sha256_hash
*/
static TupleTableSlot *
ExecUpdate(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
ItemPointer tupleid,
HeapTuple oldtuple,
TupleTableSlot *slot,
TupleTableSlot *planSlot,
EPQState *epqstate,
EState *estate,
bool canSetTag)
{
Relation resultRelationDesc = resultRelInfo->ri_RelationDesc;
TM_Result result;
TM_FailureData tmfd;
List *recheckIndexes = NIL;
/*
* abort the operation if not running transactions
*/
if (IsBootstrapProcessingMode())
elog(ERROR, "cannot UPDATE during bootstrap");
ExecMaterializeSlot(slot);
/*
* Open the table's indexes, if we have not done so already, so that we
* can add new index entries for the updated tuple.
*/
if (resultRelationDesc->rd_rel->relhasindex &&
resultRelInfo->ri_IndexRelationDescs == NULL)
ExecOpenIndices(resultRelInfo, false);
/* BEFORE ROW UPDATE Triggers */
if (resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_update_before_row)
{
if (!ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
tupleid, oldtuple, slot))
return NULL; /* "do nothing" */
}
/* INSTEAD OF ROW UPDATE Triggers */
if (resultRelInfo->ri_TrigDesc &&
resultRelInfo->ri_TrigDesc->trig_update_instead_row)
{
if (!ExecIRUpdateTriggers(estate, resultRelInfo,
oldtuple, slot))
return NULL; /* "do nothing" */
}
else if (resultRelInfo->ri_FdwRoutine)
{
/*
* GENERATED expressions might reference the tableoid column, so
* (re-)initialize tts_tableOid before evaluating them.
*/
slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
/*
* Compute stored generated columns
*/
if (resultRelationDesc->rd_att->constr &&
resultRelationDesc->rd_att->constr->has_generated_stored)
ExecComputeStoredGenerated(resultRelInfo, estate, slot,
CMD_UPDATE);
/*
* update in foreign table: let the FDW do it
*/
slot = resultRelInfo->ri_FdwRoutine->ExecForeignUpdate(estate,
resultRelInfo,
slot,
planSlot);
if (slot == NULL) /* "do nothing" */
return NULL;
/*
* AFTER ROW Triggers or RETURNING expressions might reference the
* tableoid column, so (re-)initialize tts_tableOid before evaluating
* them. (This covers the case where the FDW replaced the slot.)
*/
slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
}
else
{
LockTupleMode lockmode;
bool partition_constraint_failed;
bool update_indexes;
/*
* Constraints and GENERATED expressions might reference the tableoid
* column, so (re-)initialize tts_tableOid before evaluating them.
*/
slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
/*
* Compute stored generated columns
*/
if (resultRelationDesc->rd_att->constr &&
resultRelationDesc->rd_att->constr->has_generated_stored)
ExecComputeStoredGenerated(resultRelInfo, estate, slot,
CMD_UPDATE);
/*
* Check any RLS UPDATE WITH CHECK policies
*
* If we generate a new candidate tuple after EvalPlanQual testing, we
* must loop back here and recheck any RLS policies and constraints.
* (We don't need to redo triggers, however. If there are any BEFORE
* triggers then trigger.c will have done table_tuple_lock to lock the
* correct tuple, so there's no need to do them again.)
*/
lreplace:;
/* ensure slot is independent, consider e.g. EPQ */
ExecMaterializeSlot(slot);
/*
* If partition constraint fails, this row might get moved to another
* partition, in which case we should check the RLS CHECK policy just
* before inserting into the new partition, rather than doing it here.
* This is because a trigger on that partition might again change the
* row. So skip the WCO checks if the partition constraint fails.
*/
partition_constraint_failed =
resultRelationDesc->rd_rel->relispartition &&
!ExecPartitionCheck(resultRelInfo, slot, estate, false);
if (!partition_constraint_failed &&
resultRelInfo->ri_WithCheckOptions != NIL)
{
/*
* ExecWithCheckOptions() will skip any WCOs which are not of the
* kind we are looking for at this point.
*/
ExecWithCheckOptions(WCO_RLS_UPDATE_CHECK,
resultRelInfo, slot, estate);
}
/*
* If a partition check failed, try to move the row into the right
* partition.
*/
if (partition_constraint_failed)
{
TupleTableSlot *inserted_tuple,
*retry_slot;
bool retry;
/*
* ExecCrossPartitionUpdate will first DELETE the row from the
* partition it's currently in and then insert it back into the
* root table, which will re-route it to the correct partition.
* The first part may have to be repeated if it is detected that
* the tuple we're trying to move has been concurrently updated.
*/
retry = !ExecCrossPartitionUpdate(mtstate, resultRelInfo, tupleid,
oldtuple, slot, planSlot,
epqstate, canSetTag,
&retry_slot, &inserted_tuple);
if (retry)
{
slot = retry_slot;
goto lreplace;
}
return inserted_tuple;
}
/*
* Check the constraints of the tuple. We've already checked the
* partition constraint above; however, we must still ensure the tuple
* passes all other constraints, so we will call ExecConstraints() and
* have it validate all remaining checks.
*/
if (resultRelationDesc->rd_att->constr)
ExecConstraints(resultRelInfo, slot, estate);
/*
* replace the heap tuple
*
* Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check
* that the row to be updated is visible to that snapshot, and throw a
* can't-serialize error if not. This is a special-case behavior
* needed for referential integrity updates in transaction-snapshot
* mode transactions.
*/
result = table_tuple_update(resultRelationDesc, tupleid, slot,
estate->es_output_cid,
estate->es_snapshot,
estate->es_crosscheck_snapshot,
true /* wait for commit */ ,
&tmfd, &lockmode, &update_indexes);
switch (result)
{
case TM_SelfModified:
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
* transaction. The former case is possible in a join UPDATE
* where multiple tuples join to the same target tuple. This
* is pretty questionable, but Postgres has always allowed it:
* we just execute the first update action and ignore
* additional update attempts.
*
* The latter case arises if the tuple is modified by a
* command in a BEFORE trigger, or perhaps by a command in a
* volatile function used in the query. In such situations we
* should not ignore the update, but it is equally unsafe to
* proceed. We don't want to discard the original UPDATE
* while keeping the triggered actions based on it; and we
* have no principled way to merge this update with the
* previous ones. So throwing an error is the only safe
* course.
*
* If a trigger actually intends this type of interaction, it
* can re-execute the UPDATE (assuming it can figure out how)
* and then return NULL to cancel the outer update.
*/
if (tmfd.cmax != estate->es_output_cid)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
/* Else, already updated by self; nothing to do */
return NULL;
case TM_Ok:
break;
case TM_Updated:
{
TupleTableSlot *inputslot;
TupleTableSlot *epqslot;
TupleTableSlot *oldSlot;
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
/*
* Already know that we're going to need to do EPQ, so
* fetch tuple directly into the right slot.
*/
inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc,
resultRelInfo->ri_RangeTableIndex);
result = table_tuple_lock(resultRelationDesc, tupleid,
estate->es_snapshot,
inputslot, estate->es_output_cid,
lockmode, LockWaitBlock,
TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
&tmfd);
switch (result)
{
case TM_Ok:
Assert(tmfd.traversed);
epqslot = EvalPlanQual(epqstate,
resultRelationDesc,
resultRelInfo->ri_RangeTableIndex,
inputslot);
if (TupIsNull(epqslot))
/* Tuple not passing quals anymore, exiting... */
return NULL;
/* Make sure ri_oldTupleSlot is initialized. */
if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
ExecInitUpdateProjection(mtstate, resultRelInfo);
/* Fetch the most recent version of old tuple. */
oldSlot = resultRelInfo->ri_oldTupleSlot;
if (!table_tuple_fetch_row_version(resultRelationDesc,
tupleid,
SnapshotAny,
oldSlot))
elog(ERROR, "failed to fetch tuple being updated");
slot = ExecGetUpdateNewTuple(resultRelInfo,
epqslot, oldSlot);
goto lreplace;
case TM_Deleted:
/* tuple already deleted; nothing to do */
return NULL;
case TM_SelfModified:
/*
* This can be reached when following an update
* chain from a tuple updated by another session,
* reaching a tuple that was already updated in
* this transaction. If previously modified by
* this command, ignore the redundant update,
* otherwise error out.
*
* See also TM_SelfModified response to
* table_tuple_update() above.
*/
if (tmfd.cmax != estate->es_output_cid)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
return NULL;
default:
/* see table_tuple_lock call in ExecDelete() */
elog(ERROR, "unexpected table_tuple_lock status: %u",
result);
return NULL;
}
}
break;
case TM_Deleted:
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent delete")));
/* tuple already deleted; nothing to do */
return NULL;
default:
elog(ERROR, "unrecognized table_tuple_update status: %u",
result);
return NULL;
}
/* insert index entries for tuple if necessary */
if (resultRelInfo->ri_NumIndices > 0 && update_indexes)
recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
slot, estate, true, false,
NULL, NIL);
}
if (canSetTag)
(estate->es_processed)++;
/* AFTER ROW UPDATE Triggers */
ExecARUpdateTriggers(estate, resultRelInfo, tupleid, oldtuple, slot,
recheckIndexes,
mtstate->operation == CMD_INSERT ?
mtstate->mt_oc_transition_capture :
mtstate->mt_transition_capture);
list_free(recheckIndexes);
/*
* Check any WITH CHECK OPTION constraints from parent views. We are
* required to do this after testing all constraints and uniqueness
* violations per the SQL spec, so we do it after actually updating the
* record in the heap and all indexes.
*
* ExecWithCheckOptions() will skip any WCOs which are not of the kind we
* are looking for at this point.
*/
if (resultRelInfo->ri_WithCheckOptions != NIL)
ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate);
/* Process RETURNING if present */
if (resultRelInfo->ri_projectReturning)
return ExecProcessReturning(resultRelInfo, slot, planSlot);
return NULL;
}
/*
* ExecOnConflictUpdate --- execute UPDATE of INSERT ON CONFLICT DO UPDATE
*
* Try to lock tuple for update as part of speculative insertion. If
* a qual originating from ON CONFLICT DO UPDATE is satisfied, update
* (but still lock row, even though it may not satisfy estate's
* snapshot).
*
* Returns true if we're done (with or without an update), or false if
* the caller must retry the INSERT from scratch.
*/
static bool
ExecOnConflictUpdate(ModifyTableState *mtstate,
ResultRelInfo *resultRelInfo,
ItemPointer conflictTid,
TupleTableSlot *planSlot,
TupleTableSlot *excludedSlot,
EState *estate,
bool canSetTag,
TupleTableSlot **returning)
{
ExprContext *econtext = mtstate->ps.ps_ExprContext;
Relation relation = resultRelInfo->ri_RelationDesc;
ExprState *onConflictSetWhere = resultRelInfo->ri_onConflict->oc_WhereClause;
TupleTableSlot *existing = resultRelInfo->ri_onConflict->oc_Existing;
TM_FailureData tmfd;
LockTupleMode lockmode;
TM_Result test;
Datum xminDatum;
TransactionId xmin;
bool isnull;
/* Determine lock mode to use */
lockmode = ExecUpdateLockMode(estate, resultRelInfo);
/*
* Lock tuple for update. Don't follow updates when tuple cannot be
* locked without doing so. A row locking conflict here means our
* previous conclusion that the tuple is conclusively committed is not
* true anymore.
*/
test = table_tuple_lock(relation, conflictTid,
estate->es_snapshot,
existing, estate->es_output_cid,
lockmode, LockWaitBlock, 0,
&tmfd);
switch (test)
{
case TM_Ok:
/* success! */
break;
case TM_Invisible:
/*
* This can occur when a just inserted tuple is updated again in
* the same command. E.g. because multiple rows with the same
* conflicting key values are inserted.
*
* This is somewhat similar to the ExecUpdate() TM_SelfModified
* case. We do not want to proceed because it would lead to the
* same row being updated a second time in some unspecified order,
* and in contrast to plain UPDATEs there's no historical behavior
* to break.
*
* It is the user's responsibility to prevent this situation from
* occurring. These problems are why SQL-2003 similarly specifies
* that for SQL MERGE, an exception must be raised in the event of
* an attempt to update the same row twice.
*/
xminDatum = slot_getsysattr(existing,
MinTransactionIdAttributeNumber,
&isnull);
Assert(!isnull);
xmin = DatumGetTransactionId(xminDatum);
if (TransactionIdIsCurrentTransactionId(xmin))
ereport(ERROR,
(errcode(ERRCODE_CARDINALITY_VIOLATION),
errmsg("ON CONFLICT DO UPDATE command cannot affect row a second time"),
errhint("Ensure that no rows proposed for insertion within the same command have duplicate constrained values.")));
/* This shouldn't happen */
elog(ERROR, "attempted to lock invisible tuple");
break;
case TM_SelfModified:
/*
* This state should never be reached. As a dirty snapshot is used
* to find conflicting tuples, speculative insertion wouldn't have
* seen this row to conflict with.
*/
elog(ERROR, "unexpected self-updated tuple");
break;
case TM_Updated:
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
/*
* As long as we don't support an UPDATE of INSERT ON CONFLICT for
* a partitioned table we shouldn't reach to a case where tuple to
* be lock is moved to another partition due to concurrent update
* of the partition key.
*/
Assert(!ItemPointerIndicatesMovedPartitions(&tmfd.ctid));
/*
* Tell caller to try again from the very start.
*
* It does not make sense to use the usual EvalPlanQual() style
* loop here, as the new version of the row might not conflict
* anymore, or the conflicting tuple has actually been deleted.
*/
ExecClearTuple(existing);
return false;
case TM_Deleted:
if (IsolationUsesXactSnapshot())
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent delete")));
/* see TM_Updated case */
Assert(!ItemPointerIndicatesMovedPartitions(&tmfd.ctid));
ExecClearTuple(existing);
return false;
default:
elog(ERROR, "unrecognized table_tuple_lock status: %u", test);
}
/* Success, the tuple is locked. */
/*
* Verify that the tuple is visible to our MVCC snapshot if the current
* isolation level mandates that.
*
* It's not sufficient to rely on the check within ExecUpdate() as e.g.
* CONFLICT ... WHERE clause may prevent us from reaching that.
*
* This means we only ever continue when a new command in the current
* transaction could see the row, even though in READ COMMITTED mode the
* tuple will not be visible according to the current statement's
* snapshot. This is in line with the way UPDATE deals with newer tuple
* versions.
*/
ExecCheckTupleVisible(estate, relation, existing);
/*
* Make tuple and any needed join variables available to ExecQual and
* ExecProject. The EXCLUDED tuple is installed in ecxt_innertuple, while
* the target's existing tuple is installed in the scantuple. EXCLUDED
* has been made to reference INNER_VAR in setrefs.c, but there is no
* other redirection.
*/
econtext->ecxt_scantuple = existing;
econtext->ecxt_innertuple = excludedSlot;
econtext->ecxt_outertuple = NULL;
if (!ExecQual(onConflictSetWhere, econtext))
{
ExecClearTuple(existing); /* see return below */
InstrCountFiltered1(&mtstate->ps, 1);
return true; /* done with the tuple */
}
if (resultRelInfo->ri_WithCheckOptions != NIL)
{
/*
* Check target's existing tuple against UPDATE-applicable USING
* security barrier quals (if any), enforced here as RLS checks/WCOs.
*
* The rewriter creates UPDATE RLS checks/WCOs for UPDATE security
* quals, and stores them as WCOs of "kind" WCO_RLS_CONFLICT_CHECK,
* but that's almost the extent of its special handling for ON
* CONFLICT DO UPDATE.
*
* The rewriter will also have associated UPDATE applicable straight
* RLS checks/WCOs for the benefit of the ExecUpdate() call that
* follows. INSERTs and UPDATEs naturally have mutually exclusive WCO
* kinds, so there is no danger of spurious over-enforcement in the
* INSERT or UPDATE path.
*/
ExecWithCheckOptions(WCO_RLS_CONFLICT_CHECK, resultRelInfo,
existing,
mtstate->ps.state);
}
/* Project the new tuple version */
ExecProject(resultRelInfo->ri_onConflict->oc_ProjInfo);
/*
* Note that it is possible that the target tuple has been modified in
* this session, after the above table_tuple_lock. We choose to not error
* out in that case, in line with ExecUpdate's treatment of similar cases.
* This can happen if an UPDATE is triggered from within ExecQual(),
* ExecWithCheckOptions() or ExecProject() above, e.g. by selecting from a
* wCTE in the ON CONFLICT's SET.
*/
/* Execute UPDATE with projection */
*returning = ExecUpdate(mtstate, resultRelInfo, conflictTid, NULL,
resultRelInfo->ri_onConflict->oc_ProjSlot,
planSlot,
&mtstate->mt_epqstate, mtstate->ps.state,
canSetTag);
/*
* Clear out existing tuple, as there might not be another conflict among
* the next input rows. Don't want to hold resources till the end of the
* query.
*/
ExecClearTuple(existing);
return true;
}
/*
* Process BEFORE EACH STATEMENT triggers
*/
static void
fireBSTriggers(ModifyTableState *node)
{
ModifyTable *plan = (ModifyTable *) node->ps.plan;
ResultRelInfo *resultRelInfo = node->rootResultRelInfo;
switch (node->operation)
{
case CMD_INSERT:
ExecBSInsertTriggers(node->ps.state, resultRelInfo);
if (plan->onConflictAction == ONCONFLICT_UPDATE)
ExecBSUpdateTriggers(node->ps.state,
resultRelInfo);
break;
case CMD_UPDATE:
ExecBSUpdateTriggers(node->ps.state, resultRelInfo);
break;
case CMD_DELETE:
ExecBSDeleteTriggers(node->ps.state, resultRelInfo);
break;
default:
elog(ERROR, "unknown operation");
break;
}
}
/*
* Process AFTER EACH STATEMENT triggers
*/
static void
fireASTriggers(ModifyTableState *node)
{
ModifyTable *plan = (ModifyTable *) node->ps.plan;
ResultRelInfo *resultRelInfo = node->rootResultRelInfo;
switch (node->operation)
{
case CMD_INSERT:
if (plan->onConflictAction == ONCONFLICT_UPDATE)
ExecASUpdateTriggers(node->ps.state,
resultRelInfo,
node->mt_oc_transition_capture);
ExecASInsertTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
break;
case CMD_UPDATE:
ExecASUpdateTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
break;
case CMD_DELETE:
ExecASDeleteTriggers(node->ps.state, resultRelInfo,
node->mt_transition_capture);
break;
default:
elog(ERROR, "unknown operation");
break;
}
}
/*
* Set up the state needed for collecting transition tuples for AFTER
* triggers.
*/
static void
ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
{
ModifyTable *plan = (ModifyTable *) mtstate->ps.plan;
ResultRelInfo *targetRelInfo = mtstate->rootResultRelInfo;
/* Check for transition tables on the directly targeted relation. */
mtstate->mt_transition_capture =
MakeTransitionCaptureState(targetRelInfo->ri_TrigDesc,
RelationGetRelid(targetRelInfo->ri_RelationDesc),
mtstate->operation);
if (plan->operation == CMD_INSERT &&
plan->onConflictAction == ONCONFLICT_UPDATE)
mtstate->mt_oc_transition_capture =
MakeTransitionCaptureState(targetRelInfo->ri_TrigDesc,
RelationGetRelid(targetRelInfo->ri_RelationDesc),
CMD_UPDATE);
}
/*
* ExecPrepareTupleRouting --- prepare for routing one tuple
*
* Determine the partition in which the tuple in slot is to be inserted,
* and return its ResultRelInfo in *partRelInfo. The return value is
* a slot holding the tuple of the partition rowtype.
*
* This also sets the transition table information in mtstate based on the
* selected partition.
*/
static TupleTableSlot *
ExecPrepareTupleRouting(ModifyTableState *mtstate,
EState *estate,
PartitionTupleRouting *proute,
ResultRelInfo *targetRelInfo,
TupleTableSlot *slot,
ResultRelInfo **partRelInfo)
{
ResultRelInfo *partrel;
TupleConversionMap *map;
/*
* Lookup the target partition's ResultRelInfo. If ExecFindPartition does
* not find a valid partition for the tuple in 'slot' then an error is
* raised. An error may also be raised if the found partition is not a
* valid target for INSERTs. This is required since a partitioned table
* UPDATE to another partition becomes a DELETE+INSERT.
*/
partrel = ExecFindPartition(mtstate, targetRelInfo, proute, slot, estate);
/*
* If we're capturing transition tuples, we might need to convert from the
* partition rowtype to root partitioned table's rowtype. But if there
* are no BEFORE triggers on the partition that could change the tuple, we
* can just remember the original unconverted tuple to avoid a needless
* round trip conversion.
*/
if (mtstate->mt_transition_capture != NULL)
{
bool has_before_insert_row_trig;
has_before_insert_row_trig = (partrel->ri_TrigDesc &&
partrel->ri_TrigDesc->trig_insert_before_row);
mtstate->mt_transition_capture->tcs_original_insert_tuple =
!has_before_insert_row_trig ? slot : NULL;
}
/*
* Convert the tuple, if necessary.
*/
map = partrel->ri_RootToPartitionMap;
if (map != NULL)
{
TupleTableSlot *new_slot = partrel->ri_PartitionTupleSlot;
slot = execute_attr_map_slot(map->attrMap, slot, new_slot);
}
*partRelInfo = partrel;
return slot;
}
/* your_sha256_hash
* ExecModifyTable
*
* Perform table modifications as required, and return RETURNING results
* if needed.
* your_sha256_hash
*/
static TupleTableSlot *
ExecModifyTable(PlanState *pstate)
{
ModifyTableState *node = castNode(ModifyTableState, pstate);
EState *estate = node->ps.state;
CmdType operation = node->operation;
ResultRelInfo *resultRelInfo;
PlanState *subplanstate;
TupleTableSlot *slot;
TupleTableSlot *planSlot;
TupleTableSlot *oldSlot;
ItemPointer tupleid;
ItemPointerData tuple_ctid;
HeapTupleData oldtupdata;
HeapTuple oldtuple;
PartitionTupleRouting *proute = node->mt_partition_tuple_routing;
List *relinfos = NIL;
ListCell *lc;
CHECK_FOR_INTERRUPTS();
/*
* This should NOT get called during EvalPlanQual; we should have passed a
* subplan tree to EvalPlanQual, instead. Use a runtime test not just
* Assert because this condition is easy to miss in testing. (Note:
* although ModifyTable should not get executed within an EvalPlanQual
* operation, we do have to allow it to be initialized and shut down in
* case it is within a CTE subplan. Hence this test must be here, not in
* ExecInitModifyTable.)
*/
if (estate->es_epq_active != NULL)
elog(ERROR, "ModifyTable should not be called during EvalPlanQual");
/*
* If we've already completed processing, don't try to do more. We need
* this test because ExecPostprocessPlan might call us an extra time, and
* our subplan's nodes aren't necessarily robust against being called
* extra times.
*/
if (node->mt_done)
return NULL;
/*
* On first call, fire BEFORE STATEMENT triggers before proceeding.
*/
if (node->fireBSTriggers)
{
fireBSTriggers(node);
node->fireBSTriggers = false;
}
/* Preload local variables */
resultRelInfo = node->resultRelInfo + node->mt_lastResultIndex;
subplanstate = outerPlanState(node);
/*
* Fetch rows from subplan, and execute the required table modification
* for each row.
*/
for (;;)
{
/*
* Reset the per-output-tuple exprcontext. This is needed because
* triggers expect to use that context as workspace. It's a bit ugly
* to do this below the top level of the plan, however. We might need
* to rethink this later.
*/
ResetPerTupleExprContext(estate);
/*
* Reset per-tuple memory context used for processing on conflict and
* returning clauses, to free any expression evaluation storage
* allocated in the previous cycle.
*/
if (pstate->ps_ExprContext)
ResetExprContext(pstate->ps_ExprContext);
planSlot = ExecProcNode(subplanstate);
/* No more tuples to process? */
if (TupIsNull(planSlot))
break;
/*
* When there are multiple result relations, each tuple contains a
* junk column that gives the OID of the rel from which it came.
* Extract it and select the correct result relation.
*/
if (AttributeNumberIsValid(node->mt_resultOidAttno))
{
Datum datum;
bool isNull;
Oid resultoid;
datum = ExecGetJunkAttribute(planSlot, node->mt_resultOidAttno,
&isNull);
if (isNull)
elog(ERROR, "tableoid is NULL");
resultoid = DatumGetObjectId(datum);
/* If it's not the same as last time, we need to locate the rel */
if (resultoid != node->mt_lastResultOid)
resultRelInfo = ExecLookupResultRelByOid(node, resultoid,
false, true);
}
/*
* If resultRelInfo->ri_usesFdwDirectModify is true, all we need to do
* here is compute the RETURNING expressions.
*/
if (resultRelInfo->ri_usesFdwDirectModify)
{
Assert(resultRelInfo->ri_projectReturning);
/*
* A scan slot containing the data that was actually inserted,
* updated or deleted has already been made available to
* ExecProcessReturning by IterateDirectModify, so no need to
* provide it here.
*/
slot = ExecProcessReturning(resultRelInfo, NULL, planSlot);
return slot;
}
EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
slot = planSlot;
tupleid = NULL;
oldtuple = NULL;
/*
* For UPDATE/DELETE, fetch the row identity info for the tuple to be
* updated/deleted. For a heap relation, that's a TID; otherwise we
* may have a wholerow junk attr that carries the old tuple in toto.
* Keep this in step with the part of ExecInitModifyTable that sets up
* ri_RowIdAttNo.
*/
if (operation == CMD_UPDATE || operation == CMD_DELETE)
{
char relkind;
Datum datum;
bool isNull;
relkind = resultRelInfo->ri_RelationDesc->rd_rel->relkind;
if (relkind == RELKIND_RELATION ||
relkind == RELKIND_MATVIEW ||
relkind == RELKIND_PARTITIONED_TABLE)
{
/* ri_RowIdAttNo refers to a ctid attribute */
Assert(AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo));
datum = ExecGetJunkAttribute(slot,
resultRelInfo->ri_RowIdAttNo,
&isNull);
/* shouldn't ever get a null result... */
if (isNull)
elog(ERROR, "ctid is NULL");
tupleid = (ItemPointer) DatumGetPointer(datum);
tuple_ctid = *tupleid; /* be sure we don't free ctid!! */
tupleid = &tuple_ctid;
}
/*
* Use the wholerow attribute, when available, to reconstruct the
* old relation tuple. The old tuple serves one or both of two
* purposes: 1) it serves as the OLD tuple for row triggers, 2) it
* provides values for any unchanged columns for the NEW tuple of
* an UPDATE, because the subplan does not produce all the columns
* of the target table.
*
* Note that the wholerow attribute does not carry system columns,
* so foreign table triggers miss seeing those, except that we
* know enough here to set t_tableOid. Quite separately from
* this, the FDW may fetch its own junk attrs to identify the row.
*
* Other relevant relkinds, currently limited to views, always
* have a wholerow attribute.
*/
else if (AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
{
datum = ExecGetJunkAttribute(slot,
resultRelInfo->ri_RowIdAttNo,
&isNull);
/* shouldn't ever get a null result... */
if (isNull)
elog(ERROR, "wholerow is NULL");
oldtupdata.t_data = DatumGetHeapTupleHeader(datum);
oldtupdata.t_len =
HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
ItemPointerSetInvalid(&(oldtupdata.t_self));
/* Historically, view triggers see invalid t_tableOid. */
oldtupdata.t_tableOid =
(relkind == RELKIND_VIEW) ? InvalidOid :
RelationGetRelid(resultRelInfo->ri_RelationDesc);
oldtuple = &oldtupdata;
}
else
{
/* Only foreign tables are allowed to omit a row-ID attr */
Assert(relkind == RELKIND_FOREIGN_TABLE);
}
}
switch (operation)
{
case CMD_INSERT:
/* Initialize projection info if first time for this table */
if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
ExecInitInsertProjection(node, resultRelInfo);
slot = ExecGetInsertNewTuple(resultRelInfo, planSlot);
slot = ExecInsert(node, resultRelInfo, slot, planSlot,
estate, node->canSetTag);
break;
case CMD_UPDATE:
/* Initialize projection info if first time for this table */
if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
ExecInitUpdateProjection(node, resultRelInfo);
/*
* Make the new tuple by combining plan's output tuple with
* the old tuple being updated.
*/
oldSlot = resultRelInfo->ri_oldTupleSlot;
if (oldtuple != NULL)
{
/* Use the wholerow junk attr as the old tuple. */
ExecForceStoreHeapTuple(oldtuple, oldSlot, false);
}
else
{
/* Fetch the most recent version of old tuple. */
Relation relation = resultRelInfo->ri_RelationDesc;
Assert(tupleid != NULL);
if (!table_tuple_fetch_row_version(relation, tupleid,
SnapshotAny,
oldSlot))
elog(ERROR, "failed to fetch tuple being updated");
}
slot = ExecGetUpdateNewTuple(resultRelInfo, planSlot,
oldSlot);
/* Now apply the update. */
slot = ExecUpdate(node, resultRelInfo, tupleid, oldtuple, slot,
planSlot, &node->mt_epqstate, estate,
node->canSetTag);
break;
case CMD_DELETE:
slot = ExecDelete(node, resultRelInfo, tupleid, oldtuple,
planSlot, &node->mt_epqstate, estate,
true, /* processReturning */
node->canSetTag,
false, /* changingPart */
NULL, NULL);
break;
default:
elog(ERROR, "unknown operation");
break;
}
/*
* If we got a RETURNING result, return it to caller. We'll continue
* the work on next call.
*/
if (slot)
return slot;
}
/*
* Insert remaining tuples for batch insert.
*/
if (proute)
relinfos = estate->es_tuple_routing_result_relations;
else
relinfos = estate->es_opened_result_relations;
foreach(lc, relinfos)
{
resultRelInfo = lfirst(lc);
if (resultRelInfo->ri_NumSlots > 0)
ExecBatchInsert(node, resultRelInfo,
resultRelInfo->ri_Slots,
resultRelInfo->ri_PlanSlots,
resultRelInfo->ri_NumSlots,
estate, node->canSetTag);
}
/*
* We're done, but fire AFTER STATEMENT triggers before exiting.
*/
fireASTriggers(node);
node->mt_done = true;
return NULL;
}
/*
* ExecLookupResultRelByOid
* If the table with given OID is among the result relations to be
* updated by the given ModifyTable node, return its ResultRelInfo.
*
* If not found, return NULL if missing_ok, else raise error.
*
* If update_cache is true, then upon successful lookup, update the node's
* one-element cache. ONLY ExecModifyTable may pass true for this.
*/
ResultRelInfo *
ExecLookupResultRelByOid(ModifyTableState *node, Oid resultoid,
bool missing_ok, bool update_cache)
{
if (node->mt_resultOidHash)
{
/* Use the pre-built hash table to locate the rel */
MTTargetRelLookup *mtlookup;
mtlookup = (MTTargetRelLookup *)
hash_search(node->mt_resultOidHash, &resultoid, HASH_FIND, NULL);
if (mtlookup)
{
if (update_cache)
{
node->mt_lastResultOid = resultoid;
node->mt_lastResultIndex = mtlookup->relationIndex;
}
return node->resultRelInfo + mtlookup->relationIndex;
}
}
else
{
/* With few target rels, just search the ResultRelInfo array */
for (int ndx = 0; ndx < node->mt_nrels; ndx++)
{
ResultRelInfo *rInfo = node->resultRelInfo + ndx;
if (RelationGetRelid(rInfo->ri_RelationDesc) == resultoid)
{
if (update_cache)
{
node->mt_lastResultOid = resultoid;
node->mt_lastResultIndex = ndx;
}
return rInfo;
}
}
}
if (!missing_ok)
elog(ERROR, "incorrect result relation OID %u", resultoid);
return NULL;
}
/* your_sha256_hash
* ExecInitModifyTable
* your_sha256_hash
*/
ModifyTableState *
ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
{
ModifyTableState *mtstate;
Plan *subplan = outerPlan(node);
CmdType operation = node->operation;
int nrels = list_length(node->resultRelations);
ResultRelInfo *resultRelInfo;
List *arowmarks;
ListCell *l;
int i;
Relation rel;
/* check for unsupported flags */
Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
/*
* create state structure
*/
mtstate = makeNode(ModifyTableState);
mtstate->ps.plan = (Plan *) node;
mtstate->ps.state = estate;
mtstate->ps.ExecProcNode = ExecModifyTable;
mtstate->operation = operation;
mtstate->canSetTag = node->canSetTag;
mtstate->mt_done = false;
mtstate->mt_nrels = nrels;
mtstate->resultRelInfo = (ResultRelInfo *)
palloc(nrels * sizeof(ResultRelInfo));
/*----------
* Resolve the target relation. This is the same as:
*
* - the relation for which we will fire FOR STATEMENT triggers,
* - the relation into whose tuple format all captured transition tuples
* must be converted, and
* - the root partitioned table used for tuple routing.
*
* If it's a partitioned table, the root partition doesn't appear
* elsewhere in the plan and its RT index is given explicitly in
* node->rootRelation. Otherwise (i.e. table inheritance) the target
* relation is the first relation in the node->resultRelations list.
*----------
*/
if (node->rootRelation > 0)
{
mtstate->rootResultRelInfo = makeNode(ResultRelInfo);
ExecInitResultRelation(estate, mtstate->rootResultRelInfo,
node->rootRelation);
}
else
{
mtstate->rootResultRelInfo = mtstate->resultRelInfo;
ExecInitResultRelation(estate, mtstate->resultRelInfo,
linitial_int(node->resultRelations));
}
/* set up epqstate with dummy subplan data for the moment */
EvalPlanQualInit(&mtstate->mt_epqstate, estate, NULL, NIL, node->epqParam);
mtstate->fireBSTriggers = true;
/*
* Build state for collecting transition tuples. This requires having a
* valid trigger query context, so skip it in explain-only mode.
*/
if (!(eflags & EXEC_FLAG_EXPLAIN_ONLY))
ExecSetupTransitionCaptureState(mtstate, estate);
/*
* Open all the result relations and initialize the ResultRelInfo structs.
* (But root relation was initialized above, if it's part of the array.)
* We must do this before initializing the subplan, because direct-modify
* FDWs expect their ResultRelInfos to be available.
*/
resultRelInfo = mtstate->resultRelInfo;
i = 0;
foreach(l, node->resultRelations)
{
Index resultRelation = lfirst_int(l);
if (resultRelInfo != mtstate->rootResultRelInfo)
{
ExecInitResultRelation(estate, resultRelInfo, resultRelation);
/*
* For child result relations, store the root result relation
* pointer. We do so for the convenience of places that want to
* look at the query's original target relation but don't have the
* mtstate handy.
*/
resultRelInfo->ri_RootResultRelInfo = mtstate->rootResultRelInfo;
}
/* Initialize the usesFdwDirectModify flag */
resultRelInfo->ri_usesFdwDirectModify = bms_is_member(i,
node->fdwDirectModifyPlans);
/*
* Verify result relation is a valid target for the current operation
*/
CheckValidResultRel(resultRelInfo, operation);
resultRelInfo++;
i++;
}
/*
* Now we may initialize the subplan.
*/
outerPlanState(mtstate) = ExecInitNode(subplan, estate, eflags);
/*
* Do additional per-result-relation initialization.
*/
for (i = 0; i < nrels; i++)
{
resultRelInfo = &mtstate->resultRelInfo[i];
/* Let FDWs init themselves for foreign-table result rels */
if (!resultRelInfo->ri_usesFdwDirectModify &&
resultRelInfo->ri_FdwRoutine != NULL &&
resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
{
List *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
resultRelInfo->ri_FdwRoutine->BeginForeignModify(mtstate,
resultRelInfo,
fdw_private,
i,
eflags);
}
/*
* For UPDATE/DELETE, find the appropriate junk attr now, either a
* 'ctid' or 'wholerow' attribute depending on relkind. For foreign
* tables, the FDW might have created additional junk attr(s), but
* those are no concern of ours.
*/
if (operation == CMD_UPDATE || operation == CMD_DELETE)
{
char relkind;
relkind = resultRelInfo->ri_RelationDesc->rd_rel->relkind;
if (relkind == RELKIND_RELATION ||
relkind == RELKIND_MATVIEW ||
relkind == RELKIND_PARTITIONED_TABLE)
{
resultRelInfo->ri_RowIdAttNo =
ExecFindJunkAttributeInTlist(subplan->targetlist, "ctid");
if (!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
elog(ERROR, "could not find junk ctid column");
}
else if (relkind == RELKIND_FOREIGN_TABLE)
{
/*
* When there is a row-level trigger, there should be a
* wholerow attribute. We also require it to be present in
* UPDATE, so we can get the values of unchanged columns.
*/
resultRelInfo->ri_RowIdAttNo =
ExecFindJunkAttributeInTlist(subplan->targetlist,
"wholerow");
if (mtstate->operation == CMD_UPDATE &&
!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
elog(ERROR, "could not find junk wholerow column");
}
else
{
/* Other valid target relkinds must provide wholerow */
resultRelInfo->ri_RowIdAttNo =
ExecFindJunkAttributeInTlist(subplan->targetlist,
"wholerow");
if (!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
elog(ERROR, "could not find junk wholerow column");
}
}
}
/*
* If this is an inherited update/delete, there will be a junk attribute
* named "tableoid" present in the subplan's targetlist. It will be used
* to identify the result relation for a given tuple to be
* updated/deleted.
*/
mtstate->mt_resultOidAttno =
ExecFindJunkAttributeInTlist(subplan->targetlist, "tableoid");
Assert(AttributeNumberIsValid(mtstate->mt_resultOidAttno) || nrels == 1);
mtstate->mt_lastResultOid = InvalidOid; /* force lookup at first tuple */
mtstate->mt_lastResultIndex = 0; /* must be zero if no such attr */
/* Get the root target relation */
rel = mtstate->rootResultRelInfo->ri_RelationDesc;
/*
* Build state for tuple routing if it's a partitioned INSERT. An UPDATE
* might need this too, but only if it actually moves tuples between
* partitions; in that case setup is done by ExecCrossPartitionUpdate.
*/
if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
operation == CMD_INSERT)
mtstate->mt_partition_tuple_routing =
ExecSetupPartitionTupleRouting(estate, rel);
/*
* Initialize any WITH CHECK OPTION constraints if needed.
*/
resultRelInfo = mtstate->resultRelInfo;
foreach(l, node->withCheckOptionLists)
{
List *wcoList = (List *) lfirst(l);
List *wcoExprs = NIL;
ListCell *ll;
foreach(ll, wcoList)
{
WithCheckOption *wco = (WithCheckOption *) lfirst(ll);
ExprState *wcoExpr = ExecInitQual((List *) wco->qual,
&mtstate->ps);
wcoExprs = lappend(wcoExprs, wcoExpr);
}
resultRelInfo->ri_WithCheckOptions = wcoList;
resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
resultRelInfo++;
}
/*
* Initialize RETURNING projections if needed.
*/
if (node->returningLists)
{
TupleTableSlot *slot;
ExprContext *econtext;
/*
* Initialize result tuple slot and assign its rowtype using the first
* RETURNING list. We assume the rest will look the same.
*/
mtstate->ps.plan->targetlist = (List *) linitial(node->returningLists);
/* Set up a slot for the output of the RETURNING projection(s) */
ExecInitResultTupleSlotTL(&mtstate->ps, &TTSOpsVirtual);
slot = mtstate->ps.ps_ResultTupleSlot;
/* Need an econtext too */
if (mtstate->ps.ps_ExprContext == NULL)
ExecAssignExprContext(estate, &mtstate->ps);
econtext = mtstate->ps.ps_ExprContext;
/*
* Build a projection for each result rel.
*/
resultRelInfo = mtstate->resultRelInfo;
foreach(l, node->returningLists)
{
List *rlist = (List *) lfirst(l);
resultRelInfo->ri_returningList = rlist;
resultRelInfo->ri_projectReturning =
ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
resultRelInfo->ri_RelationDesc->rd_att);
resultRelInfo++;
}
}
else
{
/*
* We still must construct a dummy result tuple type, because InitPlan
* expects one (maybe should change that?).
*/
mtstate->ps.plan->targetlist = NIL;
ExecInitResultTypeTL(&mtstate->ps);
mtstate->ps.ps_ExprContext = NULL;
}
/* Set the list of arbiter indexes if needed for ON CONFLICT */
resultRelInfo = mtstate->resultRelInfo;
if (node->onConflictAction != ONCONFLICT_NONE)
{
/* insert may only have one relation, inheritance is not expanded */
Assert(nrels == 1);
resultRelInfo->ri_onConflictArbiterIndexes = node->arbiterIndexes;
}
/*
* If needed, Initialize target list, projection and qual for ON CONFLICT
* DO UPDATE.
*/
if (node->onConflictAction == ONCONFLICT_UPDATE)
{
OnConflictSetState *onconfl = makeNode(OnConflictSetState);
ExprContext *econtext;
TupleDesc relationDesc;
/* already exists if created by RETURNING processing above */
if (mtstate->ps.ps_ExprContext == NULL)
ExecAssignExprContext(estate, &mtstate->ps);
econtext = mtstate->ps.ps_ExprContext;
relationDesc = resultRelInfo->ri_RelationDesc->rd_att;
/* create state for DO UPDATE SET operation */
resultRelInfo->ri_onConflict = onconfl;
/* initialize slot for the existing tuple */
onconfl->oc_Existing =
table_slot_create(resultRelInfo->ri_RelationDesc,
&mtstate->ps.state->es_tupleTable);
/*
* Create the tuple slot for the UPDATE SET projection. We want a slot
* of the table's type here, because the slot will be used to insert
* into the table, and for RETURNING processing - which may access
* system attributes.
*/
onconfl->oc_ProjSlot =
table_slot_create(resultRelInfo->ri_RelationDesc,
&mtstate->ps.state->es_tupleTable);
/* build UPDATE SET projection state */
onconfl->oc_ProjInfo =
ExecBuildUpdateProjection(node->onConflictSet,
true,
node->onConflictCols,
relationDesc,
econtext,
onconfl->oc_ProjSlot,
&mtstate->ps);
/* initialize state to evaluate the WHERE clause, if any */
if (node->onConflictWhere)
{
ExprState *qualexpr;
qualexpr = ExecInitQual((List *) node->onConflictWhere,
&mtstate->ps);
onconfl->oc_WhereClause = qualexpr;
}
}
/*
* If we have any secondary relations in an UPDATE or DELETE, they need to
* be treated like non-locked relations in SELECT FOR UPDATE, ie, the
* EvalPlanQual mechanism needs to be told about them. Locate the
* relevant ExecRowMarks.
*/
arowmarks = NIL;
foreach(l, node->rowMarks)
{
PlanRowMark *rc = lfirst_node(PlanRowMark, l);
ExecRowMark *erm;
ExecAuxRowMark *aerm;
/* ignore "parent" rowmarks; they are irrelevant at runtime */
if (rc->isParent)
continue;
/* Find ExecRowMark and build ExecAuxRowMark */
erm = ExecFindRowMark(estate, rc->rti, false);
aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
arowmarks = lappend(arowmarks, aerm);
}
EvalPlanQualSetPlan(&mtstate->mt_epqstate, subplan, arowmarks);
/*
* If there are a lot of result relations, use a hash table to speed the
* lookups. If there are not a lot, a simple linear search is faster.
*
* It's not clear where the threshold is, but try 64 for starters. In a
* debugging build, use a small threshold so that we get some test
* coverage of both code paths.
*/
#ifdef USE_ASSERT_CHECKING
#define MT_NRELS_HASH 4
#else
#define MT_NRELS_HASH 64
#endif
if (nrels >= MT_NRELS_HASH)
{
HASHCTL hash_ctl;
hash_ctl.keysize = sizeof(Oid);
hash_ctl.entrysize = sizeof(MTTargetRelLookup);
hash_ctl.hcxt = CurrentMemoryContext;
mtstate->mt_resultOidHash =
hash_create("ModifyTable target hash",
nrels, &hash_ctl,
HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
for (i = 0; i < nrels; i++)
{
Oid hashkey;
MTTargetRelLookup *mtlookup;
bool found;
resultRelInfo = &mtstate->resultRelInfo[i];
hashkey = RelationGetRelid(resultRelInfo->ri_RelationDesc);
mtlookup = (MTTargetRelLookup *)
hash_search(mtstate->mt_resultOidHash, &hashkey,
HASH_ENTER, &found);
Assert(!found);
mtlookup->relationIndex = i;
}
}
else
mtstate->mt_resultOidHash = NULL;
/*
* Determine if the FDW supports batch insert and determine the batch size
* (a FDW may support batching, but it may be disabled for the
* server/table).
*
* We only do this for INSERT, so that for UPDATE/DELETE the batch size
* remains set to 0.
*/
if (operation == CMD_INSERT)
{
/* insert may only have one relation, inheritance is not expanded */
Assert(nrels == 1);
resultRelInfo = mtstate->resultRelInfo;
if (!resultRelInfo->ri_usesFdwDirectModify &&
resultRelInfo->ri_FdwRoutine != NULL &&
resultRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize &&
resultRelInfo->ri_FdwRoutine->ExecForeignBatchInsert)
{
resultRelInfo->ri_BatchSize =
resultRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize(resultRelInfo);
Assert(resultRelInfo->ri_BatchSize >= 1);
}
else
resultRelInfo->ri_BatchSize = 1;
}
/*
* Lastly, if this is not the primary (canSetTag) ModifyTable node, add it
* to estate->es_auxmodifytables so that it will be run to completion by
* ExecPostprocessPlan. (It'd actually work fine to add the primary
* ModifyTable node too, but there's no need.) Note the use of lcons not
* lappend: we need later-initialized ModifyTable nodes to be shut down
* before earlier ones. This ensures that we don't throw away RETURNING
* rows that need to be seen by a later CTE subplan.
*/
if (!mtstate->canSetTag)
estate->es_auxmodifytables = lcons(mtstate,
estate->es_auxmodifytables);
return mtstate;
}
/* your_sha256_hash
* ExecEndModifyTable
*
* Shuts down the plan.
*
* Returns nothing of interest.
* your_sha256_hash
*/
void
ExecEndModifyTable(ModifyTableState *node)
{
int i;
/*
* Allow any FDWs to shut down
*/
for (i = 0; i < node->mt_nrels; i++)
{
int j;
ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
if (!resultRelInfo->ri_usesFdwDirectModify &&
resultRelInfo->ri_FdwRoutine != NULL &&
resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
resultRelInfo);
/*
* Cleanup the initialized batch slots. This only matters for FDWs
* with batching, but the other cases will have ri_NumSlotsInitialized
* == 0.
*/
for (j = 0; j < resultRelInfo->ri_NumSlotsInitialized; j++)
{
ExecDropSingleTupleTableSlot(resultRelInfo->ri_Slots[j]);
ExecDropSingleTupleTableSlot(resultRelInfo->ri_PlanSlots[j]);
}
}
/*
* Close all the partitioned tables, leaf partitions, and their indices
* and release the slot used for tuple routing, if set.
*/
if (node->mt_partition_tuple_routing)
{
ExecCleanupTupleRouting(node, node->mt_partition_tuple_routing);
if (node->mt_root_tuple_slot)
ExecDropSingleTupleTableSlot(node->mt_root_tuple_slot);
}
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ps);
/*
* clean out the tuple table
*/
if (node->ps.ps_ResultTupleSlot)
ExecClearTuple(node->ps.ps_ResultTupleSlot);
/*
* Terminate EPQ execution if active
*/
EvalPlanQualEnd(&node->mt_epqstate);
/*
* shut down subplan
*/
ExecEndNode(outerPlanState(node));
}
void
ExecReScanModifyTable(ModifyTableState *node)
{
/*
* Currently, we don't need to support rescan on ModifyTable nodes. The
* semantics of that would be a bit debatable anyway.
*/
elog(ERROR, "ExecReScanModifyTable is not implemented");
}
```
|
```verilog
Inductive Hello := World | Bye.
```
|
```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 com.example.android.todolist;
import android.content.Intent;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.DividerItemDecoration;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.helper.ItemTouchHelper;
import android.view.View;
import static android.support.v7.widget.DividerItemDecoration.VERTICAL;
public class MainActivity extends AppCompatActivity implements TaskAdapter.ItemClickListener {
// Constant for logging
private static final String TAG = MainActivity.class.getSimpleName();
// Member variables for the adapter and RecyclerView
private RecyclerView mRecyclerView;
private TaskAdapter mAdapter;
// TODO (1) Create AppDatabase member variable for the Database
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Set the RecyclerView to its corresponding view
mRecyclerView = findViewById(R.id.recyclerViewTasks);
// Set the layout for the RecyclerView to be a linear layout, which measures and
// positions items within a RecyclerView into a linear list
mRecyclerView.setLayoutManager(new LinearLayoutManager(this));
// Initialize the adapter and attach it to the RecyclerView
mAdapter = new TaskAdapter(this, this);
mRecyclerView.setAdapter(mAdapter);
DividerItemDecoration decoration = new DividerItemDecoration(getApplicationContext(), VERTICAL);
mRecyclerView.addItemDecoration(decoration);
/*
Add a touch helper to the RecyclerView to recognize when a user swipes to delete an item.
An ItemTouchHelper enables touch behavior (like swipe and move) on each ViewHolder,
and uses callbacks to signal when a user is performing these actions.
*/
new ItemTouchHelper(new ItemTouchHelper.SimpleCallback(0, ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT) {
@Override
public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) {
return false;
}
// Called when a user swipes left or right on a ViewHolder
@Override
public void onSwiped(RecyclerView.ViewHolder viewHolder, int swipeDir) {
// Here is where you'll implement swipe to delete
}
}).attachToRecyclerView(mRecyclerView);
/*
Set the Floating Action Button (FAB) to its corresponding View.
Attach an OnClickListener to it, so that when it's clicked, a new intent will be created
to launch the AddTaskActivity.
*/
FloatingActionButton fabButton = findViewById(R.id.fab);
fabButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
// Create a new intent to start an AddTaskActivity
Intent addTaskIntent = new Intent(MainActivity.this, AddTaskActivity.class);
startActivity(addTaskIntent);
}
});
// TODO (2) Initialize member variable for the data base
}
/**
* This method is called after this activity has been paused or restarted.
* Often, this is after new data has been inserted through an AddTaskActivity,
* so this re-queries the database data for any changes.
*/
@Override
protected void onResume() {
super.onResume();
// TODO (3) Call the adapter's setTasks method using the result
// of the loadAllTasks method from the taskDao
}
@Override
public void onItemClickListener(int itemId) {
// Launch AddTaskActivity adding the itemId as an extra in the intent
}
}
```
|
Dragoneye or 'DragonEye may refer to:
The Dragoneye expansion set for Dungeons & Dragons Miniatures Game
The DragonEye equipment on the ISS for docking of the SpaceX Dragon capsule
|
Juncus kraussii commonly known as salt marsh rush, sea rush, jointed rush, matting rush or dune slack rush, is of the monocot family Juncaceae and genus Juncus. It grows in salt marshes, estuarine and coastal areas.
This species is ideal as a stabiliser in estuary banks and riparian zones that adjoin developed areas; it prevents erosion and also provides an excellent fibre for weaving.
The plant is named after a German naturalist and museum curator, Christian Krauss, who travelled to South Africa.
Description
This species is a tussock shaped perennial with many rhizomes.
The leaves are tough, straw shaped and spine-tipped that grow to be - in length with a golden brown or shiny black sheath. The inflorescences or flowers of J. kraussii are reddish brown to purplish brown in colour, - in length and are clustered toward the end of the stem. The flowers occur clusters of three to six and flowering occurs in Summer between October and January.
Distribution and habitat
The species occurs in all states of Australia, New Zealand Southern Africa and South America.
Juncus kraussii is salt tolerant and favours a damp environment and is most often found in areas such as swamps and brackish estuaries. The plant is able to grow in a range of soils from sands to alluvium.
Uses
Juncus kraussii is harvested and weaved to produce traditional sleeping mats, baskets, beer strainers, and other craftwork items in many Zulu areas of South Africa. The plant is in great demand because of its economic value and has been extensively harvested in the wild. It is now cultivated in many areas and is harvested yearly for a period of seven years in total.
The stems and leaves of Juncus kraussii were used by Indigenous Australians for fibre, for string, fishing lines, woven rugs and woven baskets. It is commonly used today for stabilisation of the banks of estuaries, around salt marshes and riparian zones next to sites developed for human use. It is also used in biofiltration systems and rain gardens.
References
kraussii
Plants described in 1845
Flora of Australia
Flora of Southern Africa
Flora of Southern America
Taxa named by Christian Ferdinand Friedrich Hochstetter
|
Glyphipterix astrapaea is a species of sedge moth in the genus Glyphipterix. It was described by Edward Meyrick in 1880. It is found in New Zealand.
References
Moths described in 1880
Glyphipterigidae
Moths of New Zealand
|
Sphegina hamulata is a species of hoverfly in the family Syrphidae.
Distribution
India.
References
Brachyopini
Insects described in 2018
Diptera of Asia
|
Classic epidemic models of disease transmission are described in Compartmental models in epidemiology. Here we discuss the behavior when such models are simulated on a lattice. Lattice models, which were first explored in the context of cellular automata, act as good first approximations of more complex spatial configurations, although they do not reflect the heterogeneity of space (e.g. population density differences, urban geography and topographical differentiations). Lattice-based epidemic models can also be implemented as fixed agent-based models.
Introduction
The mathematical modelling of epidemics was originally implemented in terms of differential equations, which effectively assumed that the various states of individuals were uniformly distributed throughout space. To take into account correlations and clustering, lattice-based models have been introduced. Grassberger
considered synchronous (cellular automaton) versions of models, and showed how the epidemic growth goes through a critical behavior such that transmission remains local when infection rates are below critical values, and spread throughout the system when they are above a critical value. Cardy and Grassberger
argued that this growth is similar to the growth of percolation clusters, which are governed by the "dynamical percolation" universality class (finished clusters are in the same class as static percolation, while growing clusters have additional dynamic exponents). In asynchronous models, the individuals are considered one at a time, as in kinetic Monte Carlo or as a "Stochastic Lattice Gas."
SIR model
In the "SIR" model, there are three states:
Susceptible (S) -- has not yet been infected, and has no immunity
Infected (I)-- currently "sick" and contagious to Susceptible neighbors
Removed (R), where the removal from further participation in the process is assumed to be permanent, due to immunization or death
It is to be distinguished from the "SIS" model, where sites recover without immunization, and are thus not "removed".
The asynchronous simulation of the model on a lattice is carried out as follows:
Pick a site. If it is I, then generate a random number x in (0,1).
If x < c then let I go to R.
Otherwise, pick one nearest neighbor randomly. If the neighboring site is S, then let it become I.
Repeat as long as there are S sites available.
Making a list of I sites makes this run quickly.
The net rate of infecting one neighbor over the rate of removal is λ = (1-c)/c.
For the synchronous model, all sites are updated simultaneously (using two copies of the lattice) as in a cellular automaton.
Contact process (asynchronous SIS model)
I → S with unit rate;
S → I with rate λnI/z where nI is the number of nearest neighbor I sites, and z is the total number of nearest neighbors (equivalently, each I attempts to infect one neighboring site with rate λ)
(Note: S → I with rate λn in some definitions, implying that lambda has one-fourth the values given here).
The simulation of the asynchronous model on a lattice is carried out as follows, with c = 1 / (1 + λ):
Pick a site. If it is I, then generate a random number x in (0,1).
If x < c then let I go to S.
Otherwise, pick one nearest neighbor randomly. If the neighboring site is S, then let it become I.
Repeat
Note that the synchronous version is related to the directed percolation model.
See also
Mathematical modelling of infectious disease
Compartmental models in epidemiology
Epidemic model
Percolation
Percolation threshold
Percolation theory
2D percolation cluster
Directed percolation
Bootstrap percolation
Biological lattice-gas cellular automaton
References
Further reading
Epidemiology
|
```xml
<ResourceDictionary xmlns="path_to_url"
xmlns:x="path_to_url"
xmlns:controls="clr-namespace:Dopamine.Controls">
<Style x:Key="{x:Type controls:TotalsInformation}" TargetType="{x:Type controls:TotalsInformation}">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="{x:Type controls:TotalsInformation}">
<DockPanel>
<TextBlock
DockPanel.Dock="Left"
Text="{TemplateBinding TotalSizeInformation}"
FontSize="{TemplateBinding FontSize}"
Foreground="{TemplateBinding Foreground}"/>
<TextBlock
DockPanel.Dock="Right"
Text="{TemplateBinding TotalDurationInformation}"
FontSize="{TemplateBinding FontSize}"
Foreground="{TemplateBinding Foreground}"/>
<ContentControl/>
</DockPanel>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
</ResourceDictionary>
```
|
Cosmic Force may refer to:
Religion and spirituality
A supreme deity in systems of thought that do not assume a personal Singular God
Unmoved mover, an Aristotelian concept
A fundamental force or energy postulated in vitalism
A term for "God" or "divinity" in panentheistic spirituality
Other uses
Power Cosmic, a concept in Marvel Comics
Cosmic Force, a 1993 album by Dennis Brown; see Heartbeat Records
The force derivable from dark energy responsible for the accelerating expansion of the universe
See also
Cosmos
Cosmogony
Cosmology
Cosmic energy (disambiguation)
|
```objective-c
#import "VerticalTranslationTransition.h"
@implementation VerticalTranslationTransition
- (CATransform3D)animateWithProgress:(CGFloat)p {
CGFloat y = [RNNInterpolator fromFloat:self.from
toFloat:self.to
precent:p
interpolator:self.interpolator];
return CATransform3DMakeTranslation(0, y, 0);
}
- (CGFloat)initialValue {
return self.view.frame.origin.y;
}
- (CGFloat)calculateFrom:(Double *)from {
return from.hasValue ? from.get : 0;
}
- (CGFloat)calculateTo:(Double *)to {
return to.hasValue ? to.get : 0;
}
@end
```
|
Panagiotis Bachramis (; 12 March 1976, in Kalamata – 13 August 2010, in Kyparissia) was a Greek professional footballer who played as midfielder. On August 13, 2010, he was killed when a speedboat struck him while he was snorkeling near the beach in Kyparissia.
Career
Born in Kalamata, Bachramis began playing football with local side Apollon Kalamata in the Fourth Division. He joined city rivals Kalamata F.C. in 1994, the club he would play for seven seasons in the First and Second Division. In 1995, Bachramis made his debut in the first division at age 19, in a 5–0 victory over AEL.
In 2001, Bachramis signed with Iraklis Thessaloniki F.C. where he played until he joined AEL in 2004. He helped AEL to gain the promotion to the First Division and win the 2007 Greek Football Cup title. Bachramis also played in the 2007-08 UEFA Cup, where AEL bowed out against Blackburn Rovers F.C. He would finish his career with Veria F.C. in the Second Division, playing a total of more than 280 competitive League, Cup and European matches for his clubs.
Bachramis played with the Greece national under-21 football team, participating in the 1998 UEFA European Under-21 Football Championship qualifying rounds in 1997. Although the team qualified for the finals, he didn't manage to play because of an injury.
Although he suffered from frequent injuries, he was a valuable player for all the teams he played for, as he was fast, calm, collective, cooperative and could play in many positions in the pitch covering any gap. It is a characteristic that Bachramis had even played as a goalkeeper(!) in a match with AE Larissa. This happened on April 12, 2006, in the Alcazar Stadium, in the rematch for the semi-finals of the Greek Cup against Olympiacos. At 90', and while all three changes have been made, the regular goalkeeper Stefanos Kotsolis withdrew injured and Bachramis took his position under the goalpost.
Statistics
Points (as of 2009): 268 matches
First Division: 162
Second Division: 69
Greek Cup: 33
Greek Super Cup: 1
Intertoto: 1
UEFA Cup: 2
Goals (as of 2009): 29
First Division: 14
Beta Ethniki: 9
Greek Cup: 6
Clubs
{| class="wikitable"
! Years
! Clubs
! Points
! Goals
|-
|1993–94
| Apollon Kalamata
| (D)
|
|-
|1994–95
| Kalamata
|14 (B) + 2 (Cup)
|0
|-
|1995–96
| Kalamata
|18 (A) + 2 (Cup)
|1 (Α) + 1 (Cup)
|-
|1996–97
| Kalamata
|17 (A) + 2 (Cup)
|2 (A)
|-
|1997–98
| Kalamata
|19 (A)
|2 (A)
|-
|1998–99
| Kalamata
|22 (B'') + 4 (Cup)
|4 (B) + 2 (Cup)
|-
|1999–2000
| Kalamata
|16 (A) + 4 (Cup)
|2 (A) + 2 (Cup)
|-
|2000–01
| Kalamata
|17 (A) + 2 (Cup)
|4 (A)
|-
|2001–02
| Iraklis
|13 (A) + 6 (Cup)
|0
|-
|2002–03
| Iraklis
|14 (A)
|0
|-
|2003–04
| Iraklis
|5 (A) + 3 (Cup)
|0 (A) + 1 (Cup)
|-
|2004–05
| AEL
|21 (B) + 3 (Cup)
|4 (B)
|-
|2005–06
| AEL
|26 (A) + 4 (Cup)
|3 (A)
|-
|2006–07
| AEL
| 6 (A) + 0 (Cup) + 1 (I)
| 0
|-
|2007–08
| AEL
| 11 (A) + 2 (Cup) +1 (SC) + 2 (UEFA)
| 0
|-
|2008–09
| Veria
|12 (B) +1 (Cup)
|1 (B)
|-
|2009–10
| Veria
|9 (C)
|1 (C)
|-
! Years
! National teams
! Points
! Goals
|-
|(;)-1995
| U–19 team
|
|
|-
|1996–1997
| U–21 team
|2
|1
|}
Abbreviations:
A or 1st: matches and goals in the First Division
B or 2nd: matches and goals in the Second Division
C or 3rd: matches and goals in the Third Division
D or 4th: matches and goals in the Fourth Division
Cup matches and goals in the Greek Cup
SC matches and goals in the Super Cup
I matches and goals in Intertoto
HonoursAEL'''
Greek Cup: 2006–07
References
External links
youtube tribute video
newsbeast
eps messinias
eleftheria online
1976 births
2010 deaths
Greek men's footballers
Kalamata F.C. players
Iraklis F.C. (Thessaloniki) players
Athlitiki Enosi Larissa F.C. players
Veria F.C. players
Super League Greece players
Footballers from Kalamata
Accidental deaths in Greece
Men's association football midfielders
|
Cocorico was a French magazine first published in 1898. It was produced by the artist Paul-Émile Boutigny and featured many artists of the Art Nouveau movement including Alphonse Mucha and Théophile Steinlen. The magazine had 63 issues.
References
External links
A collection of Alphonse Mucha's work in Cocorico
1898 establishments in France
1902 disestablishments in France
Art Nouveau magazines
Defunct magazines published in France
French art publications
French-language magazines
Magazines established in 1898
Magazines disestablished in 1902
|
```javascript
/*
* @fileoverview Main Doctrine object
* @author Yusuke Suzuki <utatane.tea@gmail.com>
* @author Dan Tao <daniel.tao@gmail.com>
* @author Andrew Eisenberg <andrew@eisenberg.as>
*/
(function () {
'use strict';
var typed,
utility,
jsdoc,
esutils,
hasOwnProperty;
esutils = require('esutils');
typed = require('./typed');
utility = require('./utility');
function sliceSource(source, index, last) {
return source.slice(index, last);
}
hasOwnProperty = (function () {
var func = Object.prototype.hasOwnProperty;
return function hasOwnProperty(obj, name) {
return func.call(obj, name);
};
}());
function shallowCopy(obj) {
var ret = {}, key;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
ret[key] = obj[key];
}
}
return ret;
}
function isASCIIAlphanumeric(ch) {
return (ch >= 0x61 /* 'a' */ && ch <= 0x7A /* 'z' */) ||
(ch >= 0x41 /* 'A' */ && ch <= 0x5A /* 'Z' */) ||
(ch >= 0x30 /* '0' */ && ch <= 0x39 /* '9' */);
}
function isParamTitle(title) {
return title === 'param' || title === 'argument' || title === 'arg';
}
function isReturnTitle(title) {
return title === 'return' || title === 'returns';
}
function isProperty(title) {
return title === 'property' || title === 'prop';
}
function isNameParameterRequired(title) {
return isParamTitle(title) || isProperty(title) ||
title === 'alias' || title === 'this' || title === 'mixes' || title === 'requires';
}
function isAllowedName(title) {
return isNameParameterRequired(title) || title === 'const' || title === 'constant';
}
function isAllowedNested(title) {
return isProperty(title) || isParamTitle(title);
}
function isAllowedOptional(title) {
return isProperty(title) || isParamTitle(title);
}
function isTypeParameterRequired(title) {
return isParamTitle(title) || isReturnTitle(title) ||
title === 'define' || title === 'enum' ||
title === 'implements' || title === 'this' ||
title === 'type' || title === 'typedef' || isProperty(title);
}
// Consider deprecation instead using 'isTypeParameterRequired' and 'Rules' declaration to pick when a type is optional/required
// This would require changes to 'parseType'
function isAllowedType(title) {
return isTypeParameterRequired(title) || title === 'throws' || title === 'const' || title === 'constant' ||
title === 'namespace' || title === 'member' || title === 'var' || title === 'module' ||
title === 'constructor' || title === 'class' || title === 'extends' || title === 'augments' ||
title === 'public' || title === 'private' || title === 'protected';
}
// A regex character class that contains all whitespace except linebreak characters (\r, \n, \u2028, \u2029)
var WHITESPACE = '[ \\f\\t\\v\\u00a0\\u1680\\u180e\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff]';
var STAR_MATCHER = '(' + WHITESPACE + '*(?:\\*' + WHITESPACE + '?)?)(.+|[\r\n\u2028\u2029])';
function unwrapComment(doc) {
// JSDoc comment is following form
// /**
// * .......
// */
return doc.
// remove /**
replace(/^\/\*\*?/, '').
// remove */
replace(/\*\/$/, '').
// remove ' * ' at the beginning of a line
replace(new RegExp(STAR_MATCHER, 'g'), '$2').
// remove trailing whitespace
replace(/\s*$/, '');
}
/**
* Converts an index in an "unwrapped" JSDoc comment to the corresponding index in the original "wrapped" version
* @param {string} originalSource The original wrapped comment
* @param {number} unwrappedIndex The index of a character in the unwrapped string
* @returns {number} The index of the corresponding character in the original wrapped string
*/
function convertUnwrappedCommentIndex(originalSource, unwrappedIndex) {
var replacedSource = originalSource.replace(/^\/\*\*?/, '');
var numSkippedChars = 0;
var matcher = new RegExp(STAR_MATCHER, 'g');
var match;
while ((match = matcher.exec(replacedSource))) {
numSkippedChars += match[1].length;
if (match.index + match[0].length > unwrappedIndex + numSkippedChars) {
return unwrappedIndex + numSkippedChars + originalSource.length - replacedSource.length;
}
}
return originalSource.replace(/\*\/$/, '').replace(/\s*$/, '').length;
}
// JSDoc Tag Parser
(function (exports) {
var Rules,
index,
lineNumber,
length,
source,
originalSource,
recoverable,
sloppy,
strict;
function advance() {
var ch = source.charCodeAt(index);
index += 1;
if (esutils.code.isLineTerminator(ch) && !(ch === 0x0D /* '\r' */ && source.charCodeAt(index) === 0x0A /* '\n' */)) {
lineNumber += 1;
}
return String.fromCharCode(ch);
}
function scanTitle() {
var title = '';
// waste '@'
advance();
while (index < length && isASCIIAlphanumeric(source.charCodeAt(index))) {
title += advance();
}
return title;
}
function seekContent() {
var ch, waiting, last = index;
waiting = false;
while (last < length) {
ch = source.charCodeAt(last);
if (esutils.code.isLineTerminator(ch) && !(ch === 0x0D /* '\r' */ && source.charCodeAt(last + 1) === 0x0A /* '\n' */)) {
waiting = true;
} else if (waiting) {
if (ch === 0x40 /* '@' */) {
break;
}
if (!esutils.code.isWhiteSpace(ch)) {
waiting = false;
}
}
last += 1;
}
return last;
}
// type expression may have nest brace, such as,
// { { ok: string } }
//
// therefore, scanning type expression with balancing braces.
function parseType(title, last, addRange) {
var ch, brace, type, startIndex, direct = false;
// search '{'
while (index < last) {
ch = source.charCodeAt(index);
if (esutils.code.isWhiteSpace(ch)) {
advance();
} else if (ch === 0x7B /* '{' */) {
advance();
break;
} else {
// this is direct pattern
direct = true;
break;
}
}
if (direct) {
return null;
}
// type expression { is found
brace = 1;
type = '';
while (index < last) {
ch = source.charCodeAt(index);
if (esutils.code.isLineTerminator(ch)) {
advance();
} else {
if (ch === 0x7D /* '}' */) {
brace -= 1;
if (brace === 0) {
advance();
break;
}
} else if (ch === 0x7B /* '{' */) {
brace += 1;
}
if (type === '') {
startIndex = index;
}
type += advance();
}
}
if (brace !== 0) {
// braces is not balanced
return utility.throwError('Braces are not balanced');
}
if (isAllowedOptional(title)) {
return typed.parseParamType(type, {startIndex: convertIndex(startIndex), range: addRange});
}
return typed.parseType(type, {startIndex: convertIndex(startIndex), range: addRange});
}
function scanIdentifier(last) {
var identifier;
if (!esutils.code.isIdentifierStartES5(source.charCodeAt(index)) && !source[index].match(/[0-9]/)) {
return null;
}
identifier = advance();
while (index < last && esutils.code.isIdentifierPartES5(source.charCodeAt(index))) {
identifier += advance();
}
return identifier;
}
function skipWhiteSpace(last) {
while (index < last && (esutils.code.isWhiteSpace(source.charCodeAt(index)) || esutils.code.isLineTerminator(source.charCodeAt(index)))) {
advance();
}
}
function parseName(last, allowBrackets, allowNestedParams) {
var name = '',
useBrackets,
insideString;
skipWhiteSpace(last);
if (index >= last) {
return null;
}
if (source.charCodeAt(index) === 0x5B /* '[' */) {
if (allowBrackets) {
useBrackets = true;
name = advance();
} else {
return null;
}
}
name += scanIdentifier(last);
if (allowNestedParams) {
if (source.charCodeAt(index) === 0x3A /* ':' */ && (
name === 'module' ||
name === 'external' ||
name === 'event')) {
name += advance();
name += scanIdentifier(last);
}
if(source.charCodeAt(index) === 0x5B /* '[' */ && source.charCodeAt(index + 1) === 0x5D /* ']' */){
name += advance();
name += advance();
}
while (source.charCodeAt(index) === 0x2E /* '.' */ ||
source.charCodeAt(index) === 0x2F /* '/' */ ||
source.charCodeAt(index) === 0x23 /* '#' */ ||
source.charCodeAt(index) === 0x2D /* '-' */ ||
source.charCodeAt(index) === 0x7E /* '~' */) {
name += advance();
name += scanIdentifier(last);
}
}
if (useBrackets) {
skipWhiteSpace(last);
// do we have a default value for this?
if (source.charCodeAt(index) === 0x3D /* '=' */) {
// consume the '='' symbol
name += advance();
skipWhiteSpace(last);
var ch;
var bracketDepth = 1;
// scan in the default value
while (index < last) {
ch = source.charCodeAt(index);
if (esutils.code.isWhiteSpace(ch)) {
if (!insideString) {
skipWhiteSpace(last);
ch = source.charCodeAt(index);
}
}
if (ch === 0x27 /* ''' */) {
if (!insideString) {
insideString = '\'';
} else {
if (insideString === '\'') {
insideString = '';
}
}
}
if (ch === 0x22 /* '"' */) {
if (!insideString) {
insideString = '"';
} else {
if (insideString === '"') {
insideString = '';
}
}
}
if (ch === 0x5B /* '[' */) {
bracketDepth++;
} else if (ch === 0x5D /* ']' */ &&
--bracketDepth === 0) {
break;
}
name += advance();
}
}
skipWhiteSpace(last);
if (index >= last || source.charCodeAt(index) !== 0x5D /* ']' */) {
// we never found a closing ']'
return null;
}
// collect the last ']'
name += advance();
}
return name;
}
function skipToTag() {
while (index < length && source.charCodeAt(index) !== 0x40 /* '@' */) {
advance();
}
if (index >= length) {
return false;
}
utility.assert(source.charCodeAt(index) === 0x40 /* '@' */);
return true;
}
function convertIndex(rangeIndex) {
if (source === originalSource) {
return rangeIndex;
}
return convertUnwrappedCommentIndex(originalSource, rangeIndex);
}
function TagParser(options, title) {
this._options = options;
this._title = title.toLowerCase();
this._tag = {
title: title,
description: null
};
if (this._options.lineNumbers) {
this._tag.lineNumber = lineNumber;
}
this._first = index - title.length - 1;
this._last = 0;
// space to save special information for title parsers.
this._extra = { };
}
// addError(err, ...)
TagParser.prototype.addError = function addError(errorText) {
var args = Array.prototype.slice.call(arguments, 1),
msg = errorText.replace(
/%(\d)/g,
function (whole, index) {
utility.assert(index < args.length, 'Message reference must be in range');
return args[index];
}
);
if (!this._tag.errors) {
this._tag.errors = [];
}
if (strict) {
utility.throwError(msg);
}
this._tag.errors.push(msg);
return recoverable;
};
TagParser.prototype.parseType = function () {
// type required titles
if (isTypeParameterRequired(this._title)) {
try {
this._tag.type = parseType(this._title, this._last, this._options.range);
if (!this._tag.type) {
if (!isParamTitle(this._title) && !isReturnTitle(this._title)) {
if (!this.addError('Missing or invalid tag type')) {
return false;
}
}
}
} catch (error) {
this._tag.type = null;
if (!this.addError(error.message)) {
return false;
}
}
} else if (isAllowedType(this._title)) {
// optional types
try {
this._tag.type = parseType(this._title, this._last, this._options.range);
} catch (e) {
//For optional types, lets drop the thrown error when we hit the end of the file
}
}
return true;
};
TagParser.prototype._parseNamePath = function (optional) {
var name;
name = parseName(this._last, sloppy && isAllowedOptional(this._title), true);
if (!name) {
if (!optional) {
if (!this.addError('Missing or invalid tag name')) {
return false;
}
}
}
this._tag.name = name;
return true;
};
TagParser.prototype.parseNamePath = function () {
return this._parseNamePath(false);
};
TagParser.prototype.parseNamePathOptional = function () {
return this._parseNamePath(true);
};
TagParser.prototype.parseName = function () {
var assign, name;
// param, property requires name
if (isAllowedName(this._title)) {
this._tag.name = parseName(this._last, sloppy && isAllowedOptional(this._title), isAllowedNested(this._title));
if (!this._tag.name) {
if (!isNameParameterRequired(this._title)) {
return true;
}
// it's possible the name has already been parsed but interpreted as a type
// it's also possible this is a sloppy declaration, in which case it will be
// fixed at the end
if (isParamTitle(this._title) && this._tag.type && this._tag.type.name) {
this._extra.name = this._tag.type;
this._tag.name = this._tag.type.name;
this._tag.type = null;
} else {
if (!this.addError('Missing or invalid tag name')) {
return false;
}
}
} else {
name = this._tag.name;
if (name.charAt(0) === '[' && name.charAt(name.length - 1) === ']') {
// extract the default value if there is one
// example: @param {string} [somebody=John Doe] description
assign = name.substring(1, name.length - 1).split('=');
if (assign.length > 1) {
this._tag['default'] = assign.slice(1).join('=');
}
this._tag.name = assign[0];
// convert to an optional type
if (this._tag.type && this._tag.type.type !== 'OptionalType') {
this._tag.type = {
type: 'OptionalType',
expression: this._tag.type
};
}
}
}
}
return true;
};
TagParser.prototype.parseDescription = function parseDescription() {
var description = sliceSource(source, index, this._last).trim();
if (description) {
if ((/^-\s+/).test(description)) {
description = description.substring(2);
}
this._tag.description = description;
}
return true;
};
TagParser.prototype.parseCaption = function parseDescription() {
var description = sliceSource(source, index, this._last).trim();
var captionStartTag = '<caption>';
var captionEndTag = '</caption>';
var captionStart = description.indexOf(captionStartTag);
var captionEnd = description.indexOf(captionEndTag);
if (captionStart >= 0 && captionEnd >= 0) {
this._tag.caption = description.substring(
captionStart + captionStartTag.length, captionEnd).trim();
this._tag.description = description.substring(captionEnd + captionEndTag.length).trim();
} else {
this._tag.description = description;
}
return true;
};
TagParser.prototype.parseKind = function parseKind() {
var kind, kinds;
kinds = {
'class': true,
'constant': true,
'event': true,
'external': true,
'file': true,
'function': true,
'member': true,
'mixin': true,
'module': true,
'namespace': true,
'typedef': true
};
kind = sliceSource(source, index, this._last).trim();
this._tag.kind = kind;
if (!hasOwnProperty(kinds, kind)) {
if (!this.addError('Invalid kind name \'%0\'', kind)) {
return false;
}
}
return true;
};
TagParser.prototype.parseAccess = function parseAccess() {
var access;
access = sliceSource(source, index, this._last).trim();
this._tag.access = access;
if (access !== 'private' && access !== 'protected' && access !== 'public') {
if (!this.addError('Invalid access name \'%0\'', access)) {
return false;
}
}
return true;
};
TagParser.prototype.parseThis = function parseThis() {
// this name may be a name expression (e.g. {foo.bar}),
// an union (e.g. {foo.bar|foo.baz}) or a name path (e.g. foo.bar)
var value = sliceSource(source, index, this._last).trim();
if (value && value.charAt(0) === '{') {
var gotType = this.parseType();
if (gotType && this._tag.type.type === 'NameExpression' || this._tag.type.type === 'UnionType') {
this._tag.name = this._tag.type.name;
return true;
} else {
return this.addError('Invalid name for this');
}
} else {
return this.parseNamePath();
}
};
TagParser.prototype.parseVariation = function parseVariation() {
var variation, text;
text = sliceSource(source, index, this._last).trim();
variation = parseFloat(text, 10);
this._tag.variation = variation;
if (isNaN(variation)) {
if (!this.addError('Invalid variation \'%0\'', text)) {
return false;
}
}
return true;
};
TagParser.prototype.ensureEnd = function () {
var shouldBeEmpty = sliceSource(source, index, this._last).trim();
if (shouldBeEmpty) {
if (!this.addError('Unknown content \'%0\'', shouldBeEmpty)) {
return false;
}
}
return true;
};
TagParser.prototype.epilogue = function epilogue() {
var description;
description = this._tag.description;
// un-fix potentially sloppy declaration
if (isAllowedOptional(this._title) && !this._tag.type && description && description.charAt(0) === '[') {
this._tag.type = this._extra.name;
if (!this._tag.name) {
this._tag.name = undefined;
}
if (!sloppy) {
if (!this.addError('Missing or invalid tag name')) {
return false;
}
}
}
return true;
};
Rules = {
// path_to_url
'access': ['parseAccess'],
// path_to_url
'alias': ['parseNamePath', 'ensureEnd'],
// path_to_url
'augments': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// path_to_url
'constructor': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// Synonym: path_to_url
'class': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// Synonym: path_to_url
'extends': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// path_to_url
'example': ['parseCaption'],
// path_to_url
'deprecated': ['parseDescription'],
// path_to_url
'global': ['ensureEnd'],
// path_to_url
'inner': ['ensureEnd'],
// path_to_url
'instance': ['ensureEnd'],
// path_to_url
'kind': ['parseKind'],
// path_to_url
'mixes': ['parseNamePath', 'ensureEnd'],
// path_to_url
'mixin': ['parseNamePathOptional', 'ensureEnd'],
// path_to_url
'member': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// path_to_url
'method': ['parseNamePathOptional', 'ensureEnd'],
// path_to_url
'module': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// Synonym: path_to_url
'func': ['parseNamePathOptional', 'ensureEnd'],
// Synonym: path_to_url
'function': ['parseNamePathOptional', 'ensureEnd'],
// Synonym: path_to_url
'var': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// path_to_url
'name': ['parseNamePath', 'ensureEnd'],
// path_to_url
'namespace': ['parseType', 'parseNamePathOptional', 'ensureEnd'],
// path_to_url
'private': ['parseType', 'parseDescription'],
// path_to_url
'protected': ['parseType', 'parseDescription'],
// path_to_url
'public': ['parseType', 'parseDescription'],
// path_to_url
'readonly': ['ensureEnd'],
// path_to_url
'requires': ['parseNamePath', 'ensureEnd'],
// path_to_url
'since': ['parseDescription'],
// path_to_url
'static': ['ensureEnd'],
// path_to_url
'summary': ['parseDescription'],
// path_to_url
'this': ['parseThis', 'ensureEnd'],
// path_to_url
'todo': ['parseDescription'],
// path_to_url
'typedef': ['parseType', 'parseNamePathOptional'],
// path_to_url
'variation': ['parseVariation'],
// path_to_url
'version': ['parseDescription']
};
TagParser.prototype.parse = function parse() {
var i, iz, sequences, method;
// empty title
if (!this._title) {
if (!this.addError('Missing or invalid title')) {
return null;
}
}
// Seek to content last index.
this._last = seekContent(this._title);
if (this._options.range) {
this._tag.range = [this._first, source.slice(0, this._last).replace(/\s*$/, '').length].map(convertIndex);
}
if (hasOwnProperty(Rules, this._title)) {
sequences = Rules[this._title];
} else {
// default sequences
sequences = ['parseType', 'parseName', 'parseDescription', 'epilogue'];
}
for (i = 0, iz = sequences.length; i < iz; ++i) {
method = sequences[i];
if (!this[method]()) {
return null;
}
}
return this._tag;
};
function parseTag(options) {
var title, parser, tag;
// skip to tag
if (!skipToTag()) {
return null;
}
// scan title
title = scanTitle();
// construct tag parser
parser = new TagParser(options, title);
tag = parser.parse();
// Seek global index to end of this tag.
while (index < parser._last) {
advance();
}
return tag;
}
//
// Parse JSDoc
//
function scanJSDocDescription(preserveWhitespace) {
var description = '', ch, atAllowed;
atAllowed = true;
while (index < length) {
ch = source.charCodeAt(index);
if (atAllowed && ch === 0x40 /* '@' */) {
break;
}
if (esutils.code.isLineTerminator(ch)) {
atAllowed = true;
} else if (atAllowed && !esutils.code.isWhiteSpace(ch)) {
atAllowed = false;
}
description += advance();
}
return preserveWhitespace ? description : description.trim();
}
function parse(comment, options) {
var tags = [], tag, description, interestingTags, i, iz;
if (options === undefined) {
options = {};
}
if (typeof options.unwrap === 'boolean' && options.unwrap) {
source = unwrapComment(comment);
} else {
source = comment;
}
originalSource = comment;
// array of relevant tags
if (options.tags) {
if (Array.isArray(options.tags)) {
interestingTags = { };
for (i = 0, iz = options.tags.length; i < iz; i++) {
if (typeof options.tags[i] === 'string') {
interestingTags[options.tags[i]] = true;
} else {
utility.throwError('Invalid "tags" parameter: ' + options.tags);
}
}
} else {
utility.throwError('Invalid "tags" parameter: ' + options.tags);
}
}
length = source.length;
index = 0;
lineNumber = 0;
recoverable = options.recoverable;
sloppy = options.sloppy;
strict = options.strict;
description = scanJSDocDescription(options.preserveWhitespace);
while (true) {
tag = parseTag(options);
if (!tag) {
break;
}
if (!interestingTags || interestingTags.hasOwnProperty(tag.title)) {
tags.push(tag);
}
}
return {
description: description,
tags: tags
};
}
exports.parse = parse;
}(jsdoc = {}));
exports.version = utility.VERSION;
exports.parse = jsdoc.parse;
exports.parseType = typed.parseType;
exports.parseParamType = typed.parseParamType;
exports.unwrapComment = unwrapComment;
exports.Syntax = shallowCopy(typed.Syntax);
exports.Error = utility.DoctrineError;
exports.type = {
Syntax: exports.Syntax,
parseType: typed.parseType,
parseParamType: typed.parseParamType,
stringify: typed.stringify
};
}());
/* vim: set sw=4 ts=4 et tw=80 : */
```
|
```objective-c
#pragma once
#ifndef LINEEDIT_H
#define LINEEDIT_H
#include "tcommon.h"
#include <QLineEdit>
#undef DVAPI
#undef DVVAR
#ifdef TOONZQT_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif
//=============================================================================
namespace DVGui {
//=============================================================================
/*! \brief It is a \b QLineEdit which lost focus when enter is pressed and emit
focusIn signal when line edit take
focus.
Inherits \b QLineEdit.
*/
class DVAPI LineEdit : public QLineEdit {
Q_OBJECT
bool m_isReturnPressed;
bool m_forbiddenSpecialChars;
bool m_mouseDragEditing = false;
public:
LineEdit(QWidget *parent = 0, bool forbiddenSpecialChars = false);
LineEdit(const QString &contents, QWidget *parent = 0,
bool forbiddenSpecialChars = false);
bool isReturnPressed() const { return m_isReturnPressed; }
~LineEdit() {}
// In the function editor, ctrl + dragging on the lineedit
// can adjust the value.
bool getMouseDragEditing() { return m_mouseDragEditing; }
void setMouseDragEditing(bool status) { m_mouseDragEditing = status; }
protected:
void focusInEvent(QFocusEvent *event) override;
void keyPressEvent(QKeyEvent *event) override;
void mouseMoveEvent(QMouseEvent *) override;
signals:
void focusIn();
void returnPressedNow();
// this signal is only used for mouse drag value editing in the function
// panel.
void mouseMoved(QMouseEvent *);
};
//your_sha256_hash-------------
} // namespace DVGui
//your_sha256_hash-------------
#endif // LINEEDIT_H
```
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\AdExchangeBuyer;
class Seller extends \Google\Model
{
public $accountId;
public $subAccountId;
public function setAccountId($accountId)
{
$this->accountId = $accountId;
}
public function getAccountId()
{
return $this->accountId;
}
public function setSubAccountId($subAccountId)
{
$this->subAccountId = $subAccountId;
}
public function getSubAccountId()
{
return $this->subAccountId;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(Seller::class, 'Google_Service_AdExchangeBuyer_Seller');
```
|
```smalltalk
//
// Generated with Bot Builder V4 SDK Template for Visual Studio EchoBot v4.9.2
using System;
using ImmediateAcceptBot.BackgroundQueue;
using ImmediateAcceptBot.Bots;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Builder.Integration.AspNet.Core;
using Microsoft.Bot.Connector.Authentication;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace ImmediateAcceptBot
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddHttpClient().AddControllers().AddNewtonsoftJson(options =>
{
options.SerializerSettings.MaxDepth = HttpHelper.BotMessageSerializerSettings.MaxDepth;
});
// Activity specific BackgroundService for processing athenticated activities.
services.AddHostedService<HostedActivityService>();
// Generic BackgroundService for processing tasks.
services.AddHostedService<HostedTaskService>();
// BackgroundTaskQueue and ActivityTaskQueue are the entry points for
// the enqueueing activities or tasks to be processed by the BackgroundService.
services.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>();
services.AddSingleton<IActivityTaskQueue, ActivityTaskQueue>();
// Configure the ShutdownTimeout based on appsettings.
services.Configure<HostOptions>(opts => opts.ShutdownTimeout = TimeSpan.FromSeconds(Configuration.GetValue<int>("ShutdownTimeoutSeconds")));
// Create the Bot Framework Authentication to be used with the Bot Adapter.
services.AddSingleton<BotFrameworkAuthentication, ConfigurationBotFrameworkAuthentication>();
// Create the ImmediateAcceptAdapter.
// Note: some classes use the base BotAdapter so we add an extra registration that pulls the same instance.
services.AddSingleton<ImmediateAcceptAdapter>();
services.AddSingleton<IBotFrameworkHttpAdapter>(sp => sp.GetService<ImmediateAcceptAdapter>());
services.AddSingleton<BotAdapter>(sp => sp.GetService<ImmediateAcceptAdapter>());
// Create the bot. In this case the ASP Controller and ImmediateAcceptAdapter is expecting an IBot.
services.AddTransient<IBot, EchoBot>();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseDefaultFiles()
.UseStaticFiles()
.UseWebSockets()
.UseRouting()
.UseAuthorization()
.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
// app.UseHttpsRedirection();
}
}
}
```
|
```kotlin
package net.corda.nodeapi.internal.protonwrapper.netty
import java.security.cert.X509CRL
import java.security.cert.X509Certificate
@FunctionalInterface
interface CrlSource {
/**
* Given certificate provides a set of CRLs, potentially performing remote communication.
*/
fun fetch(certificate: X509Certificate): Set<X509CRL>
}
```
|
Else Hagen (21 September 1914 – 17 August 2010) was a Norwegian visual artist.
She was born in Eydehavn, and was married to Arne E. Holm. She is known for her large decorations in public areas. Among her works are decorations in Stortinget, Tromsø Airport, the University Library in Bergen, the Norwegian School of Sport Sciences, and Postgirobygget.
When she won the competition to decorate Nøtterøy Realskole (now Borgheim School) in 1950, she became the first female artist to receive a public decoration commission in Norway.
References
1914 births
2010 deaths
People from Arendal
Norwegian artists
|
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import smskdeg2rad = require( './index' );
// TESTS //
// The function returns a Float32Array...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( x.length, x, 1, m, 1, y, 1 ); // $ExpectType Float32Array
}
// The compiler throws an error if the function is provided a first argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( '10', x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( true, x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( false, x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( null, x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( undefined, x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( [], x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( {}, x, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( ( x: number ): number => x, x, 1, m, 1, y, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a second argument which is not a Float32Array...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( x.length, 10, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, '10', 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, true, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, false, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, null, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, undefined, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, [ '1' ], 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, {}, 1, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, ( x: number ): number => x, 1, m, 1, y, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a third argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( x.length, x, '10', m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, true, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, false, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, null, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, undefined, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, [], m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, {}, m, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, ( x: number ): number => x, m, 1, y, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a fourth argument which is not a Uint8Array...
{
const x = new Float32Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( x.length, x, 1, 10, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, '10', 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, true, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, false, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, null, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, undefined, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, [ '1' ], 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, {}, 1, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, ( x: number ): number => x, 1, y, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a fifth argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( x.length, x, 1, m, '10', y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, true, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, false, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, null, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, undefined, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, [], y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, {}, y, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, ( x: number ): number => x, y, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a sixth argument which is not a Float32Array...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
smskdeg2rad( x.length, x, 1, m, 1, 10, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, '10', 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, true, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, false, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, null, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, undefined, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, [ '1' ], 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, {}, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, ( x: number ): number => x, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a seventh argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad( x.length, x, 1, m, 1, y, '10' ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, true ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, false ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, null ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, undefined ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, [] ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, {} ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, ( x: number ): number => x ); // $ExpectError
}
// The compiler throws an error if the function is provided an unsupported number of arguments...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad(); // $ExpectError
smskdeg2rad( x.length ); // $ExpectError
smskdeg2rad( x.length, x ); // $ExpectError
smskdeg2rad( x.length, x, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1 ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y ); // $ExpectError
smskdeg2rad( x.length, x, 1, m, 1, y, 1, 10 ); // $ExpectError
}
// Attached to main export is an `ndarray` method which returns a Float32Array...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectType Float32Array
}
// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( '10', x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( true, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( false, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( null, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( undefined, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( [], x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( {}, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( ( x: number ): number => x, x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Float32Array...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, 10, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, '10', 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, true, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, false, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, null, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, undefined, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, [ '1' ], 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, {}, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, ( x: number ): number => x, 1, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, '10', 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, true, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, false, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, null, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, undefined, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, [], 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, {}, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, ( x: number ): number => x, 0, m, 1, 0, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, '10', m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, true, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, false, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, null, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, undefined, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, [], m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, {}, m, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, ( x: number ): number => x, m, 1, 0, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Uint8Array...
{
const x = new Float32Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, 10, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, '10', 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, true, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, false, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, null, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, undefined, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, [ '1' ], 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, {}, 1, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, m, '10', 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, true, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, false, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, null, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, undefined, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, [], 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, {}, 0, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, '10', y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, true, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, false, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, null, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, undefined, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, [], y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, {}, y, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a Float32Array...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, 10, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, '10', 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, true, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, false, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, null, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, undefined, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, {}, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, '10', 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, true, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, false, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, null, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, undefined, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, [], 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, {}, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a tenth argument which is not a number...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, '10' ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, true ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, false ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, null ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, undefined ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, [] ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, {} ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, ( x: number ): number => x ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
{
const x = new Float32Array( 10 );
const m = new Uint8Array( 10 );
const y = new Float32Array( 10 );
smskdeg2rad.ndarray(); // $ExpectError
smskdeg2rad.ndarray( x.length ); // $ExpectError
smskdeg2rad.ndarray( x.length, x ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1 ); // $ExpectError
smskdeg2rad.ndarray( x.length, x, 1, 0, m, 1, 0, y, 1, 0, 10 ); // $ExpectError
}
```
|
```java
package com.airbnb.epoxy;
import android.view.ViewParent;
import androidx.annotation.LayoutRes;
import androidx.annotation.Nullable;
import java.lang.CharSequence;
import java.lang.Number;
import java.lang.Object;
import java.lang.Override;
import java.lang.String;
/**
* Generated file. Do not modify!
*/
public class AbstractModelWithHolder_ extends AbstractModelWithHolder implements GeneratedModel<AbstractModelWithHolder.Holder>, AbstractModelWithHolderBuilder {
private OnModelBoundListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> onModelBoundListener_epoxyGeneratedModel;
private OnModelUnboundListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> onModelUnboundListener_epoxyGeneratedModel;
private OnModelVisibilityStateChangedListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> onModelVisibilityStateChangedListener_epoxyGeneratedModel;
private OnModelVisibilityChangedListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> onModelVisibilityChangedListener_epoxyGeneratedModel;
public AbstractModelWithHolder_() {
super();
}
@Override
public void addTo(EpoxyController controller) {
super.addTo(controller);
addWithDebugValidation(controller);
}
@Override
public void handlePreBind(final EpoxyViewHolder holder,
final AbstractModelWithHolder.Holder object, final int position) {
validateStateHasNotChangedSinceAdded("The model was changed between being added to the controller and being bound.", position);
}
@Override
public void handlePostBind(final AbstractModelWithHolder.Holder object, int position) {
if (onModelBoundListener_epoxyGeneratedModel != null) {
onModelBoundListener_epoxyGeneratedModel.onModelBound(this, object, position);
}
validateStateHasNotChangedSinceAdded("The model was changed during the bind call.", position);
}
/**
* Register a listener that will be called when this model is bound to a view.
* <p>
* The listener will contribute to this model's hashCode state per the {@link
* com.airbnb.epoxy.EpoxyAttribute.Option#DoNotHash} rules.
* <p>
* You may clear the listener by setting a null value, or by calling {@link #reset()}
*/
public AbstractModelWithHolder_ onBind(
OnModelBoundListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> listener) {
onMutation();
this.onModelBoundListener_epoxyGeneratedModel = listener;
return this;
}
@Override
public void unbind(AbstractModelWithHolder.Holder object) {
super.unbind(object);
if (onModelUnboundListener_epoxyGeneratedModel != null) {
onModelUnboundListener_epoxyGeneratedModel.onModelUnbound(this, object);
}
}
/**
* Register a listener that will be called when this model is unbound from a view.
* <p>
* The listener will contribute to this model's hashCode state per the {@link
* com.airbnb.epoxy.EpoxyAttribute.Option#DoNotHash} rules.
* <p>
* You may clear the listener by setting a null value, or by calling {@link #reset()}
*/
public AbstractModelWithHolder_ onUnbind(
OnModelUnboundListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> listener) {
onMutation();
this.onModelUnboundListener_epoxyGeneratedModel = listener;
return this;
}
@Override
public void onVisibilityStateChanged(int visibilityState,
final AbstractModelWithHolder.Holder object) {
if (onModelVisibilityStateChangedListener_epoxyGeneratedModel != null) {
onModelVisibilityStateChangedListener_epoxyGeneratedModel.onVisibilityStateChanged(this, object, visibilityState);
}
super.onVisibilityStateChanged(visibilityState, object);
}
/**
* Register a listener that will be called when this model visibility state has changed.
* <p>
* The listener will contribute to this model's hashCode state per the {@link
* com.airbnb.epoxy.EpoxyAttribute.Option#DoNotHash} rules.
*/
public AbstractModelWithHolder_ onVisibilityStateChanged(
OnModelVisibilityStateChangedListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> listener) {
onMutation();
this.onModelVisibilityStateChangedListener_epoxyGeneratedModel = listener;
return this;
}
@Override
public void onVisibilityChanged(float percentVisibleHeight, float percentVisibleWidth,
int visibleHeight, int visibleWidth, final AbstractModelWithHolder.Holder object) {
if (onModelVisibilityChangedListener_epoxyGeneratedModel != null) {
onModelVisibilityChangedListener_epoxyGeneratedModel.onVisibilityChanged(this, object, percentVisibleHeight, percentVisibleWidth, visibleHeight, visibleWidth);
}
super.onVisibilityChanged(percentVisibleHeight, percentVisibleWidth, visibleHeight, visibleWidth, object);
}
/**
* Register a listener that will be called when this model visibility has changed.
* <p>
* The listener will contribute to this model's hashCode state per the {@link
* com.airbnb.epoxy.EpoxyAttribute.Option#DoNotHash} rules.
*/
public AbstractModelWithHolder_ onVisibilityChanged(
OnModelVisibilityChangedListener<AbstractModelWithHolder_, AbstractModelWithHolder.Holder> listener) {
onMutation();
this.onModelVisibilityChangedListener_epoxyGeneratedModel = listener;
return this;
}
public AbstractModelWithHolder_ value(int value) {
onMutation();
super.value = value;
return this;
}
public int value() {
return value;
}
@Override
public AbstractModelWithHolder_ id(long id) {
super.id(id);
return this;
}
@Override
public AbstractModelWithHolder_ id(@Nullable Number... ids) {
super.id(ids);
return this;
}
@Override
public AbstractModelWithHolder_ id(long id1, long id2) {
super.id(id1, id2);
return this;
}
@Override
public AbstractModelWithHolder_ id(@Nullable CharSequence key) {
super.id(key);
return this;
}
@Override
public AbstractModelWithHolder_ id(@Nullable CharSequence key,
@Nullable CharSequence... otherKeys) {
super.id(key, otherKeys);
return this;
}
@Override
public AbstractModelWithHolder_ id(@Nullable CharSequence key, long id) {
super.id(key, id);
return this;
}
@Override
public AbstractModelWithHolder_ layout(@LayoutRes int layoutRes) {
super.layout(layoutRes);
return this;
}
@Override
public AbstractModelWithHolder_ spanSizeOverride(
@Nullable EpoxyModel.SpanSizeOverrideCallback spanSizeCallback) {
super.spanSizeOverride(spanSizeCallback);
return this;
}
@Override
public AbstractModelWithHolder_ show() {
super.show();
return this;
}
@Override
public AbstractModelWithHolder_ show(boolean show) {
super.show(show);
return this;
}
@Override
public AbstractModelWithHolder_ hide() {
super.hide();
return this;
}
@Override
protected AbstractModelWithHolder.Holder createNewHolder(ViewParent parent) {
return new AbstractModelWithHolder.Holder();
}
@Override
public AbstractModelWithHolder_ reset() {
onModelBoundListener_epoxyGeneratedModel = null;
onModelUnboundListener_epoxyGeneratedModel = null;
onModelVisibilityStateChangedListener_epoxyGeneratedModel = null;
onModelVisibilityChangedListener_epoxyGeneratedModel = null;
super.value = 0;
super.reset();
return this;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof AbstractModelWithHolder_)) {
return false;
}
if (!super.equals(o)) {
return false;
}
AbstractModelWithHolder_ that = (AbstractModelWithHolder_) o;
if (((onModelBoundListener_epoxyGeneratedModel == null) != (that.onModelBoundListener_epoxyGeneratedModel == null))) {
return false;
}
if (((onModelUnboundListener_epoxyGeneratedModel == null) != (that.onModelUnboundListener_epoxyGeneratedModel == null))) {
return false;
}
if (((onModelVisibilityStateChangedListener_epoxyGeneratedModel == null) != (that.onModelVisibilityStateChangedListener_epoxyGeneratedModel == null))) {
return false;
}
if (((onModelVisibilityChangedListener_epoxyGeneratedModel == null) != (that.onModelVisibilityChangedListener_epoxyGeneratedModel == null))) {
return false;
}
if ((value != that.value)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int _result = super.hashCode();
_result = 31 * _result + (onModelBoundListener_epoxyGeneratedModel != null ? 1 : 0);
_result = 31 * _result + (onModelUnboundListener_epoxyGeneratedModel != null ? 1 : 0);
_result = 31 * _result + (onModelVisibilityStateChangedListener_epoxyGeneratedModel != null ? 1 : 0);
_result = 31 * _result + (onModelVisibilityChangedListener_epoxyGeneratedModel != null ? 1 : 0);
_result = 31 * _result + value;
return _result;
}
@Override
public String toString() {
return "AbstractModelWithHolder_{" +
"value=" + value +
"}" + super.toString();
}
}
```
|
Indira Nagar () is a neighbourhood in Chennai, India.
The region was developed by the Tamil Nadu Housing Board (TNHB) in the late 1970s and early 1980s. It contains residential plots, apartments, commercial complexes, large arterial roads, school zones, bus terminals, and slums.
Indira Nagar is an example of a government-planned town established by the TNHB. In comparison to other TNHB developments such as Anna Nagar, K.K. Nagar, Ashok Nagar, and Besant Nagar, Indira Nagar is relatively small-scale. The Indira Nagar station, part of the Chennai Mass Rapid Transit System, serves the neighbourhood. Hindu Senior Secondary School is located in the area.
Neighbourhoods in Chennai
|
Russula delica is a mushroom that goes by the common name of milk-white brittlegill, and is a member of the genus Russula, all of which are collectively known as brittlegills. It is mostly white, with ochraceous or brownish cap markings, and a short robust stem. It is edible, but poor in taste, and grows in coniferous, broadleaved, or mixed woods. It can be confused with other white Russula species and certain white Lactarius species.
Taxonomy
First described by the Swedish mycologist Elias Magnus Fries in 1838, its specific epithet delica is Latin for "weaned". Older names include Christian Hendrik Persoon's Lactarius piperatus var. exsuccus.
This species has undergone many taxonomic changes over the years. Russula chloroides is now considered a distinct species because of the very dense lamellae and blue/green zone at the stem apex of some specimens. Gill spacing, gill depth, spore colour and spore ornamentation have also thrown many finds into doubt, and a number of varieties have been described throughout the years.
Mycologist John Burton Cleland collected a form he described in 1935 as R. delica from under eucalypts in the Mount Lofty Ranges in South Australia, however, this was reclassified as a new species R. marangania in 1997 by Cheryl Grgurinovic.
Description
The basidiocarps (fruiting bodies) of Russula delica seem loath to leave the soil, and are often found half buried, or sometimes growing hypogeously. As a result, the caps often trap the surrounding leaf debris and soil on their rough surfaces. The cap can be in diameter. It is white, usually tinged with ochre or brown, with an inrolled margin, which usually remains white. At first it is convex, but later flattens, and is often funnel shaped. The firm, white stipe is short and stout, measuring high and wide. The gills are decurrent, and are quite closely spaced initially. The spore print is creamy white, and the warty oval spores measure 8–12 x 7–9 μm. The flesh is white, and does not change colour on cutting. It has a pleasant, fruity smell when young, but at maturity it may develop a faintly fishy or unpleasant smell. It has a spicy, tangy taste.
Similar species
Russula chloroides is very similar and often confused with R. delica. It can be separated by the turquoise band at the apex (at the attachment of the gills with the cap) and by its unpleasant, peppery smell.
Russula pallidospora is another similar species, which has very tough flesh, more distant gills and an ochraceous spore deposit.
Russula flavispora is also similar but rare, and has dense gills and a deep ochraceous spore deposit.
Similar whitish milk-cap species, such as Lactifluus piperatus all exude milk from the gills, and the cut flesh.
Distribution and habitat
Russula delica is widespread in the northern temperate zones, including Europe and Asia. It is particularly common in the Eastern Mediterranean. It is a thermophylic species, appearing during hot spells in summer and autumn in broadleaved and coniferous woods. In North America Russula delica is rare and is largely replaced by R. brevipes, which is very similar, but not found in Europe.
Edibility
This mushroom is edible but poor, having an unpleasant taste, leading some to classify it as inedible. However, in Cyprus, as well as certain Greek islands such as Lesvos, huge numbers of Russula delica are collected and consumed every year. They are usually pickled and preserved in olive oil, vinegar or brine, after prolonged boiling.
In Ukraine and Russia, this mushroom is used for salting too. Only caps are used, which are boiled for about half an hour, and then salted in cold brine with dill and garlic.
See also
List of Russula species
References
delica
Fungi described in 1838
Fungi of Europe
Fungi of Asia
Fungi of North America
Taxa named by Elias Magnus Fries
|
```html
{% extends "index-base.html" %}
{% block header %}
<text style="font-size:32px">Knowledge Clusters {% endblock %}</text>
{% block inner_content %}
<br><br>
<div class="row cluster-header">
<div class="col-md-14" style='background-color:white'>
<div class="col-md-2_5 group-by-header">
<h5> Group posts by:</h5>
</div>
<span class="col-md-3 group-by-options">
<div class="radio-inline radio-cluster">
<label>
<input type="radio" name="cluster-radio" id="clusterFolder">Folder
</label>
</div>
<div class="radio-inline radio-cluster">
<label>
<input type="radio" name="cluster-radio" id="clusterTags">Tags
</label>
</div>
<div class="radio-inline radio-cluster">
<label>
<input type="radio" name="cluster-radio" id="clusterAuthor">Author
</label>
</div>
</span>
<div class="col-md-2_5 sort-by-header">
<h5> Sort by:</h5>
</div>
<span class="col-md-3 sort-by-options">
<div class="radio-inline radio-cluster">
<label>
<input type="radio" name="sort-radio" id="sortAlpha"> Alphabetically
</label>
</div>
<div class="radio-inline radio-cluster">
<label>
<input type="radio" name="sort-radio" id="sortCount">Count
</label>
</div>
</span>
<div style="clear:both"></div>
</div>
</div>
<ul id="cluster_list" class="col-md-14;margin-left: 20px;display: inline-flex;">
{%- for cluster, is_post, count, contents in grouped_data recursive %}
{%- if is_post %}
<li class="cluster-list-li" style="list-style-type:circle">
<a href="{{'/post/' + contents.path|urlencode }}">
{{ contents.title|replace('_', ' '|title )}}
</a>
</li>
{%- else %}
{%- if contents|length > 0 and cluster|length > 0 %}
{% set cluster_id = cluster|replace(' ', '__')|replace('-', '__')|replace('#', '__')|replace('.', '__') %}
<li id="{{ cluster_id|safe }}" class="cluster_dir cluster-list-li" style="list-style-type:disc">
<div>
<h6 style="margin-bottom:0;margin-top:0;margin-left: 10px;">
{{ [cluster,' (', count, ')'] | join }}
<i id="{{ cluster_id|safe }}-glyph" class="glyphicon glyphicon-chevron-right cluster-dropdown"></i>
</h6>
</div>
</li>
<div id="{{ cluster_id|safe }}-content" style="display:none">
<ul style="margin-top: 0px">
{{ loop(contents) }}
</ul>
</div>
{%- endif %}
{%- endif %}
{%- endfor %}
</ul>
</nav>
{% endblock %}
{% block scripts %}
{{ super() }}
<script src="{{ url_for('static', filename='js/index-cluster.js') }}"></script>
<script type="text/javascript">
$(document).ready(function () {
var cluster_button = $(".btn-cluster")[0];
$(cluster_button).addClass("btn-active");
var glyphicon = $(".glyphicon-post-org.glyphicon-th-list")[0];
$(glyphicon).addClass("glyphicon-active");
var tag = "{{ tag |default('', true)}}";
var clusterSelected = '#cluster{{ group_by|title }}';
var sortSelected = '#sort{{ sort_by|title }}';
var clusterButtons = ["clusterFolder", "clusterTags", "clusterAuthor"];
var sortButtons = ["sortAlpha", "sortCount"];
indexClusterJx.addFoldingToGroups();
indexClusterJx.clickTag(tag);
clusterSelected = indexClusterJx.getClusterSelected(clusterSelected);
sortSelected = indexClusterJx.getSortSelected(sortSelected);
$(clusterSelected)[0].setAttribute("checked", "checked")
$(sortSelected)[0].setAttribute("checked", "checked")
indexClusterJx.formatButtons(clusterSelected, clusterButtons, sortSelected, sortButtons);
function search() {
indexClusterJx.refreshPage(clusterSelected, sortSelected);
}
})
</script>
{% endblock %}
```
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\CloudDataplex;
class GoogleCloudDataplexV1DataQualityResultPostScanActionsResult extends \Google\Model
{
protected $bigqueryExportResultType = your_sha256_hasheryExportResult::class;
protected $bigqueryExportResultDataType = '';
/**
* @param your_sha256_hasheryExportResult
*/
public function setBigqueryExportResult(your_sha256_hasheryExportResult $bigqueryExportResult)
{
$this->bigqueryExportResult = $bigqueryExportResult;
}
/**
* @return your_sha256_hasheryExportResult
*/
public function getBigqueryExportResult()
{
return $this->bigqueryExportResult;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(GoogleCloudDataplexV1DataQualityResultPostScanActionsResult::class, your_sha256_hashultPostScanActionsResult');
```
|
Abingdon-on-Thames ( ), commonly known as Abingdon, is a historic market town and civil parish in the ceremonial county of Oxfordshire, England, on the River Thames. Historically the county town of Berkshire, Abingdon has been administered since 1974 by the Vale of White Horse district within Oxfordshire. The area was occupied from the early to middle Iron Age and the remains of a late Iron Age and Roman defensive enclosure lies below the town centre. Abingdon Abbey was founded around 676, giving its name to the emerging town. In the 13th and 14th centuries, Abingdon was an agricultural centre with an extensive trade in wool, alongside weaving and the manufacture of clothing. Charters for the holding of markets and fairs were granted by various monarchs, from Edward I to George II.
The town survived the dissolution of the abbey in 1538, and by the 18th and 19th centuries, with the building of Abingdon Lock in 1790 and the Wilts & Berks Canal in 1810, Abingdon was on important routes for goods transport. In 1856 the Abingdon Railway opened, linking the town with the Great Western Railway. The canal was abandoned in 1906 but a voluntary trust is now working to restore and re-open it. Abingdon railway station was closed to passengers in September 1963. The line remained open for goods until 1984, its role including serving the MG car factory, which operated from 1929 to 1980.
Abingdon's brewery, Morland, makers of Old Speckled Hen ale, was taken over and closed in 1999; the site of the brewery has been redeveloped into housing. The rock band Radiohead formed in 1985 when its members were studying at Abingdon School, a day and boarding independent secondary school. The 2011 Census recorded the parish's population as 33,130. This was 2,504 more than in the 2001 Census total of 30,626, and represented just over 8% growth in the population.
History
A Neolithic stone hand axe was found at Abingdon. Petrological analysis in 1940 identified the stone as epidotised tuff from Stake Pass in the Lake District, to the north. Stone axes from the same source have been found at Sutton Courtenay, Alvescot, Kencot and Minster Lovell. Abingdon has been occupied from the early to middle Iron Age and the remains of a late Iron Age defensive enclosure (or oppidum) lies below the town centre. The oppidum was in use throughout the Roman occupation. A Neolithic causewayed enclosure was found in Abingdon in 1926, dating to the 36th or 37th century BC.
Abingdon Abbey was founded in Saxon times, possibly around 676, but its early history is confused by numerous legends, invented to raise its status and explain the place name. The name seems to mean 'Hill of a man named Æbba, or a woman named Æbbe', possibly the saint to whom St Ebbe's Church in Oxford was dedicated (Æbbe of Coldingham or a different Æbbe of Oxford). However, Abingdon stands in a valley and not on a hill. It is thought that the name was first given to a place on Boars Hill above Chilswell, and the name was transferred to its present site when the Abbey was moved. In 1084, William the Conqueror celebrated Easter at the Abbey and it is possible that his son Henry I received some schooling at the abbey.
In the 13th and 14th centuries, Abingdon was a flourishing agricultural centre with an extensive trade in wool and a famous weaving and clothing manufacturing industry. The abbot seems to have held a market from very early times and charters for the holding of markets and fairs were granted by various sovereigns, from Edward I to George II. In 1337 there was a famous riot in protest at the Abbot's control of this market in which several of the monks were killed. After the abbey's dissolution in 1538, the town sank into decay and, in 1556, upon receiving a representation of its pitiable condition, Mary I granted a charter establishing a mayor, two bailiffs, twelve chief burgesses and sixteen secondary burgesses, the mayor to be clerk of the market, coroner and a JP. The present Christ's Hospital originally belonged to the Guild of the Holy Cross, on the dissolution of which Edward VI founded the almshouses instead, under its present name.
The council was empowered to elect one burgess to parliament and this right continued until the Redistribution of Seats Act of 1885. A town clerk and other officers were appointed and the town boundaries were described in great detail. Later charters, from Elizabeth I, James I, James II, George II and George III, made no considerable change. James II changed the style of the corporation to that of a mayor, twelve aldermen and twelve burgesses. Abingdon became the county town of Berkshire sometime after receiving its Royal Charter in 1556.
Assize courts were held in Abingdon from 1570, but in the 17th century it was vying with Reading for county town status. The county hall and court house were built between 1678 and 1682, to assert this status. The building, now the Abingdon County Hall Museum, was reputedly designed by Christopher Kempster, who worked with Sir Christopher Wren.
In 1790 Abingdon Lock was built, replacing navigation via the Swift Ditch. In 1810, the Wilts & Berks Canal opened, linking Abingdon with Semington on the Kennet and Avon Canal. Abingdon became a key link between major industrial centres such as Bristol, London, Birmingham and the Black Country. In 1856 the Abingdon Railway opened, linking the town with the Great Western Railway at . However, Abingdon's failure to engage fully with the railway revolution, accepting only a branch line, sidelined the town in favour of Reading which became the County Town in 1869.
The Wilts & Berks Canal was abandoned in 1906 but a voluntary trust is now working to restore and re-open it. Abingdon railway station was closed to passengers in September 1963. The line remained open for goods until 1984, including serving the MG car factory, which opened in 1929 and closed in October 1980 as part of a British Leyland rationalisation plan. The nearest railway station is , away. Much of the original Abingdon branch line is now a cyclepath, whilst the land on which the station stood has been extensively redeveloped, and is now the site of a large Waitrose store and surrounded by a large number of new flats and houses.
The corporation was reformed, under the Municipal Corporations Act 1835 but was abolished under the Local Government Act 1972. In 1974, under local government reorganisation, Berkshire County Council was abolished and Abingdon's governance was transferred to Oxfordshire with the town becoming the seat of the new Vale of White Horse District Council, with Abingdon becoming a civil parish with a town council. Since the 1980s, Abingdon has played host to a number of information communication companies, with many based in the town's respective business and science parks. With this, and the result of Abingdon's proximity to academic and scientific institutions in Oxford, the town has seen an influx of young professionals taking residence in the town's many residential areas such as Peachcroft.
The town was sometimes historically called "Abingdon-on-Thames", but the official name of the borough (as given in statutes from the Municipal Corporations Act 1835 to the Local Government Act 1972 and all intervening Ordnance Survey maps) was simply "Abingdon". Local councillors voted in November 2011 to change the official name of the town to "Abingdon-on-Thames", and the change took effect on 23 February 2012.
Leisure and media
Sport and recreation facilities include the White Horse Leisure and Tennis Centre, Tilsley Park and the Southern Town Park. Abingdon had four cinemas but all have closed. The last was the Regal, which closed in 1989. It stood derelict for 24 years until it was demolished in 2003 and replaced by housing development, Regal Close. The Unicorn theatre was built in an area called The Checkers Hall in the ruins of the Abbey buildings and shows plays and films on an irregular basis. In addition, a new cinema, called the Abbey Cinema has been built in one of the Town Council buildings and operates in conjunction with the Regal in Evesham.
The local newspapers are The Oxford Times, Oxford Mail and Abingdon Herald. The Oxfordshire Guardian, a free newspaper, was based in Abingdon for many years and was founded as the South Oxfordshire Courier until its closure in 2018. Local radio and television stations are shared with Oxford, although ITV retains a news gathering centre in nearby Milton Park (formerly having a broadcasting studio in the town) for ITV Meridian. Historically the ITV franchise was ITV Central. Local analogue radio is provided by BBC Radio Oxford, Jack FM, Jack 3 and Heart South (historically 'Fox FM' and later 'Heart Thames Valley'), while the town is also covered by the Oxfordshire DAB multiplex. There was a Six TV local TV channel until 2009 and the town's further education college was the home to That's TV studios for Oxfordshire until it relocated to Oxford Science Park.
The Tesco Extra store west of the town is the largest supermarket in Abingdon and has historically been one of the most profitable Tesco stores in the country. Nearby is the Fairacres Retail Park, thought to be the first retail park in the UK and recently redeveloped, which includes Argos, Subway, B & M, Dreams and Pets at Home stores. It originally had two long established Abingdon retailers—Vineys Home Furnishings (now part of the Lee Longlands chain but retains its name) and Mays Carpets (now part of the Carpetright chain and has re-branded accordingly). In the town centre, many independent stores, estate agents and charity shops make up the Bury Street shopping centre as major high street names have chosen to go to other towns. However, a recent renovation has attracted stores such as New Look, Peacocks and WHSmith to open branches.
The town centre of Abingdon was renovated in 2012 as part of the council's redevelopment plan, with the 1970s shopping precinct converted to look more modern. The roads around the area have been changed: notably the one-way system around the centre has been partially changed to two-way. While this has slightly reduced traffic within the historic town centre, congestion has greatly increased elsewhere. Local businesses have also complained that the increased traffic has driven shoppers away. Redevelopment of the Old Gaol site, most recently a leisure centre, began in 2010. The first stage was demolishing the 1970s additions and swimming pool extension. The Gaol has been converted into luxury flats, shops and restaurants, with access to the riverside.
Sport
Abingdon has two non-League football teams: Abingdon United F.C., who compete in the and play at The Armadillo Energy Stadium, and Abingdon Town F.C., who play at Culham Road. Abingdon Golf Club/North Berks Golf Club (now defunct) was first mentioned in 1876. The club disappeared at the time of the Second World War The Oxford Saints American Football Club play their games in Abingdon at Tilsley Park and are one of the longest-running American Football clubs in the UK, founded in 1983. Abingdon is home to Abingdon Rowing Club, with members from 13 to 80 years old. It has had many successes at local and national races, and also holds its own Abingdon Head race in April, one of the main events in the Abingdon Calendar. Its boathouse is on Wilsham Road. Abingdon Amblers changed its name to Abingdon Athletics Club. They train at Tilsley Park and take part in county cross-country leagues.
Abingdon RUFC was formed at the Queens Hotel on 27 February 1931. During the 1930s the club was based at the Queens Hotel and games were played on the Council owned recreation ground at Caldecott Road. Immediately after the Second World War the club moved to outside the RAF camp (now Dalton Barracks) which offered on-site changing facilities and later a pitch inside the camp. At the start of the Suez Crisis in 1956 play temporarily returned to the Caldecott Road site because of security risks. This period saw the formation of the ill-fated Abingdon Sports Club; an amalgamation of the town's rugby, cricket and hockey clubs and the bid to establish a sporting centre at Hales Meadow. In a short time the ground was developed and a pavilion erected but the organisation was plagued with financial difficulties and very soon dissolved with hockey disbanding and Abingdon Rugby remaining at the site as tenants to the cricket club. In the mid-1980s a determined effort was made to acquire grounds and a clubhouse dedicated to rugby.
The current base at the town's Southern Sports Park was opened by former Abingdon MP John Patten in 1989. Abingdon has had members representing the county, progressing to first-class level and on to international status in the Six Nations Tournament. The Abingdon Sevens traditionally opens the Home Counties' playing season and has attracted sides from throughout the country and beyond. Initiated in 1956 as a one-off tournament to celebrate the town's 400th anniversary of receiving a Royal Charter, it proved so successful that the competition has been held on an annual basis ever since. Several years ago it was decided to introduce the youngsters of Abingdon to Club Rugby. The Youth Section has 200 playing members from the ages of 6 to 18. In 2013–14 Abingdon RFC's President, Paul Murphy MBE, was also the President of the RFU. Since 2016, Oxford Rugby League have played in Abingdon at Abingdon School's Tilsley Park.
Economy
The Pavlova and Gloria leather works were major employers but both are now closed. Alfred Booth and Company of Liverpool traded with the Pavlova Leather Syndicate from 1860, bought a share in it in 1917–18 and took it over in 1921. In May 1947 at the annual British Industries Fair in Birmingham, Pavlova advertised doe skins, chamois, lambskins and goatskins, much of it as suede, for uses including shoes, gloves and belts. In 1958 Pavlova's site covered , employed neary 200 people and included a staff sports field. At that time its factory still processed imported skins of sheep, lamb and goat, mainly to make suede. Garner Group took over the Booth Group in 1979 and became Garner Booth. Pittards plc took over Garner Booth in 1987 and became Pittard Garner. It closed the Pavlova works in 1993.
Abingdon was originally home to the Morland Brewery, whose most famous ale was Old Speckled Hen, named after an early MG car. Greene King Brewery bought Morland for £182 million in 1999, closed the brewery and moved production to Bury St Edmunds in Suffolk. The site of the brewery has been redeveloped into housing. The Maltings was demolished and is now a mixed residential area and council offices. In 2010, a craft brewery, Loose Cannon, reinstated brewing in the town at the Drayton Road Industrial Estate and sells its beers locally, including on draught at some local pubs. Abingdon is near several major scientific employers: the UKAEA at Culham (including the Joint European Torus (JET) fusion research project), Harwell Laboratory, the STFC Rutherford Appleton Laboratory and the new Diamond Light Source synchrotron, which is the largest UK-funded scientific facility to be built for over 40 years. Many inhabitants work in Oxford or commute by rail to London, from nearby Didcot. The Army now occupies Dalton Barracks, which, prior to 1993, was the Royal Air Force station RAF Abingdon.
Abingdon has a business park which has offices for several local, national and international companies including, until recently, Vodafone (acquired as part of its takeover of Mannesmann in 2000) and Northern Rock bank. The Science Park includes the global headquarters of Sophos, an anti-virus company. RM, an educational computing supplier, commonly refer to themselves as being Abingdon-based, which is technically true—even though their HQ is actually in nearby Milton Park, Milton, they have an Abingdon post code (as does the rest of Milton Park). Penlon Ltd, a medical equipment company, have their premises on the outskirts of Abingdon (their previous site, near the former railway station, has been redeveloped as residential housing). Another major employer is the British head office of the German appliance company Miele.
Industrially, Abingdon was best known for the MG car factory, which opened in 1929. 1,155,032 cars were made at the plant over the next 51 years until British Leyland closed it on 24 October 1980. Subsequent cars sold under the MG brand have since been produced either at Longbridge in Birmingham or at SAIC's factories in China. The company was founded in 1924 and moved its business alongside the Pavlova Leather Factory in 1929. By the outbreak of the Second World War, MG was established as one of the most popular brands of sports car in Britain. After the war, the MG factory continued to churn out increasing volumes of popular sports car which were available at competitive prices but the factory closed in October 1980 on the demise of the ageing but still popular MG MGB range, and was demolished within months. The headquarters of the MG Car Club, founded in 1930, is at 11 & 12 Cemetery Road, next to the old factory offices. A police station was built in its place, which was later extended with the addition of more cells, as Oxford's police station could not be extended further.
Geography and transport
Abingdon is south of Oxford, south-east of Witney and north of Newbury in the flat valley of the Thames on its west (right) bank, where the small river Ock flows in from the Vale of White Horse. It is on the A415 between Witney and Dorchester, adjacent to the A34 trunk road, linking it with the M4 and M40 motorways. The B4017 and A4183 also link the town, both being part of the old A34 and often heavily congested. Local bus services to Oxford and the surrounding areas are run by the Oxford Bus Company, its sister company Thames Travel and smaller independent companies.
Abingdon no longer has a rail service. However, in recent years, urban expansion has brought Radley railway station close to the town's northeastern limits. The small, primarily stopping-service, railway stations at and Radley are both just over from the town centre. Abingdon's eastern ring-road and newest suburbs are connected by footpath and cycleway from Radley.
Culham station was called "Abingdon Road" when it first opened in 1844, being the nearest station to the town at that time. It was renamed "Culham" when the Abingdon Railway branch line to Abingdon railway station was opened in 1856. That branch line initially connected to the main line at Abingdon Junction, before being extended to Radley station when that opened in 1873. The branch line from Radley to Abingdon closed to passengers in 1963. The nearest major stations with taxi ranks are () and (). All are managed by Great Western Railway. Frequent express buses operate between the local railway stations and Abingdon, run by Oxford Bus Company and its sister companies Thames Travel and Pulham's Coaches.
Governance
The town is also represented on Oxfordshire County Council. The incumbent Member of Parliament for Oxford West and Abingdon is Layla Moran (Liberal Democrat). Abingdon is represented on the Vale of White Horse district council, as well as having its own town council. Control of the town council has passed between the Liberal Democrats and Conservatives in recent years. After the 2019 local elections, political composition of the council is:
Liberal Democrats – 18 seats
Green Party – 1 seat
Places of interest
Of the Benedictine Abingdon Abbey there remains a Perpendicular gateway and ruins of the mainly Early English prior's house, the guest house and other fragments. Other remains from the former abbey include the Unicorn Theatre and Long Gallery, which are still used for plays and functions including an annual craft fair. St. Nicolas' Church, parts of which were built in 1180, is near the museum. Abingdon Bridge over the Thames, near St Helen's Church, was built in 1416 and was widened or altered in 1790, 1828, 1927 and 1929. Abbey Gateway between the Abingdon County Hall Museum and the Guildhall remains a point of local importance.
Abingdon has the remains of a motte-and-bailey castle, which can be found to the north of the town centre surrounded by trees within a housing estate. Originally built of wood or stone, it was a fortification on a raised earthwork called a motte surrounded by a protective ditch. There is a Second World War FW3/28A pillbox by the River Ock near Marcham Road. A gaol, built by prisoners of the Napoleonic Wars in 1811, is on the south edge of town next to the Thames. In the 1970s the gaol was converted into a leisure centre. In 2011 the site was developed into residential and commercial premises. According to local legend, prior to its conversion in the 1970s, the gaol was haunted by the ghost of an eight-year-old boy who, after being convicted for arson in the mid-19th century, became the youngest person in the UK to be executed by hanging.
The Roysse Room was the site of Abingdon School (then 'Roysse's School') from 1563 until it moved to its current site after an indenture by John Roysse, who had been born and educated in Abingdon before he moved to London. The room is now part of the civic offices. St. Helen's Church dates from around 1100 and is the second-widest church in England, having five aisles and being wider than it is long. The tower of St Helen's Church has a modern ring of ten bells, cast by the Whitechapel Bell Foundry in 2005 and hung in a new frame with new fittings by White's of Appleton in 2006. Abingdon's county hall by the main market square, built in 1677–1680 reputedly by Christopher Kempster, stands on columns, leaving the ground floor open for a market and other functions. It was once hailed by Nikolaus Pevsner with the comment "Of the free-standing town halls of England with open ground floors this is the grandest". It now houses the Abingdon County Hall Museum and is run by Historic England.
Culture and folklore
Bun-throwing is an Abingdon tradition that began with the 1761 Coronation of King George III. This long-standing tradition of the town has local dignitaries throwing buns (5,000 buns in 2018) from the roof of the Abingdon County Hall Museum into crowds assembled in the market square below on specific days of celebration (such as royal marriages, coronations and jubilees). The museum has a collection of the buns, dried and varnished, dating back to bun-throwings of the 19th century. To date there have been 35 bun-throwing events. Since 2000, there have been bun-throwing ceremonies to commemorate the Millennium, the Golden Jubilee of Queen Elizabeth II in 2002, the 450th anniversary of the town's being granted a royal charter in 2006, the Royal Wedding of Prince William and Catherine Middleton in 2011, the Diamond Jubilee of Elizabeth II in 2012, the centenary of the end of the World War I in November 2018 and the Platinum Jubilee of Elizabeth II in 2022.
The centre of town and the whole of Ock Street (half a mile) are closed every October for two days for the Ock Street Michaelmas Fair, once a hiring fair but now maybe Britain's longest and narrowest funfair. The much smaller Runaway Fair, the following Monday, was traditionally for workers who were unsatisfied with their employment after the first week. Abingdon has a very old and still active Morris dancing tradition, passed on since before the folk dance and song revivals in the 19th century. Every year a Mayor of Ock Street is elected by the inhabitants of Ock Street; he then parades through the town preceded by the famous Horns of Ock Street, a symbol of Abingdon's Morris Dance troupe.
The Friends of Abingdon's Unicorn Theatre, housed in the old Abbey buildings, is the site of first productions of many stage adaptations of Terry Pratchett's Discworld novels, by Stephen Briggs. Old Speckled Hen ale was originally brewed by Morland's of Abingdon to commemorate the MG factory in the town. It continues to be brewed by Greene King along with several complementary beers. The rock band Radiohead formed at Abingdon School in 1985.
Abingdonians
See also Abbot of Abingdon, Abingdon School and List of Old Abingdonians.
Ælfric of Abingdon, 10th-century Archbishop of Canterbury
Alexander of Abingdon, late 13th-century/early-14th-century sculptor
Sammy Chung, British former football manager
John Creemer Clarke (1821–95), clothing manufacturer (Hyde and Clarke), JP, MP, benefactor
Oswald Couldrey (1882–1958), British artist, poet and author
Gerald Charles Dickens, actor and great great grandson of Charles Dickens, lives in Abingdon
Kate Edger was born in Abingdon and became the first NZ woman graduate
Saint Edmund of Abingdon, 13th-century Archbishop of Canterbury, was born in Abingdon, as were his sisters, Saint Alice of Catesby and the Blessed Margaret Rich
Kate Garraway, former GMTV and now Daybreak presenter, born in Abingdon and attended Fitzharrys school
Michelle Goodman, Pilot and First Female Pilot to receive the DFC (b. 1976), lives in Abingdon.
Tom Hingley, lead singer of Oldham band Inspiral Carpets
David Jessel, BBC foreign correspondent and justice campaigner, born in Abingdon
Francis Maude, Conservative Party MP, born in Abingdon and attended Abingdon School
Paul Mayhew-Archer, comedy writer and actor. Taught drama at John Mason School and co-wrote The Vicar of Dibley; currently lives in Abingdon
Alain Menu, World Touring Car Championship driver, lives in Abingdon
David Mitchell, actor and comedian, attended Abingdon School
Tom Penny, professional skateboarder: skateboards for Flip Skateboards and attended Fitzharrys School
Radiohead, the rock band, formed as students at Abingdon School
Dorothy Richardson, novelist, born in Abingdon. She was the first writer to publish an English-language novel using what was to become known as the stream-of-consciousness technique.
John Spiers, melodeon player best known as a member of the band Bellowhead which broke up in 2016
Stephen of Abingdon, 14th-century Lord Mayor of the City of London
Matthew Taylor, footballer, grew up in the town and attended John Mason School
Thomas Tesdale, 16th-century local benefactor and eventual founder of Pembroke College, Oxford
Sir Henry Tombs (1825–74), a recipient of the Victoria Cross
Oliver Tompsett, West End star, best known for appearing as Fiyero in the musical Wicked at the Apollo Victoria Theatre in London
Dean Whitehead, footballer, was born in Abingdon
Kit Young, actor from Abingdon
Education
Abingdon and Witney College: provides further education.
Abingdon School: private, boys, 11–18.
The Consortium: local authority, mixed, a partnership of schools including Abingdon and Witney College and the following secondary schools:
Fitzharrys School
Larkmead School
John Mason School
Europa School, UK which replaced European School, Culham.
Our Lady's Abingdon: private, mixed, 3–18.
School of St Helen and St Katharine: private, girls, 9–18.
International relations
Abingdon is twinned with:
Argentan, France
Sint-Niklaas, Belgium
Schongau, Germany
Lucca, Italy
Freedom of the Town
The following people and military units have received the Freedom of the Town of Abingdon-on-Thames.
Military Units
RAF Abingdon: 1955.
12 Regiment, RLC: 8 December 2010.
See also
Abingdon Monks' Map
The Abingdon Sword
Albert Park, Abingdon
Our Lady and St Edmund's Church, Abingdon
References
Citations
Sources
External links
Abingdon Council history
Civil parishes in Oxfordshire
Former county towns in England
Market towns in Oxfordshire
Populated places on the River Thames
Vale of White Horse
|
Stefan Matthew Wever (April 22, 1958 – December 27, 2022) was a German-born American professional baseball pitcher, who played a single Major League Baseball game with the New York Yankees in 1982, recording the loss, a 27.00 earned run average (ERA), and two strikeouts in that game.
Born in West Germany, Wever moved to the United States as a child, where he took up baseball. He played baseball in high school and the University of California, Santa Barbara, which led to him being drafted by the New York Yankees. After four seasons in the minor leagues, Wever made his major league debut on September 17, 1982. In his debut, he suffered a shoulder injury, which he tried to pitch through for two years before having surgery in 1984. He tried to come back from the injury in 1985, but retired. After retiring, he opened a bar in San Francisco, which he continued to run.
Early life
Wever was born in Marburg, West Germany, in 1958. He immigrated to the United States with his mother and twin sister at six and lived in Boston until he was 12, when he moved to San Francisco. He attended Lowell High School, where he played on the school's baseball team. During his senior year, Wever helped lead the Lowell Cardinals to the city championship game, and he graduated in 1976.
After graduating from high school, Wever was not looked at by college recruiters due to a lack of competition he faced. As a result, he attended the University of California, Santa Barbara on an academic scholarship, and walked on to the school's baseball team. In three seasons with the Santa Barbara Gauchos, he had 18 wins, 17 losses, 199 strikeouts, and 15 complete games; the losses and complete games were at that time school records. After his junior year, Wever was drafted by the New York Yankees in the sixth round of the 1979 Major League Baseball draft. He was given a signing bonus of $16,000, and officially signed with the team shortly after the draft concluded.
Baseball career
Wever began his professional career in 1979 with the Oneonta Yankees of the New York–Penn League (NYPL). He pitched in ten games for the team, finishing the season with a 6–3 record, a 1.77 earned run average (ERA), and 70 strikeouts. In the Yankees' championship series against the Geneva Cubs, he pitched a shutout and threw nine strikeouts to win the first game and help the Yankees win the NYPL Championship. The following year, Wever was promoted to the Fort Lauderdale Yankees of the Florida State League. That year, he had a 7–3 record, a 3.64 ERA and 94 innings pitched in 15 games.
In 1981, Wever began the season remaining with Fort Lauderdale. He had a 7–3 record and a 2.00 ERA in 12 games before being promoted to the Nashville Sounds of the Southern League, the Yankees' AA affiliate. With Nashville, he had a 5–2 record and 2.05 ERA in nine appearances. Wever's pitching coach in Nashville was Hall of Famer Hoyt Wilhelm. Wilhelm felt he had the ability but not the confidence to pitch in the majors, and spent his time in Nashville working on that aspect of Wever's game. The following season, Weber was almost unanimously named to the Southern League All-Star team, thanks to 11 wins and 116 strikeouts through the end of June. He improved to a 16–6 record, a 2.78 ERA, and 191 strikeouts, won the Southern League Most Outstanding Pitcher Award, and accomplished the pitcher's Triple Crown, leading the league in wins, ERA, and strikeouts. He led Nashville to the Southern League championship, and right after doing so, the Yankees called Wever up to the major leagues.
His first and only major league appearance came against the Milwaukee Brewers on September 17, 1982. The first two batters he faced were Paul Molitor and Robin Yount, both future Hall of Famers, one of only a few players in history to do so. The fourth batter he faced was Ted Simmons, also a future Hall of Famer. Partway through the first inning, he felt a twinge in his shoulder; not wanting to leave his first game early, he pitched through it, and allowed five runs in the first. Partway through the third, after three more runs allowed, Wever was taken out of the game. He pitched for innings and had eight earned runs, two strikeouts, and three wild pitches. Entering the 1983 season, Wever was projected to be the fifth starter in the Yankees' starting rotation. Because of continued pain in his shoulder, he instead spent the season with the AAA Columbus Clippers, where he went 1–4 with a 9.78 ERA in seven appearances.
Wever spent 1984 with Fort Lauderdale, where he went 1–3 in seven games. After the seven games, he visited Dr. James Andrews, who diagnosed the twinge he suffered two years earlier as a torn rotator cuff and torn labrum; it explained why he had been throwing 85 mph since the injury, compared to 95 mph beforehand. He had surgery shortly afterward, and spent the rest of the year rehabbing the injury. He attempted a comeback in 1985 with the Albany-Colonie Yankees, and had a 4.91 ERA in five games with the team. In June, having continued to pitch through shoulder pain, Wever retired from baseball and ended his professional career.
Post-playing career
After retiring from baseball, Wever returned to school, and earned a bachelor's degree in English literature from the University of California, Berkeley. He married Melinda in 1988, and three years later opened up the Horseshoe Tavern, a bar in San Francisco's Marina District, which he continues to run.
While working at his bar, Wever made a return to baseball in a coaching role. He was named varsity baseball coach at Redwood High School in Larkspur, California in 2008, after having volunteered for the freshman team the year before. Wever was forced to resign in 2010 due to a diagnosis of large-cell lymphoma. He went on to continue coaching youth baseball camps and leagues, and was bench coach for the San Rafael Pacifics in 2013.
Personal life and death
Wever later spent three days a week feeding the homeless at SF's St. Anthony's Dining Room.
In 2019, Wever moved to Portland, Oregon, to be near his daughter. He continued to be active in volunteering and traveled to San Francisco once a month to continue volunteering at St. Anthony's and to look after his business.
Wever died on December 27, 2022, at the age of 64.
References
External links
Stefan Wever at SABR (Baseball BioProject)
1958 births
2022 deaths
Major League Baseball players from Germany
New York Yankees players
Major League Baseball pitchers
Nashville Sounds players
UC Santa Barbara Gauchos baseball players
Oneonta Yankees players
Fort Lauderdale Yankees players
Columbus Clippers players
Albany-Colonie Yankees players
Sportspeople from Marburg
Lowell High School (San Francisco) alumni
|
Eagles is the debut studio album by American rock band the Eagles. The album was recorded at London's Olympic Studios with producer Glyn Johns and released in 1972. The album was an immediate success for the young band, reaching No. 22 on the charts and going platinum. Three singles were released from the album, each reaching the Top 40: "Take It Easy" (number 12), "Witchy Woman" (number 9), and "Peaceful Easy Feeling" (number 22). The band, starting with this album, played a major role in popularizing the country rock sound.
The album was ranked number 368 in the 2012 edition of Rolling Stone magazine's list of the 500 greatest albums of all time, and at number 207 in the 2020 reboot of the list. The single "Take It Easy" is part of the Rock and Roll Hall of Fame "500 Songs That Shaped Rock and Roll".
Background
In 1971, the band had just been formed and signed by David Geffen, who then sent them to Aspen, Colorado, to develop as a band. For their first album, Glenn Frey wanted Glyn Johns to be the producer as they liked a number of rock albums engineered by Johns, including albums by the Rolling Stones, the Who, and Led Zeppelin. Johns was invited by Geffen to see the band perform at a club called Tulagi in Boulder, Colorado, in December 1971. Johns, however, was not impressed by the band's live performance, thinking that it sounded confused and lacking in cohesion - Frey wanted it to be a rock & roll band while Bernie Leadon wanted a country feel—so Johns declined to produce the album.
Johns was persuaded by Geffen to have a second listen in a rehearsal setting in Los Angeles, but Johns did not change his opinion of the band until all four started singing harmonies with acoustic guitar on a ballad written by Meisner, "Take the Devil". Johns was impressed by their harmony singing, and later said: "There it was, the sound. Extraordinary blend of voices, wonderful harmony sound, just stunning." In the albums he produced for the Eagles, Johns emphasized the vocal blend of the band, and he has been credited with shaping the band into "the country-rock band with those high-flyin' harmonies."
Recording
The band went to London, where they spent two weeks recording the album at the Olympic Studios. The album cost $125,000 to produce. Johns tried to introduce a more acoustic sound in the recording, and concentrated on the vocal blend and arrangements. There were however frequent disagreements over the sound of the band between the producer and Frey and Don Henley during the making of the album. Frey and Henley wanted a rougher rock and roll sound, while Johns was interested in using Bernie Leadon's banjo and Randy Meisner's bass to create a more country sound. Frey later admitted: "[Johns] was the key to our success in a lot of ways", but added: "We just didn’t want to make another limp-wristed L.A. country-rock record." Johns also instituted a no-drug and no-alcohol rule that Frey, but not Henley, was unhappy about.
Three of the songs recorded in London feature Frey on lead vocals, another three with Meisner and two with Leadon. The chirping sound at the start of the song by Leadon and Meisner, "Earlybird", was taken from a sound effect library. On "Take It Easy", Johns convinced Leadon to play double-time banjo on the song, a touch that Johns felt made the song different.
Originally, Henley co-wrote and sang one song on the album, "Witchy Woman". Later, a further track, "Nightingale", was recorded in Los Angeles after Geffen and manager Elliot Roberts listened to the tape of the album and decided that it needed another song with Henley on lead vocals. Johns had previously recorded a few takes of the song in London, but abandoned it as he felt it did not work. Geffen tried to get the song recorded with another production team, and Johns, angered by the attempt to record "Nightingale" behind his back, then re-recorded the song with the band at Wally Heider's Studio 3 in Hollywood. Even though Johns judged this recording unsatisfactory, it was included in the album.
The album was slated for Quadraphonic release and even given a Quadraphonic catalog number but it was never released in that format.
Artwork
The album artwork was created by album cover artist Gary Burden with photography by Henry Diltz. The album was initially designed as a gatefold album that would further open up into a poster; however Geffen thought it would be confusing, and glued it together so that it would not open, and the gatefold image of the band members at Joshua Tree then became orientated the wrong side up. In the documentary History of the Eagles, Glenn Frey revealed that the band were all on peyote when the gatefold picture of the band members was shot in Joshua Tree National Park.
Critical reception
Reviewing in 1972, Bud Scoppa of Rolling Stone believed the Eagles had "distinguished" country-rock backgrounds, and said the album is "right behind Jackson Browne's record as the best first album this year. And I could be persuaded to remove the word 'first' from that statement". In Christgau's Record Guide: Rock Albums of the Seventies (1981), Robert Christgau felt that the band wrote good songs, but he was unsure about the authenticity of their country roots so what they produced was "suave and synthetic-brilliant, but false".
Allmusic's William Ruhlmann, in his retrospective review, sums up the album as balanced in terms of songwriting, but noting that the three hit singles were sung by Frey and Henley, who would later go on to dominate the band. Rolling Stone listed it as number 368 on their 2012 edition of the 500 greatest albums of all time list with the comment that the album "created a new template for laid-back L.A. country-rock style". It rose to number 207 in the 2020 edition of the list. It was included in Robert Dimery's 1001 Albums You Must Hear Before You Die.
Ultimate Classic Rock critic Sterling Whitaker rated the non-single album track "Most of Us Are Sad" as being among the Eagles' 10 most underrated songs.
Commercial performance
The album debuted on the US Billboard 200 chart at number 102 in its first week of release, rising at number 22 in its sixth week on the chart. The album was certified platinum by the Recording Industry Association of America (RIAA) on March 20, 2001 for shipment of 1 million copies in the United States.
Track listing
Personnel
Eagles
Glenn Frey – vocals, guitars, slide guitar, piano, clavinet, synthesizer, keyboard
Don Henley – vocals, drums, percussion, synthesizer
Bernie Leadon – vocals, guitars, banjo, Dobro, mandolin
Randy Meisner – vocals, bass guitar
Production
Gary Burden – art direction, design
Henry Diltz – photography
Glyn Johns – producer, engineer
Charts
Certifications
References
Eagles (band) albums
1972 debut albums
Elektra Records albums
Asylum Records albums
Albums produced by Glyn Johns
Albums recorded at Wally Heider Studios
Albums recorded at Olympic Sound Studios
|
```objective-c
// 2016 and later: Unicode, Inc. and others.
/*
*******************************************************************************
*
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
*
* File reslist.h
*
* Modification History:
*
* Date Name Description
* 02/21/00 weiv Creation.
*******************************************************************************
*/
#ifndef RESLIST_H
#define RESLIST_H
#define KEY_SPACE_SIZE 65536
#define RESLIST_MAX_INT_VECTOR 2048
#include <functional>
#include "unicode/utypes.h"
#include "unicode/unistr.h"
#include "unicode/ures.h"
#include "unicode/ustring.h"
#include "cmemory.h"
#include "cstring.h"
#include "uhash.h"
#include "unewdata.h"
#include "uresdata.h"
#include "ustr.h"
U_CDECL_BEGIN
class PathFilter;
class PseudoListResource;
class ResKeyPath;
struct ResFile {
ResFile()
: fBytes(NULL), fIndexes(NULL),
fKeys(NULL), fKeysLength(0), fKeysCount(0),
fStrings(NULL), fStringIndexLimit(0),
fChecksum(0) {}
~ResFile() { close(); }
void close();
uint8_t *fBytes;
const int32_t *fIndexes;
const char *fKeys;
int32_t fKeysLength;
int32_t fKeysCount;
PseudoListResource *fStrings;
int32_t fStringIndexLimit;
int32_t fChecksum;
};
struct SResource;
typedef struct KeyMapEntry {
int32_t oldpos, newpos;
} KeyMapEntry;
/* Resource bundle root table */
struct SRBRoot {
SRBRoot(const UString *comment, UBool isPoolBundle, UErrorCode &errorCode);
~SRBRoot();
void write(const char *outputDir, const char *outputPkg,
char *writtenFilename, int writtenFilenameLen, UErrorCode &errorCode);
void setLocale(UChar *locale, UErrorCode &errorCode);
int32_t addTag(const char *tag, UErrorCode &errorCode);
const char *getKeyString(int32_t key) const;
const char *getKeyBytes(int32_t *pLength) const;
int32_t addKeyBytes(const char *keyBytes, int32_t length, UErrorCode &errorCode);
void compactKeys(UErrorCode &errorCode);
int32_t makeRes16(uint32_t resWord) const;
int32_t mapKey(int32_t oldpos) const;
private:
void compactStringsV2(UHashtable *stringSet, UErrorCode &errorCode);
public:
// TODO: private
SResource *fRoot; // Normally a TableResource.
char *fLocale;
int32_t fIndexLength;
int32_t fMaxTableLength;
UBool fNoFallback; /* see URES_ATT_NO_FALLBACK */
int8_t fStringsForm; /* default STRINGS_UTF16_V1 */
UBool fIsPoolBundle;
char *fKeys;
KeyMapEntry *fKeyMap;
int32_t fKeysBottom, fKeysTop;
int32_t fKeysCapacity;
int32_t fKeysCount;
int32_t fLocalKeyLimit; /* key offset < limit fits into URES_TABLE */
icu::UnicodeString f16BitUnits;
int32_t f16BitStringsLength;
const ResFile *fUsePoolBundle;
int32_t fPoolStringIndexLimit;
int32_t fPoolStringIndex16Limit;
int32_t fLocalStringIndexLimit;
SRBRoot *fWritePoolBundle;
};
/* write a java resource file */
// TODO: C++ify
void bundle_write_java(struct SRBRoot *bundle, const char *outputDir, const char* outputEnc, char *writtenFilename,
int writtenFilenameLen, const char* packageName, const char* bundleName, UErrorCode *status);
/* write a xml resource file */
// TODO: C++ify
void bundle_write_xml(struct SRBRoot *bundle, const char *outputDir,const char* outputEnc, const char* rbname,
char *writtenFilename, int writtenFilenameLen, const char* language, const char* package, UErrorCode *status);
/* Various resource types */
/*
* Return a unique pointer to a dummy object,
* for use in non-error cases when no resource is to be added to the bundle.
* (NULL is used in error cases.)
*/
struct SResource* res_none(void);
class ArrayResource;
class TableResource;
class IntVectorResource;
TableResource *table_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status);
ArrayResource *array_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status);
struct SResource *string_open(struct SRBRoot *bundle, const char *tag, const UChar *value, int32_t len, const struct UString* comment, UErrorCode *status);
struct SResource *alias_open(struct SRBRoot *bundle, const char *tag, UChar *value, int32_t len, const struct UString* comment, UErrorCode *status);
IntVectorResource *intvector_open(struct SRBRoot *bundle, const char *tag, const struct UString* comment, UErrorCode *status);
struct SResource *int_open(struct SRBRoot *bundle, const char *tag, int32_t value, const struct UString* comment, UErrorCode *status);
struct SResource *bin_open(struct SRBRoot *bundle, const char *tag, uint32_t length, uint8_t *data, const char* fileName, const struct UString* comment, UErrorCode *status);
/* Resource place holder */
struct SResource {
SResource();
SResource(SRBRoot *bundle, const char *tag, int8_t type, const UString* comment,
UErrorCode &errorCode);
virtual ~SResource();
UBool isTable() const { return fType == URES_TABLE; }
UBool isString() const { return fType == URES_STRING; }
const char *getKeyString(const SRBRoot *bundle) const;
/**
* Preflights strings.
* Finds duplicates and counts the total number of string code units
* so that they can be written first to the 16-bit array,
* for minimal string and container storage.
*
* We walk the final parse tree, rather than collecting this information while building it,
* so that we need not deal with changes to the parse tree (especially removing resources).
*/
void preflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode);
virtual void handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode);
/**
* Writes resource values into f16BitUnits
* and determines the resource item word, if possible.
*/
void write16(SRBRoot *bundle);
virtual void handleWrite16(SRBRoot *bundle);
/**
* Calculates ("preflights") and advances the *byteOffset
* by the size of the resource's data in the binary file and
* determines the resource item word.
*
* Most handlePreWrite() functions may add any number of bytes, but preWrite()
* will always pad it to a multiple of 4.
* The resource item type may be a related subtype of the fType.
*
* The preWrite() and write() functions start and end at the same
* byteOffset values.
* Prewriting allows bundle.write() to determine the root resource item word,
* before actually writing the bundle contents to the file,
* which is necessary because the root item is stored at the beginning.
*/
void preWrite(uint32_t *byteOffset);
virtual void handlePreWrite(uint32_t *byteOffset);
/**
* Writes the resource's data to mem and updates the byteOffset
* in parallel.
*/
void write(UNewDataMemory *mem, uint32_t *byteOffset);
virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
/**
* Applies the given filter with the given base path to this resource.
* Removes child resources rejected by the filter recursively.
*
* @param bundle Needed in order to access the key for this and child resources.
*/
virtual void applyFilter(const PathFilter& filter, ResKeyPath& path, const SRBRoot* bundle);
/**
* Calls the given function for every key ID present in this tree.
*/
virtual void collectKeys(std::function<void(int32_t)> collector) const;
int8_t fType; /* nominal type: fRes (when != 0xffffffff) may use subtype */
UBool fWritten; /* res_write() can exit early */
uint32_t fRes; /* resource item word; RES_BOGUS=0xffffffff if not known yet */
int32_t fRes16; /* Res16 version of fRes for Table, Table16, Array16; -1 if it does not fit. */
int32_t fKey; /* Index into bundle->fKeys; -1 if no key. */
int32_t fKey16; /* Key16 version of fKey for Table & Table16; -1 if no key or it does not fit. */
int line; /* used internally to report duplicate keys in tables */
SResource *fNext; /* This is for internal chaining while building */
struct UString fComment;
};
class ContainerResource : public SResource {
public:
ContainerResource(SRBRoot *bundle, const char *tag, int8_t type,
const UString* comment, UErrorCode &errorCode)
: SResource(bundle, tag, type, comment, errorCode),
fCount(0), fFirst(NULL) {}
virtual ~ContainerResource();
void handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode) override;
void collectKeys(std::function<void(int32_t)> collector) const override;
protected:
void writeAllRes16(SRBRoot *bundle);
void preWriteAllRes(uint32_t *byteOffset);
void writeAllRes(UNewDataMemory *mem, uint32_t *byteOffset);
void writeAllRes32(UNewDataMemory *mem, uint32_t *byteOffset);
public:
// TODO: private with getter?
uint32_t fCount;
SResource *fFirst;
};
class TableResource : public ContainerResource {
public:
TableResource(SRBRoot *bundle, const char *tag,
const UString* comment, UErrorCode &errorCode)
: ContainerResource(bundle, tag, URES_TABLE, comment, errorCode),
fTableType(URES_TABLE), fRoot(bundle) {}
virtual ~TableResource();
void add(SResource *res, int linenumber, UErrorCode &errorCode);
void handleWrite16(SRBRoot *bundle) override;
void handlePreWrite(uint32_t *byteOffset) override;
void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset) override;
void applyFilter(const PathFilter& filter, ResKeyPath& path, const SRBRoot* bundle) override;
int8_t fTableType; // determined by table_write16() for table_preWrite() & table_write()
SRBRoot *fRoot;
};
class ArrayResource : public ContainerResource {
public:
ArrayResource(SRBRoot *bundle, const char *tag,
const UString* comment, UErrorCode &errorCode)
: ContainerResource(bundle, tag, URES_ARRAY, comment, errorCode),
fLast(NULL) {}
virtual ~ArrayResource();
void add(SResource *res);
virtual void handleWrite16(SRBRoot *bundle);
virtual void handlePreWrite(uint32_t *byteOffset);
virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
SResource *fLast;
};
/**
* List of resources for a pool bundle.
* Writes an empty table resource, rather than a container structure.
*/
class PseudoListResource : public ContainerResource {
public:
PseudoListResource(SRBRoot *bundle, UErrorCode &errorCode)
: ContainerResource(bundle, NULL, URES_TABLE, NULL, errorCode) {}
virtual ~PseudoListResource();
void add(SResource *res);
virtual void handleWrite16(SRBRoot *bundle);
};
class StringBaseResource : public SResource {
public:
StringBaseResource(SRBRoot *bundle, const char *tag, int8_t type,
const UChar *value, int32_t len,
const UString* comment, UErrorCode &errorCode);
StringBaseResource(SRBRoot *bundle, int8_t type,
const icu::UnicodeString &value, UErrorCode &errorCode);
StringBaseResource(int8_t type, const UChar *value, int32_t len, UErrorCode &errorCode);
virtual ~StringBaseResource();
const UChar *getBuffer() const { return icu::toUCharPtr(fString.getBuffer()); }
int32_t length() const { return fString.length(); }
virtual void handlePreWrite(uint32_t *byteOffset);
virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
// TODO: private with getter?
icu::UnicodeString fString;
};
class StringResource : public StringBaseResource {
public:
StringResource(SRBRoot *bundle, const char *tag, const UChar *value, int32_t len,
const UString* comment, UErrorCode &errorCode)
: StringBaseResource(bundle, tag, URES_STRING, value, len, comment, errorCode),
fSame(NULL), fSuffixOffset(0),
fNumCopies(0), fNumUnitsSaved(0), fNumCharsForLength(0) {}
StringResource(SRBRoot *bundle, const icu::UnicodeString &value, UErrorCode &errorCode)
: StringBaseResource(bundle, URES_STRING, value, errorCode),
fSame(NULL), fSuffixOffset(0),
fNumCopies(0), fNumUnitsSaved(0), fNumCharsForLength(0) {}
StringResource(int32_t poolStringIndex, int8_t numCharsForLength,
const UChar *value, int32_t length,
UErrorCode &errorCode)
: StringBaseResource(URES_STRING, value, length, errorCode),
fSame(NULL), fSuffixOffset(0),
fNumCopies(0), fNumUnitsSaved(0), fNumCharsForLength(numCharsForLength) {
// v3 pool string encoded as string-v2 with low offset
fRes = URES_MAKE_RESOURCE(URES_STRING_V2, poolStringIndex);
fWritten = TRUE;
}
virtual ~StringResource();
int32_t get16BitStringsLength() const {
return fNumCharsForLength + length() + 1; // +1 for the NUL
}
virtual void handlePreflightStrings(SRBRoot *bundle, UHashtable *stringSet, UErrorCode &errorCode);
virtual void handleWrite16(SRBRoot *bundle);
void writeUTF16v2(int32_t base, icu::UnicodeString &dest);
StringResource *fSame; // used for duplicates
int32_t fSuffixOffset; // this string is a suffix of fSame at this offset
int32_t fNumCopies; // number of equal strings represented by one stringSet element
int32_t fNumUnitsSaved; // from not writing duplicates and suffixes
int8_t fNumCharsForLength;
};
class AliasResource : public StringBaseResource {
public:
AliasResource(SRBRoot *bundle, const char *tag, const UChar *value, int32_t len,
const UString* comment, UErrorCode &errorCode)
: StringBaseResource(bundle, tag, URES_ALIAS, value, len, comment, errorCode) {}
virtual ~AliasResource();
};
class IntResource : public SResource {
public:
IntResource(SRBRoot *bundle, const char *tag, int32_t value,
const UString* comment, UErrorCode &errorCode);
virtual ~IntResource();
// TODO: private with getter?
int32_t fValue;
};
class IntVectorResource : public SResource {
public:
IntVectorResource(SRBRoot *bundle, const char *tag,
const UString* comment, UErrorCode &errorCode);
virtual ~IntVectorResource();
void add(int32_t value, UErrorCode &errorCode);
virtual void handlePreWrite(uint32_t *byteOffset);
virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
// TODO: UVector32
uint32_t fCount;
uint32_t *fArray;
};
class BinaryResource : public SResource {
public:
BinaryResource(SRBRoot *bundle, const char *tag,
uint32_t length, uint8_t *data, const char* fileName,
const UString* comment, UErrorCode &errorCode);
virtual ~BinaryResource();
virtual void handlePreWrite(uint32_t *byteOffset);
virtual void handleWrite(UNewDataMemory *mem, uint32_t *byteOffset);
// TODO: CharString?
uint32_t fLength;
uint8_t *fData;
// TODO: CharString
char* fFileName; // file name for binary or import binary tags if any
};
// TODO: use LocalPointer or delete
void res_close(struct SResource *res);
void setFormatVersion(int32_t formatVersion);
int32_t getFormatVersion();
void setUsePoolBundle(UBool use);
/* in wrtxml.cpp */
uint32_t computeCRC(const char *ptr, uint32_t len, uint32_t lastcrc);
U_CDECL_END
#endif /* #ifndef RESLIST_H */
```
|
George Curtis (17 August 1837 – 2 April 1885) was an Australian cricketer. He played two first-class matches for New South Wales between 1861/62 and 1865/66.
See also
List of New South Wales representative cricketers
References
External links
1837 births
1885 deaths
Australian cricketers
New South Wales cricketers
Cricketers from Sydney
|
```go
package externalcontact
import (
"encoding/json"
"fmt"
"github.com/silenceper/wechat/v2/util"
)
const (
// fetchExternalContactUserListURL
fetchExternalContactUserListURL = "path_to_url"
// fetchExternalContactUserDetailURL
fetchExternalContactUserDetailURL = "path_to_url"
// fetchBatchExternalContactUserDetailURL
fetchBatchExternalContactUserDetailURL = "path_to_url"
// updateUserRemarkURL
updateUserRemarkURL = "path_to_url"
// listCustomerStrategyURL
listCustomerStrategyURL = "path_to_url"
// getCustomerStrategyURL
getCustomerStrategyURL = "path_to_url"
// getRangeCustomerStrategyURL
getRangeCustomerStrategyURL = "path_to_url"
// createCustomerStrategyURL
createCustomerStrategyURL = "path_to_url"
// editCustomerStrategyURL
editCustomerStrategyURL = "path_to_url"
// delCustomerStrategyURL
delCustomerStrategyURL = "path_to_url"
)
// ExternalUserListResponse
type ExternalUserListResponse struct {
util.CommonError
ExternalUserID []string `json:"external_userid"`
}
// GetExternalUserList
// @see path_to_url
func (r *Client) GetExternalUserList(userID string) ([]string, error) {
accessToken, err := r.GetAccessToken()
if err != nil {
return nil, err
}
var response []byte
response, err = util.HTTPGet(fmt.Sprintf("%s?access_token=%v&userid=%v", fetchExternalContactUserListURL, accessToken, userID))
if err != nil {
return nil, err
}
var result ExternalUserListResponse
err = util.DecodeWithError(response, &result, "GetExternalUserList")
return result.ExternalUserID, err
}
// ExternalUserDetailResponse
type ExternalUserDetailResponse struct {
util.CommonError
ExternalContact ExternalUser `json:"external_contact"`
FollowUser []FollowUser `json:"follow_user"`
NextCursor string `json:"next_cursor"`
}
// ExternalUser
type ExternalUser struct {
ExternalUserID string `json:"external_userid"`
Name string `json:"name"`
Avatar string `json:"avatar"`
Type int64 `json:"type"`
Gender int64 `json:"gender"`
UnionID string `json:"unionid"`
Position string `json:"position"`
CorpName string `json:"corp_name"`
CorpFullName string `json:"corp_full_name"`
ExternalProfile *ExternalProfile `json:"external_profile,omitempty"`
}
// FollowUser
type FollowUser struct {
UserID string `json:"userid"`
Remark string `json:"remark"`
Description string `json:"description"`
CreateTime int64 `json:"createtime"`
Tags []Tag `json:"tags"`
RemarkCorpName string `json:"remark_corp_name"`
RemarkMobiles []string `json:"remark_mobiles"`
OperUserID string `json:"oper_userid"`
AddWay int64 `json:"add_way"`
WeChatChannels WechatChannel `json:"wechat_channels"`
State string `json:"state"`
}
// Tag
type Tag struct {
GroupName string `json:"group_name"`
TagName string `json:"tag_name"`
Type int64 `json:"type"`
TagID string `json:"tag_id"`
}
// WechatChannel
type WechatChannel struct {
NickName string `json:"nickname"`
Source int `json:"source"`
}
// ExternalProfile ,
type ExternalProfile struct {
ExternalCorpName string `json:"external_corp_name"`
WechatChannels WechatChannels `json:"wechat_channels"`
ExternalAttr []ExternalAttr `json:"external_attr"`
}
// WechatChannels
type WechatChannels struct {
Nickname string `json:"nickname"`
Status int `json:"status"`
}
// ExternalAttr
type ExternalAttr struct {
Type int `json:"type"`
Name string `json:"name"`
Text *Text `json:"text,omitempty"`
Web *Web `json:"web,omitempty"`
MiniProgram *MiniProgram `json:"miniprogram,omitempty"`
}
// Text
type Text struct {
Value string `json:"value"`
}
// Web
type Web struct {
URL string `json:"url"`
Title string `json:"title"`
}
// MiniProgram
type MiniProgram struct {
AppID string `json:"appid"`
Pagepath string `json:"pagepath"`
Title string `json:"title"`
}
// GetExternalUserDetail
// @see path_to_url
func (r *Client) GetExternalUserDetail(externalUserID string, nextCursor ...string) (*ExternalUserDetailResponse, error) {
accessToken, err := r.GetAccessToken()
if err != nil {
return nil, err
}
var response []byte
var cursor string
if len(nextCursor) > 0 {
cursor = nextCursor[0]
}
response, err = util.HTTPGet(fmt.Sprintf("%s?access_token=%v&external_userid=%v&cursor=%v", fetchExternalContactUserDetailURL, accessToken, externalUserID, cursor))
if err != nil {
return nil, err
}
result := &ExternalUserDetailResponse{}
err = util.DecodeWithError(response, result, "get_external_user_detail")
return result, err
}
// BatchGetExternalUserDetailsRequest
type BatchGetExternalUserDetailsRequest struct {
UserIDList []string `json:"userid_list"`
Cursor string `json:"cursor"`
Limit int `json:"limit,omitempty"`
}
// ExternalUserDetailListResponse
type ExternalUserDetailListResponse struct {
util.CommonError
ExternalContactList []ExternalUserForBatch `json:"external_contact_list"`
}
// ExternalUserForBatch
type ExternalUserForBatch struct {
ExternalContact ExternalContact `json:"external_contact"`
FollowInfo FollowInfo `json:"follow_info"`
}
// ExternalContact
type ExternalContact struct {
ExternalUserID string `json:"external_userid"`
Name string `json:"name"`
Position string `json:"position"`
Avatar string `json:"avatar"`
CorpName string `json:"corp_name"`
CorpFullName string `json:"corp_full_name"`
Type int64 `json:"type"`
Gender int64 `json:"gender"`
UnionID string `json:"unionid"`
ExternalProfile string `json:"external_profile"`
}
// FollowInfo
type FollowInfo struct {
UserID string `json:"userid"`
Remark string `json:"remark"`
Description string `json:"description"`
CreateTime int64 `json:"createtime"`
TagID []string `json:"tag_id"`
RemarkCorpName string `json:"remark_corp_name"`
RemarkMobiles []string `json:"remark_mobiles"`
OperUserID string `json:"oper_userid"`
AddWay int64 `json:"add_way"`
WeChatChannels WechatChannel `json:"wechat_channels"`
}
// BatchGetExternalUserDetails
// @see path_to_url
func (r *Client) BatchGetExternalUserDetails(request BatchGetExternalUserDetailsRequest) ([]ExternalUserForBatch, error) {
accessToken, err := r.GetAccessToken()
if err != nil {
return nil, err
}
var response []byte
jsonData, err := json.Marshal(request)
if err != nil {
return nil, err
}
response, err = util.HTTPPost(fmt.Sprintf("%s?access_token=%v", fetchBatchExternalContactUserDetailURL, accessToken), string(jsonData))
if err != nil {
return nil, err
}
var result ExternalUserDetailListResponse
err = util.DecodeWithError(response, &result, "BatchGetExternalUserDetails")
return result.ExternalContactList, err
}
// UpdateUserRemarkRequest
type UpdateUserRemarkRequest struct {
UserID string `json:"userid"`
ExternalUserID string `json:"external_userid"`
Remark string `json:"remark"`
Description string `json:"description"`
RemarkCompany string `json:"remark_company"`
RemarkMobiles []string `json:"remark_mobiles"`
RemarkPicMediaID string `json:"remark_pic_mediaid"`
}
// UpdateUserRemark
// @see path_to_url
func (r *Client) UpdateUserRemark(request UpdateUserRemarkRequest) error {
accessToken, err := r.GetAccessToken()
if err != nil {
return err
}
var response []byte
jsonData, err := json.Marshal(request)
if err != nil {
return err
}
response, err = util.HTTPPost(fmt.Sprintf("%s?access_token=%v", updateUserRemarkURL, accessToken), string(jsonData))
if err != nil {
return err
}
return util.DecodeWithCommonError(response, "UpdateUserRemark")
}
// ListCustomerStrategyRequest
type ListCustomerStrategyRequest struct {
Cursor string `json:"cursor"`
Limit int `json:"limit"`
}
// ListCustomerStrategyResponse
type ListCustomerStrategyResponse struct {
util.CommonError
Strategy []StrategyID `json:"strategy"`
NextCursor string `json:"next_cursor"`
}
// StrategyID ID
type StrategyID struct {
StrategyID int `json:"strategy_id"`
}
// ListCustomerStrategy
// @see path_to_url#%E8%8E%B7%E5%8F%96%E8%A7%84%E5%88%99%E7%BB%84%E5%88%97%E8%A1%A8
func (r *Client) ListCustomerStrategy(req *ListCustomerStrategyRequest) (*ListCustomerStrategyResponse, error) {
var (
accessToken string
err error
)
if accessToken, err = r.GetAccessToken(); err != nil {
return nil, err
}
var response []byte
if response, err = util.PostJSON(fmt.Sprintf(listCustomerStrategyURL, accessToken), req); err != nil {
return nil, err
}
result := &ListCustomerStrategyResponse{}
err = util.DecodeWithError(response, result, "ListCustomerStrategy")
return result, err
}
// GetCustomerStrategyRequest
type GetCustomerStrategyRequest struct {
StrategyID int `json:"strategy_id"`
}
// GetCustomerStrategyResponse
type GetCustomerStrategyResponse struct {
util.CommonError
Strategy Strategy `json:"strategy"`
}
// Strategy
type Strategy struct {
StrategyID int `json:"strategy_id"`
ParentID int `json:"parent_id"`
StrategyName string `json:"strategy_name"`
CreateTime int64 `json:"create_time"`
AdminList []string `json:"admin_list"`
Privilege Privilege `json:"privilege"`
}
// Privilege
type Privilege struct {
ViewCustomerList bool `json:"view_customer_list"`
ViewCustomerData bool `json:"view_customer_data"`
ViewRoomList bool `json:"view_room_list"`
ContactMe bool `json:"contact_me"`
JoinRoom bool `json:"join_room"`
ShareCustomer bool `json:"share_customer"`
OperResignCustomer bool `json:"oper_resign_customer"`
OperResignGroup bool `json:"oper_resign_group"`
SendCustomerMsg bool `json:"send_customer_msg"`
EditWelcomeMsg bool `json:"edit_welcome_msg"`
ViewBehaviorData bool `json:"view_behavior_data"`
ViewRoomData bool `json:"view_room_data"`
SendGroupMsg bool `json:"send_group_msg"`
RoomDeduplication bool `json:"room_deduplication"`
RapidReply bool `json:"rapid_reply"`
OnjobCustomerTransfer bool `json:"onjob_customer_transfer"`
EditAntiSpamRule bool `json:"edit_anti_spam_rule"`
ExportCustomerList bool `json:"export_customer_list"`
ExportCustomerData bool `json:"export_customer_data"`
ExportCustomerGroupList bool `json:"export_customer_group_list"`
ManageCustomerTag bool `json:"manage_customer_tag"`
}
// GetCustomerStrategy
// @see path_to_url#%E8%8E%B7%E5%8F%96%E8%A7%84%E5%88%99%E7%BB%84%E8%AF%A6%E6%83%85
func (r *Client) GetCustomerStrategy(req *GetCustomerStrategyRequest) (*GetCustomerStrategyResponse, error) {
var (
accessToken string
err error
)
if accessToken, err = r.GetAccessToken(); err != nil {
return nil, err
}
var response []byte
if response, err = util.PostJSON(fmt.Sprintf(getCustomerStrategyURL, accessToken), req); err != nil {
return nil, err
}
result := &GetCustomerStrategyResponse{}
err = util.DecodeWithError(response, result, "GetCustomerStrategy")
return result, err
}
// GetRangeCustomerStrategyRequest
type GetRangeCustomerStrategyRequest struct {
StrategyID int `json:"strategy_id"`
Cursor string `json:"cursor"`
Limit int `json:"limit"`
}
// GetRangeCustomerStrategyResponse
type GetRangeCustomerStrategyResponse struct {
util.CommonError
Range []Range `json:"range"`
NextCursor string `json:"next_cursor"`
}
// Range
type Range struct {
Type int `json:"type"`
UserID string `json:"userid,omitempty"`
PartyID int `json:"partyid,omitempty"`
}
// GetRangeCustomerStrategy
// @see path_to_url#%E8%8E%B7%E5%8F%96%E8%A7%84%E5%88%99%E7%BB%84%E7%AE%A1%E7%90%86%E8%8C%83%E5%9B%B4
func (r *Client) GetRangeCustomerStrategy(req *GetRangeCustomerStrategyRequest) (*GetRangeCustomerStrategyResponse, error) {
var (
accessToken string
err error
)
if accessToken, err = r.GetAccessToken(); err != nil {
return nil, err
}
var response []byte
if response, err = util.PostJSON(fmt.Sprintf(getRangeCustomerStrategyURL, accessToken), req); err != nil {
return nil, err
}
result := &GetRangeCustomerStrategyResponse{}
err = util.DecodeWithError(response, result, "GetRangeCustomerStrategy")
return result, err
}
// CreateCustomerStrategyRequest
type CreateCustomerStrategyRequest struct {
ParentID int `json:"parent_id"`
StrategyName string `json:"strategy_name"`
AdminList []string `json:"admin_list"`
Privilege Privilege `json:"privilege"`
Range []Range `json:"range"`
}
// CreateCustomerStrategyResponse
type CreateCustomerStrategyResponse struct {
util.CommonError
StrategyID int `json:"strategy_id"`
}
// CreateCustomerStrategy
// @see path_to_url#%E5%88%9B%E5%BB%BA%E6%96%B0%E7%9A%84%E8%A7%84%E5%88%99%E7%BB%84
func (r *Client) CreateCustomerStrategy(req *CreateCustomerStrategyRequest) (*CreateCustomerStrategyResponse, error) {
var (
accessToken string
err error
)
if accessToken, err = r.GetAccessToken(); err != nil {
return nil, err
}
var response []byte
if response, err = util.PostJSON(fmt.Sprintf(createCustomerStrategyURL, accessToken), req); err != nil {
return nil, err
}
result := &CreateCustomerStrategyResponse{}
err = util.DecodeWithError(response, result, "CreateCustomerStrategy")
return result, err
}
// EditCustomerStrategyRequest
type EditCustomerStrategyRequest struct {
StrategyID int `json:"strategy_id"`
StrategyName string `json:"strategy_name"`
AdminList []string `json:"admin_list"`
Privilege Privilege `json:"privilege"`
RangeAdd []Range `json:"range_add"`
RangeDel []Range `json:"range_del"`
}
// EditCustomerStrategy
// see path_to_url#%E7%BC%96%E8%BE%91%E8%A7%84%E5%88%99%E7%BB%84%E5%8F%8A%E5%85%B6%E7%AE%A1%E7%90%86%E8%8C%83%E5%9B%B4
func (r *Client) EditCustomerStrategy(req *EditCustomerStrategyRequest) error {
var (
accessToken string
err error
)
if accessToken, err = r.GetAccessToken(); err != nil {
return err
}
var response []byte
if response, err = util.PostJSON(fmt.Sprintf(editCustomerStrategyURL, accessToken), req); err != nil {
return err
}
return util.DecodeWithCommonError(response, "EditCustomerStrategy")
}
// DelCustomerStrategyRequest
type DelCustomerStrategyRequest struct {
StrategyID int `json:"strategy_id"`
}
// DelCustomerStrategy
// see path_to_url#%E5%88%A0%E9%99%A4%E8%A7%84%E5%88%99%E7%BB%84
func (r *Client) DelCustomerStrategy(req *DelCustomerStrategyRequest) error {
var (
accessToken string
err error
)
if accessToken, err = r.GetAccessToken(); err != nil {
return err
}
var response []byte
if response, err = util.PostJSON(fmt.Sprintf(delCustomerStrategyURL, accessToken), req); err != nil {
return err
}
return util.DecodeWithCommonError(response, "DelCustomerStrategy")
}
```
|
```go
package tenancy
import (
"flag"
"fmt"
"strings"
"github.com/spf13/viper"
)
const (
flagPrefix = "multi-tenancy"
flagTenancyEnabled = flagPrefix + ".enabled"
flagTenancyHeader = flagPrefix + ".header"
flagValidTenants = flagPrefix + ".tenants"
)
// AddFlags adds flags for tenancy to the FlagSet.
func AddFlags(flags *flag.FlagSet) {
flags.Bool(flagTenancyEnabled, false, "Enable tenancy header when receiving or querying")
flags.String(flagTenancyHeader, "x-tenant", "HTTP header carrying tenant")
flags.String(flagValidTenants, "",
fmt.Sprintf("comma-separated list of allowed values for --%s header. (If not supplied, tenants are not restricted)",
flagTenancyHeader))
}
// InitFromViper creates tenancy.Options populated with values retrieved from Viper.
func InitFromViper(v *viper.Viper) Options {
var p Options
p.Enabled = v.GetBool(flagTenancyEnabled)
p.Header = v.GetString(flagTenancyHeader)
tenants := v.GetString(flagValidTenants)
if len(tenants) != 0 {
p.Tenants = strings.Split(tenants, ",")
} else {
p.Tenants = []string{}
}
return p
}
```
|
Josiah Webbe (April 1767 – 9 November 1804) was an English East India Company servant who worked as Chief Secretary at Madras and as a Resident at Mysore and later in the court of the Maharaja of Scindia.
Webbe was born into the colonial elite of Nevis as the son of George Webbe (1744-1804), a wealthy landowner and slaveowner, and Mary Fenton Dasent (1737-1818), whose grandfather John Dasent (1691-1754) and brother John Dasent (1734-1787) were both Chief Justice of Nevis.
He entered the service of the East India Company as a writer on July 26, 1783. His ability to deal with Indian languages made him popular. He advised against hostile actions towards Tipu Sultan which displeased Lord Mornington and the directors of the East India Company leading to his removal from the service of Arthur Wellesley. In 1803, he was posted Resident to the newly acquired kingdom of Mysore and the next year, he was posted by Wellesley to the Court of the Maharaja of Scindia in Gwalior. He died at Hussainabad on the banks of Narmada. A monolithic granite obelisk to him was erected at Srirangapatnam by Dewan Purnaiah, and a monument by John Flaxman was installed at St. Mary's Church in Fort St. George.
Unmarried, Webbe left his wealth to his sister Fanny Francklyn (née Webbe) and her son Alexander Allan (1808-1868), who then took up the name and arms of Webbe in lieu of Francklyn.
References
1767 births
1804 deaths
British East India Company civil servants
|
Jason Rabedeaux (April 4, 1965 – September 22, 2014) was an American college basketball coach who served as the head coach of the UTEP Miners from 1999 to 2002. Rabedeaux was also a top assistant at Washington State and Oklahoma prior to becoming UTEP's head coach.
Early life
Rabedeaux was born in Aurora, Illinois, and moved to Eau Claire, Wisconsin when he was seven.
Rabedeaux attended Eau Claire Memorial High School, playing basketball, American football and baseball; he quarterbacked the Old Abes to the state semifinals in his senior year, while earning All-State in basketball and baseball. He was a walk on at the University of California, Davis, and was named all-conference twice. He ended his UC Davis career with 1,112 points, 15th-most in school history. He holds the school record for the three-pointers in a season (80), most three-pointers in a game (six) and most free throws in a game (14). In 1995, he was inducted into the UC Davis Aggies Athletics Hall of Fame. Rabedeaux holds a bachelor's degree in exercise physiology, and at Washington State in 1991, earned a master's degree in athletic administration.
Coaching career
Upon finishing his college career, Rabedeaux spent a season as an assistant coach with North Adams State College, then joined Washington State, working with Kelvin Sampson as a graduate assistant (1989–1991) and eventually assistant coach (1992–1994). When Sampson went to Oklahoma, Rabedeaux followed him, working as an assistant coach. With Rabedeaux, the Sooners averaged 20.6 wins over five years, qualifying for the NCAA Tournament each year, including a Sweet 16 appearance in 1999.
Rabedeaux, who had served as recruiting director with North Adams, Washington State and Oklahoma, established himself as one of the top recruiters in the nation. Two of his recruits, Nate Erdmann and Corey Brewer, were later drafted by the Utah Jazz and Miami Heat in 1997 and 1998 respectively. Rabedeaux's recruiting also extended into Mexico, with recruit Eduardo Nájera becoming a 2000 Wooden Award candidate.
On September 10, 1999, Rabedeaux was hired by UTEP to replace Hall of Fame coach Don Haskins. In his first year, the Miners, with a lack of depth, finished 13–15, six of their losses being by less than three points; the Miners also swept the New Mexico Lobos for the first time in 14 years, and won at the Lobos' home arena, The Pit, the first such win for the Miners in nine seasons. In 2000, the Miners improved to 23–9 with a 10–6 record against conference opponents, while also qualifying for the NIT for the first time in six years. The team ranked seventh in the country in points per game with a school-best 80.3, while leading the Western Athletic Conference in scoring with 22.3 points per game. UTEP also finished seventh in field goal percentage (.492), 14th in free throw percentage (.753) and 17th in scoring offense. At the end of the year, he was named the WAC Coach of the Year by the Sporting News and Houston Chronicle. However, in 2002, UTEP struggled, finishing 10–22. Despite receiving a contract extension through 2007, on October 21, he announced his resignation due to "personal reasons".
In 2004, Rabedeaux was hired by Tom Crean as a coach at Marquette. In 2007, he became the school's Director of Basketball Operations.
In 2008, he joined the Jiangsu Dragons of the Chinese Basketball Association, coaching until 2010, when he was suspended for a year after being involved in a bench-clearing brawl during a playoff game. He later became head coach of the Japan Basketball League's Link Tochigi Brex. However, the team, who had been the league's defending champions, went 8–12, and Rabedeaux was fired in December 2010. In 2011, he was hired by the Al-Manama of the Bahrain Premier League, winning the Bahrain Cup and Bahrain Super Cup, though much of his players left the team to join the army due to an uprising. In late 2011, Rabedeaux was hired by the Saigon Heat of the ASEAN Basketball League as an assistant coach under Robert Newson. After seven consecutive losses, Newson was demoted, and on February 23, Rabedeaux was promoted to head coach. During his tenure with the Heat, he coached in China to earn more money. His final game with the Heat was a 72–61 win over the Indonesia Warriors.
Personal life and death
Rabedeaux and his ex-wife Stephanie had two sons, Beau and Cole, and a daughter, Riley.
Beginning during the final year of his coaching career at UTEP, Rabedeaux struggled with alcoholism; former assistant Bobby Champagne recalled Rabedeaux missing a flight to meet with a recruit because he was drunk at a nearby bar. After his divorce, Rabedeaux began gaining a significant amount of weight, reaching as high as .
In Vietnam, Rabedeaux met Hong-Nhung Nguyen, nicknamed Eva by foreigners, and the two began a relationship, with plans to marry and return to the United States. After Rabedeaux returned from a trip to Wisconsin, his behavior, which included becoming increasingly hostile and smelling of alcohol, attracted the attention of Heat owner Connor Nguyen, who warned him that should he cause another incident, he would be fired. Nguyen had hired Tony Garbelotto as an assistant and potential interim coach. During games, he appeared to be unstable and dizzy; during his final game against the Warriors, he attempted to draw a play, but was unable to, and Garbelotto had to explain the play.
The day after the game, Rabedeaux was found by Eva in the kitchen with cuts on his arms and head, and died while in a local taxicab. His death certificate listed the reason of death as a traumatic brain injury. Toxicology reports revealed that Rabedeaux had been sober at the time of his death.
Rabedeaux's funeral was held at the Congregational United Church of Christ in Eau Claire, with Sampson delivering the eulogy.
Head coaching record
|-
| style="text-align:left;"|Link Tochigi Brex
| style="text-align:left;"|2010
| 20||8||12|||| style="text-align:center;"|Fired|||-||-||-||
| style="text-align:center;"|-
|-
References
1965 births
2014 deaths
American expatriate basketball people in China
American expatriate basketball people in Vietnam
American men's basketball coaches
ASEAN Basketball League coaches
Basketball coaches from Wisconsin
Basketball players from Wisconsin
College men's basketball head coaches in the United States
Oklahoma Sooners men's basketball coaches
Sportspeople from Aurora, Illinois
Sportspeople from Eau Claire, Wisconsin
University of California, Davis alumni
UTEP Miners men's basketball coaches
Utsunomiya Brex coaches
Washington State Cougars men's basketball coaches
American men's basketball players
|
```shell
#!/bin/sh
##
## version 3. Alternative licensing terms are available. Contact
## info@minocacorp.com for details. See the LICENSE file at the root of this
## project for complete licensing information..
##
## Script Name:
##
## build_packet.sh
##
## Abstract:
##
## This script builds the Packet image.
##
## Author:
##
## Evan Green 26-Jan-2017
##
## Environment:
##
## Minoca Build
##
if test -z "$SRCROOT"; then
export SRCROOT=`pwd`/src
fi
if test -z "$ARCH"; then
echo "ARCH must be set."
exit 1
fi
if test -z "$DEBUG"; then
echo "DEBUG must be set."
exit 1
fi
##
## Exit if this is not x86.
##
if [ "$ARCH$VARIANT" != "x86" ]; then
echo "Skipping Packet build on $ARCH$VARIANT."
exit 0
fi
export TMPDIR=$PWD
export TEMP=$TMPDIR
BINROOT="$SRCROOT/$ARCH$VARIANT$DEBUG/bin"
DEST="$BINROOT/apps"
cd $BINROOT
##
## Move the install image aside temporarily.
##
mv install.img install_.img
##
## Copy the skeleton over so the proper environment is set up for postinst
## scripts.
##
cp -Rpf $BINROOT/skel/* $BINROOT/apps/ || true
##
## Create a local opkg configuration that prefers the local package repository.
##
package_dir="$BINROOT/packages"
cp /etc/opkg/opkg.conf ./myopkg.conf.orig
sed "s|src/gz main.*|src/gz local file:///$package_dir|" ./myopkg.conf.orig > \
./myopkg.conf
##
## Install python-setuptools on the build machine.
##
opkg --conf=$PWD/myopkg.conf update
opkg --conf=$PWD/myopkg.conf install python-pip
##
## Perform an offline install of packages needed for the build.
##
PACKAGES="opkg
libgcc
gzip
nano
openssh
expat
python2
python-setuptools
tar
wget
sqlite
libiconv
libncurses
libreadline
libopenssl
libpcre
ca-certificates
python-cloud-init"
mkdir -p "$DEST/usr/lib/opkg/"
opkg --conf=$PWD/myopkg.conf --offline-root="$DEST" update
opkg --conf=$PWD/myopkg.conf --offline-root="$DEST" --force-postinstall \
install $PACKAGES
rm -rf "$DEST/var/opkg-lists"
##
## Perform an offline install of the python packages. This can go away once
## all these packages (and their dependencies) are actually added as official
## packages, rather than being fetched from Pypi.
##
PYPACKAGES="cheetah
jinja2
PrettyTable
oauth
pyserial
configobj
pyyaml
argparse
requests
jsonpatch"
pip install --target="$DEST/usr/lib/python2.7/site-packages" $PYPACKAGES
mkdir -p "$DEST/root/.ssh"
chmod 700 "$DEST/root/.ssh"
##
## Set up the cloud.cfg file.
##
cat > "$DEST/etc/cloud/cloud.cfg" <<"_EOF"
disable_root: 0
ssh_pwauth: 0
datasource:
Ec2:
timeout: 10
max_wait: 20
metadata_urls: [ 'path_to_url ]
dsmode: net
cloud_init_modules:
- DataSourceEc2
- migrator
- bootcmd
- write-files
- growpart
# - resizefs
- set_hostname
- update_hostname
- update_etc_hosts
- rsyslog
- ssh
cloud_config_modules:
- DataSourceEc2
- mounts
# - locale
- set-passwords
- yum-add-repo
- package-update-upgrade-install
- timezone
- puppet
- chef
- salt-minion
- mcollective
- runcmd
cloud_final_modules:
- DataSourceEc2
- scripts-per-once
- scripts-per-boot
- scripts-per-instance
- scripts-user
- ssh-authkey-fingerprints
- keys-to-console
- phone-home
- final-message
system_info:
distro: gentoo # Pick gentoo because it uses /etc/init.d/ for init scripts.
_EOF
##
## Rebuild the install.img.
##
cd $SRCROOT/os/images
make install.img
##
## Rename the image, and put the old install.img back.
##
cd $BINROOT
mv install.img packet.img
mv install_.img install.img
##
## Remove cloud-init.
##
opkg --conf=$PWD/myopkg.conf --offline-root="$DEST" --force-postinstall \
remove python-cloud-init
export SYSROOT="$DEST"
for step in cloud-init-local cloud-init cloud-init-config cloud-init-final;
do
update-rc.d -f $step remove
rm -f $SYSROOT/etc/init.d/$step
done
echo Done building Packet image.
```
|
```css
Use `text-transform` to avoid screen-reader pronunciation errors
Change the style of the decoration with `text-decoration-style`
Use `em` instead of `px` for sizes
Comma-separated lists
`letter-spacing` property
```
|
```c
/*
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "gprof.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
#include "cg_arcs.h"
#include "corefile.h"
#include "hist.h"
static int i386_iscall PARAMS ((unsigned char *));
void i386_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
static int
i386_iscall (ip)
unsigned char *ip;
{
if (*ip == 0xe8)
return 1;
return 0;
}
void
i386_find_call (parent, p_lowpc, p_highpc)
Sym *parent;
bfd_vma p_lowpc;
bfd_vma p_highpc;
{
unsigned char *instructp;
Sym *child;
bfd_vma pc, destpc;
if (core_text_space == 0)
{
return;
}
if (p_lowpc < s_lowpc)
{
p_lowpc = s_lowpc;
}
if (p_highpc > s_highpc)
{
p_highpc = s_highpc;
}
DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
parent->name, (unsigned long) p_lowpc,
(unsigned long) p_highpc));
for (pc = p_lowpc; pc < p_highpc; ++pc)
{
instructp = (unsigned char *) core_text_space + pc - core_text_sect->vma;
if (i386_iscall (instructp))
{
DBG (CALLDEBUG,
printf ("[findcall]\t0x%lx:call", (unsigned long) pc));
/*
* regular pc relative addressing
* check that this is the address of
* a function.
*/
destpc = bfd_get_32 (core_bfd, instructp + 1) + pc + 5;
if (destpc >= s_lowpc && destpc <= s_highpc)
{
child = sym_lookup (&symtab, destpc);
if (child && child->addr == destpc)
{
/*
* a hit
*/
DBG (CALLDEBUG,
printf ("\tdestpc 0x%lx (%s)\n",
(unsigned long) destpc, child->name));
arc_add (parent, child, (unsigned long) 0);
instructp += 4; /* call is a 5 byte instruction */
continue;
}
}
/*
* else:
* it looked like a callf, but it:
* a) wasn't actually a callf, or
* b) didn't point to a known function in the symtab, or
* c) something funny is going on.
*/
DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
}
}
}
```
|
Two brass era companies used the Pilgrim marque for their automobiles between 1913 and 1918.
Pilgrim - 1913–1914, New Albany, Indiana
Ferdinand Kahler was the owner of the New Albany Woodworking and Furniture Company which had produced bodies for the Jonz automobile, and when the Jonz New Albany, Indiana factory closed, Kahler was stuck with a stockpile of bodies. To protect his investment, Kahler bought the Jonz equipment and moved into its factory. He organized the Ohio Falls Motor Car Company, and selected Pilgrim as the name for his car. He secured 44-50-hp four-cylinder engines from Continental, which he mounted in a 120-inch wheelbase chassis, and used his Jonz contracted bodies. He advertised "A $2,250 car for $1.800”, and "Buy your automobile direct from our factory”. Very few did.
After selling cars in 1913 and 1914, the Ohio Falls Motor Car Company went into receivership. Kahler sold out to the Crown Motor Car Company of Louisville, Kentucky which moved into the factory in 1914 and reorganized as Hercules.
Pilgrim - 1915–1918, Detroit, Michigan
William Radford an engineer who had worked for Oldsmobile and Hudson, had previously tried the automobile business with the Oxford and Fostoria automobiles. The Pilgrim was an automobile built in Detroit, Michigan, by the Pilgrim Motor Car Company in 1915. The Pilgrim was known as a light car that weighed . They produced a five-seat touring car, powered by a 2.3-liter, four-cylinder engine that was water-cooled and priced at $685 to $835. C. H. Leete, the company president, was arrested for fraud and William Radford departed the company. Attempts to reorganize the company were only partly successful and very few cars were built before it ceased operations in 1918.
References
Defunct motor vehicle manufacturers of the United States
Motor vehicle manufacturers based in Michigan
Defunct manufacturing companies based in Michigan
Motor vehicle manufacturers based in Indiana
Brass Era vehicles
1910s cars
Cars introduced in 1913
Cars introduced in 1915
Vehicle manufacturing companies established in 1913
Vehicle manufacturing companies disestablished in 1915
Vehicle manufacturing companies established in 1915
Vehicle manufacturing companies disestablished in 1918
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing,
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* specific language governing permissions and limitations
*
*/
package org.ballerinalang.model.tree;
import org.wso2.ballerinalang.compiler.tree.BLangRecordVariable;
import java.util.List;
/**
* Represents a record variable node.
*
* Example:
* type Person record {
* string name;
* boolean married;
* !...
* };
*
* Person {name, married} = {name: "Peter", married: true};
*
* @since 0.985.0
*/
public interface RecordVariableNode extends VariableNode, AnnotatableNode, DocumentableNode, TopLevelNode {
List<? extends BLangRecordVariable.BLangRecordVariableKeyValueNode> getVariables();
VariableNode getRestParam();
boolean hasRestParam();
/**
* Interface for key and value of a record variable.
*/
interface BLangRecordVariableKeyValueNode {
IdentifierNode getKey();
VariableNode getValue();
}
}
```
|
```c++
//your_sha256_hash-----------//
//
// See accompanying file LICENSE_1_0.txt or copy at
// path_to_url
//
// See path_to_url for more information.
//your_sha256_hash-----------//
#ifndef BOOST_COMPUTE_DETAIL_IS_CONTIGUOUS_ITERATOR_HPP
#define BOOST_COMPUTE_DETAIL_IS_CONTIGUOUS_ITERATOR_HPP
#include <vector>
#include <valarray>
#include <boost/config.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost {
namespace compute {
namespace detail {
// default = false
template<class Iterator, class Enable = void>
struct _is_contiguous_iterator : public boost::false_type {};
// std::vector<T>::iterator = true
template<class Iterator>
struct _is_contiguous_iterator<
Iterator,
typename boost::enable_if<
typename boost::is_same<
Iterator,
typename std::vector<typename Iterator::value_type>::iterator
>::type
>::type
> : public boost::true_type {};
// std::vector<T>::const_iterator = true
template<class Iterator>
struct _is_contiguous_iterator<
Iterator,
typename boost::enable_if<
typename boost::is_same<
Iterator,
typename std::vector<typename Iterator::value_type>::const_iterator
>::type
>::type
> : public boost::true_type {};
// std::valarray<T>::iterator = true
template<class Iterator>
struct _is_contiguous_iterator<
Iterator,
typename boost::enable_if<
typename boost::is_same<
Iterator,
typename std::valarray<typename Iterator::value_type>::iterator
>::type
>::type
> : public boost::true_type {};
// std::valarray<T>::const_iterator = true
template<class Iterator>
struct _is_contiguous_iterator<
Iterator,
typename boost::enable_if<
typename boost::is_same<
Iterator,
typename std::valarray<typename Iterator::value_type>::const_iterator
>::type
>::type
> : public boost::true_type {};
// T* = true
template<class Iterator>
struct _is_contiguous_iterator<
Iterator,
typename boost::enable_if<
boost::is_pointer<Iterator>
>::type
> : public boost::true_type {};
// the is_contiguous_iterator meta-function returns true if Iterator points
// to a range of contiguous values. examples of contiguous iterators are
// std::vector<>::iterator and float*. examples of non-contiguous iterators
// are std::set<>::iterator and std::insert_iterator<>.
//
// the implementation consists of two phases. the first checks that value_type
// for the iterator is not void. this must be done as for many containers void
// is not a valid value_type (ex. std::vector<void>::iterator is not valid).
// after ensuring a non-void value_type, the _is_contiguous_iterator function
// is invoked. it has specializations retuning true for all (known) contiguous
// iterators types and a default value of false.
template<class Iterator, class Enable = void>
struct is_contiguous_iterator :
public _is_contiguous_iterator<
typename boost::remove_cv<Iterator>::type
> {};
// value_type of void = false
template<class Iterator>
struct is_contiguous_iterator<
Iterator,
typename boost::enable_if<
typename boost::is_void<
typename Iterator::value_type
>::type
>::type
> : public boost::false_type {};
} // end detail namespace
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_DETAIL_IS_CONTIGUOUS_ITERATOR_HPP
```
|
The 2023 Internazionali di Tennis d'Abruzzo was a professional tennis tournament played on clay courts. It was the fifth edition of the tournament which was part of the 2023 ATP Challenger Tour. It took place in Francavilla al Mare, Italy between 8 and 14 May 2023.
Singles main-draw entrants
Seeds
1 Rankings are as of 24 April 2023.
Other entrants
The following players received wildcards into the singles main draw:
Gabriele Piraino
Fausto Tabacco
Giorgio Tabacco
The following players received entry into the singles main draw as alternates:
Salvatore Caruso
Raphaël Collignon
Elmar Ejupovic
Alessandro Giannessi
Mikhail Kukushkin
Gianluca Mager
The following players received entry from the qualifying draw:
Duje Ajduković
Andrea Arnaboldi
Moez Echargui
Giovanni Fonio
Edoardo Lavagno
Stefano Travaglia
Champions
Singles
Alejandro Tabilo def. Benoît Paire 6–1, 7–5.
Doubles
Nicolás Barrientos / Ariel Behar def. Sander Arends / Petros Tsitsipas 7–6(7–1), 3–6, [10–6].
References
2023 ATP Challenger Tour
2023 in Italian tennis
May 2023 sports events in Italy
Internazionali di Tennis d'Abruzzo
|
```makefile
PKG_NAME="vfs.libarchive"
PKG_VERSION="20.3.0-Nexus"
PKG_SHA256=your_sha256_hash
PKG_REV="7"
PKG_ARCH="any"
PKG_LICENSE="GPL"
PKG_SITE="path_to_url"
PKG_URL="path_to_url{PKG_VERSION}.tar.gz"
PKG_DEPENDS_TARGET="toolchain kodi-platform bzip2 libarchive lz4 lzo xz zlib"
PKG_SECTION=""
PKG_SHORTDESC="vfs.libarchive"
PKG_LONGDESC="vfs.libarchive"
PKG_IS_ADDON="yes"
PKG_ADDON_TYPE="kodi.vfs"
```
|
```objective-c
/*
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.
*/
#ifndef _TBB_threading_control_H
#define _TBB_threading_control_H
#include "oneapi/tbb/mutex.h"
#include "oneapi/tbb/global_control.h"
#include "threading_control_client.h"
#include "intrusive_list.h"
#include "main.h"
#include "permit_manager.h"
#include "pm_client.h"
#include "thread_dispatcher.h"
#include "cancellation_disseminator.h"
#include "thread_request_serializer.h"
#include "scheduler_common.h"
namespace tbb {
namespace detail {
namespace r1 {
class arena;
class thread_data;
class threading_control;
class threading_control_impl {
public:
threading_control_impl(threading_control*);
public:
void release(bool blocking_terminate);
threading_control_client create_client(arena& a);
void publish_client(threading_control_client client, d1::constraints& constraints);
struct client_snapshot {
std::uint64_t aba_epoch;
unsigned priority_level;
thread_dispatcher_client* my_td_client;
pm_client* my_pm_client;
};
client_snapshot prepare_client_destruction(threading_control_client client);
bool try_destroy_client(client_snapshot deleter);
void register_thread(thread_data& td);
void unregister_thread(thread_data& td);
void propagate_task_group_state(std::atomic<uint32_t> d1::task_group_context::*mptr_state,
d1::task_group_context& src, uint32_t new_state);
void set_active_num_workers(unsigned soft_limit);
std::size_t worker_stack_size();
unsigned max_num_workers();
void adjust_demand(threading_control_client, int mandatory_delta, int workers_delta);
bool is_any_other_client_active();
thread_control_monitor& get_waiting_threads_monitor();
private:
static unsigned calc_workers_soft_limit(unsigned workers_hard_limit);
static std::pair<unsigned, unsigned> calculate_workers_limits();
static cache_aligned_unique_ptr<permit_manager> make_permit_manager(unsigned workers_soft_limit);
static cache_aligned_unique_ptr<thread_dispatcher> make_thread_dispatcher(threading_control& control,
unsigned workers_soft_limit,
unsigned workers_hard_limit);
// TODO: Consider allocation one chunk of memory and construct objects on it
cache_aligned_unique_ptr<permit_manager> my_permit_manager{nullptr};
cache_aligned_unique_ptr<thread_dispatcher> my_thread_dispatcher{nullptr};
cache_aligned_unique_ptr<thread_request_serializer_proxy> my_thread_request_serializer{nullptr};
cache_aligned_unique_ptr<cancellation_disseminator> my_cancellation_disseminator{nullptr};
cache_aligned_unique_ptr<thread_control_monitor> my_waiting_threads_monitor{nullptr};
};
class threading_control {
using global_mutex_type = d1::mutex;
public:
using client_snapshot = threading_control_impl::client_snapshot;
static threading_control* register_public_reference();
static bool unregister_public_reference(bool blocking_terminate);
static bool is_present();
static void set_active_num_workers(unsigned soft_limit);
static bool register_lifetime_control();
static bool unregister_lifetime_control(bool blocking_terminate);
threading_control_client create_client(arena& a);
void publish_client(threading_control_client client, d1::constraints& constraints);
client_snapshot prepare_client_destruction(threading_control_client client);
bool try_destroy_client(client_snapshot deleter);
void register_thread(thread_data& td);
void unregister_thread(thread_data& td);
void propagate_task_group_state(std::atomic<uint32_t> d1::task_group_context::*mptr_state,
d1::task_group_context& src, uint32_t new_state);
std::size_t worker_stack_size();
static unsigned max_num_workers();
void adjust_demand(threading_control_client client, int mandatory_delta, int workers_delta);
bool is_any_other_client_active();
thread_control_monitor& get_waiting_threads_monitor();
private:
threading_control(unsigned public_ref, unsigned ref);
void add_ref(bool is_public);
bool remove_ref(bool is_public);
static threading_control* get_threading_control(bool is_public);
static threading_control* create_threading_control();
bool release(bool is_public, bool blocking_terminate);
void wait_last_reference(global_mutex_type::scoped_lock& lock);
void destroy();
friend class thread_dispatcher;
static threading_control* g_threading_control;
//! Mutex guarding creation/destruction of g_threading_control, insertions/deletions in my_arenas, and cancellation propagation
static global_mutex_type g_threading_control_mutex;
cache_aligned_unique_ptr<threading_control_impl> my_pimpl{nullptr};
//! Count of external threads attached
std::atomic<unsigned> my_public_ref_count{0};
//! Reference count controlling threading_control object lifetime
std::atomic<unsigned> my_ref_count{0};
};
} // r1
} // detail
} // tbb
#endif // _TBB_threading_control_H
```
|
Walter Kollmann (17 June 1932 – 16 May 2017) was an Austrian footballer.
Career
During his club career he played for Wacker Wien. Kollmann earned 16 caps for the Austria national football team, and participated in the 1954 FIFA World Cup and the 1958 FIFA World Cup. He also represented Austria at the 1952 Summer Olympics.
References
External links
Walter Kollmann's obituary
1932 births
2017 deaths
Austrian men's footballers
Austria men's international footballers
Footballers at the 1952 Summer Olympics
Olympic footballers for Austria
1954 FIFA World Cup players
1958 FIFA World Cup players
Men's association football defenders
|
Morten Thrane Brünnich (30 September 1737 – 19 September 1827) was a Danish zoologist and mineralogist.
Biography
Brünnich was born in Copenhagen, the son of a portrait painter. He studied oriental languages and theology, but soon became interested in natural history. He contributed his observations of insects to Erik Pontoppidan's Danske Atlas (1763–81). After being put in charge of the natural history collection of Christian Fleischer he became interested in ornithology, and in 1764 he published Ornithologia Borealis, which included the details of many Scandinavian birds, some described for the first time.
The publication of Ornithologia Borealis was aided by his insight in the collection.
Brünnich corresponded with many foreign naturalists including Linnaeus, Peter Simon Pallas and Thomas Pennant. He published his Entomologia in 1764. He then embarked on a long tour of Europe, spending time studying the fish of the Mediterranean Sea and publishing his Ichthyologia Massiliensis on the subject in 1768.
On his return Brünnich took up the post of Lecturer in Natural History and Economy at Copenhagen University. Here he established a natural history museum and wrote a textbook for his students, the Zoologiae fundamenta.
Namesake organisms
Brünnich's guillemot and the European wasp spider are named after him.
Also in 1927, botanists Hutch. & Dalziel published Afrobrunnichia, which is a genus of plants in the family Polygonaceae with two species in West Africa. It was named in Morten Thrane Brünnich's honour.
Works
{{Column list|colwidth=35em|
Prodromus insectologiæ Siælandicæ. Kopenhagen 1761.
Die natürliche Historie des Eider-Vogels. Kopenhagen 1763.
Eder-Fuglens Beskrivelse. Kopenhagen 1763.
Tillæg til Eder-Fuglens Beskrivelse. Kopenhagen 1763.
Entomologia. Godiche, Kopenhagen 1764.
Ornithologia borealis. Kall & Godiche, Kopenhagen 1764.
Ichthyologia Massiliensis. Roth & Proft, Kopenhagen, Leipzig 1768.
Appendix to Cronstedt's Mineralogy. London 1772.
Zoologiæ fundamenta praelectionibus academicis accommodata. Pelt, Kopenhagen 1771/72.
Mineralogie. Simmelkiær & Logan, Kopenhagen, St. Petersburg 1777-81.
Dyrenes Historie og Dyre-Samlingen ud Universitetes Natur-Theater. Kopenhagen, 1782.
Literatura Danica scientiarum naturalium. Kopenhagen, Leipzig 1783.
Catalogus bibliothecæ historiæ naturalis. Kopenhagen 1793.
Historiske Efterretninger om Norges Biergverker. Kopenhagen 1819.
Kongsberg Sölvbergwerk i Norge. Kopenhagen 1826.
}}
References
Biographies for Birdwatchers'', by Barbara and Richard Mearns -
1737 births
1827 deaths
Danish mineralogists
Danish ornithologists
Danish lepidopterists
Scientists from Copenhagen
Entomological writers
Ornithological writers
Ichthyological writers
Danish zoologists
University of Copenhagen alumni
Academic staff of the University of Copenhagen
Danish ichthyologists
|
```c++
//
//
// path_to_url
//
#include "pxr/pxr.h"
#include "pxr/usd/usd/stageCacheContext.h"
#include "pxr/usd/usd/stageCache.h"
#include "pxr/base/tf/pyEnum.h"
#include "pxr/base/tf/pyResultConversions.h"
#include <functional>
#include <memory>
#include <boost/python.hpp>
#include <vector>
using std::vector;
using namespace boost::python;
PXR_NAMESPACE_USING_DIRECTIVE
namespace {
// Expose C++ RAII class as python context manager.
struct Usd_PyStageCacheContext
{
// Constructor stores off arguments to pass to the factory later.
template <class Arg>
explicit Usd_PyStageCacheContext(Arg arg)
: _makeContext([arg]() {
return new UsdStageCacheContext(arg);
})
{}
explicit Usd_PyStageCacheContext(UsdStageCache &cache)
: _makeContext([&cache]() {
return new UsdStageCacheContext(cache);
})
{}
// Instantiate the C++ class object and hold it by shared_ptr.
void __enter__() { _context.reset(_makeContext()); }
// Drop the shared_ptr.
void __exit__(object, object, object) { _context.reset(); }
private:
std::shared_ptr<UsdStageCacheContext> _context;
std::function<UsdStageCacheContext *()> _makeContext;
};
} // anonymous namespace
void wrapUsdStageCacheContext()
{
TfPyWrapEnum<UsdStageCacheContextBlockType>();
// The use of with_custodian_and_ward(_postcall) below let us bind python
// object lifetimes together in such a way that we don't get dangling c++
// references in the c++ objects. See the boost.python docs for details
// (google search for boost python with_custodian_and_ward).
// Must ensure that the returned Wrapper objects below keep their cache
// argument alive, otherwise the Wrappers could have dangling references to
// their caches.
class_<Usd_NonPopulatingStageCacheWrapper>(
"_NonPopulatingStageCacheWrapper", no_init);
def("UseButDoNotPopulateCache", UsdUseButDoNotPopulateCache<UsdStageCache>,
with_custodian_and_ward_postcall<0, 1>());
// The constructor needs to ensure that the wrapper arguments be kept alive
// as long as the context is, to transitively keep their held cache objects
// alive.
class_<Usd_PyStageCacheContext>("StageCacheContext", no_init)
.def(init<Usd_NonPopulatingStageCacheWrapper>()[
with_custodian_and_ward<1, 2>()])
.def(init<UsdStageCache &>()[
with_custodian_and_ward<1, 2>()])
.def(init<UsdStageCacheContextBlockType>())
.def("__enter__", &Usd_PyStageCacheContext::__enter__)
.def("__exit__", &Usd_PyStageCacheContext::__exit__)
;
}
```
|
```html
<div *ngIf="!serviceAccounts" class="tw-items-center tw-justify-center tw-pt-64 tw-text-center">
<i class="bwi bwi-spinner bwi-spin bwi-3x"></i>
</div>
<bit-no-items *ngIf="serviceAccounts?.length == 0">
<ng-container slot="title">{{ "machineAccountsNoItemsTitle" | i18n }}</ng-container>
<ng-container slot="description">{{ "machineAccountsNoItemsMessage" | i18n }}</ng-container>
<button
slot="button"
type="button"
bitButton
buttonType="secondary"
(click)="newServiceAccountEvent.emit()"
>
<i class="bwi bwi-plus" aria-hidden="true"></i>
{{ "newMachineAccount" | i18n }}
</button>
</bit-no-items>
<bit-table *ngIf="serviceAccounts?.length >= 1" [dataSource]="dataSource">
<ng-container header>
<tr>
<th bitCell class="tw-w-0">
<label class="!tw-mb-0 tw-flex tw-w-fit tw-gap-2 !tw-font-bold !tw-text-muted">
<input
type="checkbox"
(change)="$event ? toggleAll() : null"
[checked]="selection.hasValue() && isAllSelected()"
[indeterminate]="selection.hasValue() && !isAllSelected()"
/>
{{ "all" | i18n }}
</label>
</th>
<th bitCell colspan="2" bitSortable="name" default>{{ "name" | i18n }}</th>
<th bitCell>{{ "secrets" | i18n }}</th>
<th bitCell bitSortable="revisionDate">{{ "lastEdited" | i18n }}</th>
<th bitCell class="tw-w-0">
<button
type="button"
bitIconButton="bwi-ellipsis-v"
buttonType="main"
[title]="'options' | i18n"
[attr.aria-label]="'options' | i18n"
[bitMenuTriggerFor]="tableMenu"
></button>
</th>
</tr>
</ng-container>
<ng-template body let-rows$>
<tr bitRow *ngFor="let serviceAccount of rows$ | async">
<td bitCell>
<input
type="checkbox"
(change)="$event ? selection.toggle(serviceAccount.id) : null"
[checked]="selection.isSelected(serviceAccount.id)"
/>
</td>
<td bitCell class="tw-w-0 tw-pr-0">
<i class="bwi bwi-wrench tw-text-muted" aria-hidden="true"></i>
</td>
<td bitCell class="tw-break-all">
<a bitLink [routerLink]="serviceAccount.id">
{{ serviceAccount.name }}
</a>
</td>
<td bitCell>
<span> {{ serviceAccount.accessToSecrets }} </span>
</td>
<td bitCell>{{ serviceAccount.revisionDate | date: "medium" }}</td>
<td bitCell>
<button
type="button"
bitIconButton="bwi-ellipsis-v"
buttonType="main"
[title]="'options' | i18n"
[attr.aria-label]="'options' | i18n"
[bitMenuTriggerFor]="serviceAccountMenu"
></button>
</td>
<bit-menu #serviceAccountMenu>
<a type="button" bitMenuItem [routerLink]="serviceAccount.id">
<i class="bwi bwi-fw bwi-eye" aria-hidden="true"></i>
{{ "viewMachineAccount" | i18n }}
</a>
<button type="button" bitMenuItem (click)="editServiceAccountEvent.emit(serviceAccount.id)">
<i class="bwi bwi-fw bwi-pencil" aria-hidden="true"></i>
{{ "editMachineAccount" | i18n }}
</button>
<button type="button" bitMenuItem (click)="delete(serviceAccount)">
<i class="bwi bwi-fw bwi-trash tw-text-danger" aria-hidden="true"></i>
<span class="tw-text-danger">
{{ "deleteMachineAccount" | i18n }}
</span>
</button>
</bit-menu>
</tr>
</ng-template>
</bit-table>
<bit-menu #tableMenu>
<button type="button" bitMenuItem (click)="bulkDeleteServiceAccounts()">
<i class="bwi bwi-fw bwi-trash tw-text-danger" aria-hidden="true"></i>
<span class="tw-text-danger">
{{ "deleteMachineAccounts" | i18n }}
</span>
</button>
</bit-menu>
```
|
is a railway station on the Abukuma Express Line in the city of Kakuda, Miyagi, Japan.
Lines
Kakuda Station is served by the Abukuma Express Line, and is located 43.3 km from the official starting point of the line at .
Station layout
Kakuda Station has a two opposed side platforms connected to the station building by a footbridge. The station is staffed.
Platforms
Adjacent stations
History
Kakuda Station opened on April 1, 1968, as a station operated by Japanese National Railways (JNR). It became part of the Abukuma Express network on July 1, 1986, and a second platform was added.
Surrounding area
National Route 113
Kakuda City Hall
Kakuda Post Office
See also
List of Railway Stations in Japan
External links
Railway stations in Miyagi Prefecture
Abukuma Express Line
Railway stations in Japan opened in 1968
Kakuda, Miyagi
|
The North Plainfield School District is a comprehensive community public school district that serves students in pre-kindergarten through twelfth grade from North Plainfield in Somerset County, New Jersey, United States. The district also houses a comprehensive Adult High School and an Adult Community School which offers educational programs for North Plainfield and neighboring community residents.
As of the 2018–19 school year, the district, comprising six schools, had an enrollment of 3,342 students and 304.0 classroom teachers (on an FTE basis), for a student–teacher ratio of 11.0:1.
The district is classified by the New Jersey Department of Education as being in District Factor Group "DE", the fifth-highest of eight groupings. District Factor Groups organize districts statewide to allow comparison by common socioeconomic characteristics of the local districts. From lowest socioeconomic status to highest, the categories are A, B, CD, DE, FG, GH, I and J.
Schools
Schools in the district (with 2018–19 enrollment data from the National Center for Education Statistics) are:
Elementary schools
East End Elementary School (423 students; in grades PreK–4)
Stony Brook Elementary School (253; PreK–4)
West End Elementary School (488; K–4)
Middle school
Somerset Intermediate School (516; 5–6)
Middle / High school
North Plainfield Middle School (544; 7–8)
North Plainfield High School (1,052; 9–12) is certified by the New Jersey Department of Education and accredited by the Middle States Association of Colleges and Schools, offers a comprehensive program of studies to its 7–12 enrollment.
Administration
Core members of the district's administration are:
Michelle Aquino, superintendent
Donald Sternberg, business administrator and board secretary
Board of education
The district's board of education, with seven members, sets policy and oversees the fiscal and educational operation of the district through its administration. As a Type II school district, the board's trustees are elected directly by voters to serve three-year terms of office on a staggered basis, with either two or three seats up for election each year held (since 2012) as part of the November general election.
References
External links
North Plainfield Public Schools
School Data for the North Plainfield Public Schools, National Center for Education Statistics
New Jersey District Factor Group DE
North Plainfield, New Jersey
School districts in Somerset County, New Jersey
|
Digital Universe Atlas is a free open source software planetarium application, available under the terms of the Illinois Open Source License, and running on Linux, Windows, macOS (10.5 and above), AmigaOS 4, and IRIX.
It is a standalone 4-dimensional space visualization application built on the programmable Partiview data visualization engine designed by Stuart Levy of the National Center for Supercomputing Applications (NCSA) as an adjunct of the NCSA's Virtual Director virtual choreography project. The Virtual Universe Atlas project was launched by the American Museum of Natural History's Hayden Planetarium with significant programming support from the National Aeronautics and Space Administration as well as Stuart Levy. The database draws on the National Virtual Observatory.
Along with Celestia and Orbiter, and unlike most other planetarium applications, Digital Universe shares the capacity to visualize space from points outside Earth. Building on work by Japan's RIKEN, its planet renderings and zoom visualizations can match or exceed Celestia and Orbiter. Unlike Celestia and Orbiter, highly accurate visualization from distances beyond the Milky Way galaxy is integral to the software and the datasets. This allows for unrivaled flexibility in plotting itineraries that reveal true distances and configurations of objects in the observable sky. It therefore improves understanding of the surroundings of the solar system in terms of observer-neutral celestial coordinate systems—systems that are neither geocentric nor heliocentric—such as the galactic coordinate system and supergalactic coordinate system.
The Digital Universe Atlas has spun off a commercial-grade planetarium platform from SCISS called Uniview that was featured in the White House star party on October 7, 2009. The Atlas database and Partiview interface is compatible with professional planetarium software such as Evans & Sutherland's Digistar and Sky-Skan's DigitalSky 2.
The Digital Universe is now a critical component of the OpenSpace open source interactive data visualization software suite. In 2014, a NASA grant (supported by the NASA Science Mission Directorate in response to NASA Cooperative Agreement Number (CAN) NNH15ZDA004C, Amendment 1) was awarded to the American Museum of Natural History for the development of the OpenSpace project, to utilize the latest data visualization techniques and graphics card technologies for rapid data throughput. OpenSpace and its Digital Universe datasets work on all operating systems and is available for free download.
See also
Space flight simulation game
List of space flight simulation games
Planetarium software
List of observatory software
References
External links
Official Website
OpenSpace website
Partiview
Partiview user's guide
Peter Teubern & Stuart Levy, Partiview reference manual
Partiview mailing list
University of Chicago Department of Astronomy & Astrophysics, "Partiview for Developers"
Selden Ball, "Planets for Partiview"
Partiview on GeoWalls
University of Chicago Department of Astronomy & Astrophysics, "Downloads," other visualization plug-ins for Partiview
Uniview
Evans & Sutherland Digistar
Sky-Skan DigitalSky
"The Known Universe" video simulation, American Museum of Natural History, December 15, 2009, using the DUA database and visualized using UniView
Brian Abbott, Carter Emmart, and Ryan Wyatt, "Virtual Universe," Natural History, April 2004
"3-D Tour Puts Stars within Reach," Wired Magazine, June 3, 2003
Slashdot discussion, July 25, 2002
TED 2010 - A 3D atlas of the universe - Carter Emmart
AmigaOS 4 software
Astronomy software
Free astronomy software
Planetarium software for Linux
Science software for macOS
Science software for Windows
Software using the NCSA license
|
Rear Admiral Agha Danish () , , is a retired two-star rank admiral and a senior naval aviator in the Pakistan Navy. Starting his career in the Operations Branch of the Navy as a General Duty Pilot, the Admiral's last appointment was the Naval Field Command where he was responsible for overseeing operational and war preparedness of all air, surface and sub-surface units of the Pakistan Naval Fleet.
Naval career
Danish joined the Pakistan Naval Academy after passing the pre-entrance university exams in 1970. In 1974, Danish gained his B.A. in Statistics, and was commissioned in the Naval Operations Branch, as a Sub-Lieutenant. The same year, he joined the Naval Aviation, and attended the College of Flying Training of the Pakistan Air Force Academy. He graduated there as a General Duty Pilot and became a first fighter pilot of the Navy. Upon his graduation, he was promoted to Lieutenant and commanded a fighter naval squadron, PNA Squadron No. 29 ASW, which is the Navy's primary anti-submarine squadron. As a pilot, he is also associated with several other flying units in Pakistan's armed forces including No. 1 Army Aviation Squadron and the 30 VP Squadron of the Navy's anti-submarine warfare branch. The Admiral was also sent to the United States to train on P3C Orion Aircraft, the Navy's anti-submarine and maritime surveillance aircraft, at the Naval Air Station in Jacksonville, Florida, when Pakistan purchased the long range maritime patrol aircraft fleet from the United States government. He is a graduate of National Defense College and holds a double M.Sc. in Defense and Strategic studies. Admiral Danish has also attended the Higher National Defense Command Course at the National Defense University in China. The Admiral later served as Directing Staff at the National Defense University in Pakistan where he was responsible for instructing seniors officers from all three armed forces of Pakistan.
During his career, the Admiral has held several important command and staff appointments including command of two naval destroyers namely PNS Babur and PNS Tariq, being one of the few naval officers to have held command of two naval destroyers simultaneously. He is also the only Naval officer to ever receive the Chief of Air Staff Trophy based on his exceptional flying skills. He also served as Commander Naval Aviation and Commandant Pakistan Naval War College and, in that regard, served on the Board of Governors of Bahria University. At Naval Headquarters, the Admiral was Principal Staff Officer with the Chief of the Naval Staff while also serving as Secretary Navy Board.
In 2005, Agha Danish joined the ranks of Naval Admiral. Thereafter he also served on the Karachi Port Trust Board as the General Manager where he oversaw all shipping and ground operations at the Karachi Port, one of the largest and busiest deep-water seaports in South Asia which handles about 60% of Pakistan's cargo. In 2010, Admiral Agha Danish was also recommended for appointment as Chairman of Port Qasim Authority in a note sent to the Prime Minister of Pakistan. The Admiral's last operational appointment was the Naval Field Command 'Flag Officer Sea Training' where he was responsible for overseeing operational and war preparedness of all air, surface and sub-surface units of the Pakistan Naval Fleet. Presently, he is serving as Director General for Bahria University and National Center for Maritime Policy Research.
Admiral Danish is also a recipient of Sitara-e-Imtiaz (Military) and Hilal-e-Imtiaz (Military), both awarded by the President of Pakistan. The Admiral is married with two children.
References
Pakistan Navy admirals
Living people
Pakistan Naval Academy alumni
Pakistani test pilots
Year of birth missing (living people)
|
```java
/*
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.shardingsphere.sharding.algorithm.sharding.range;
import com.google.common.collect.Range;
import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.exception.generic.UnsupportedSQLOperationException;
import org.apache.shardingsphere.sharding.algorithm.sharding.ShardingAutoTableAlgorithmUtils;
import org.apache.shardingsphere.sharding.api.sharding.ShardingAutoTableAlgorithm;
import org.apache.shardingsphere.sharding.api.sharding.standard.PreciseShardingValue;
import org.apache.shardingsphere.sharding.api.sharding.standard.RangeShardingValue;
import org.apache.shardingsphere.sharding.api.sharding.standard.StandardShardingAlgorithm;
import org.apache.shardingsphere.sharding.exception.data.NullShardingValueException;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
/**
* Abstract range sharding algorithm.
*/
public abstract class AbstractRangeShardingAlgorithm implements StandardShardingAlgorithm<Comparable<?>>, ShardingAutoTableAlgorithm {
private Map<Integer, Range<Comparable<?>>> partitionRange;
@Override
public final void init(final Properties props) {
partitionRange = calculatePartitionRange(props);
}
protected abstract Map<Integer, Range<Comparable<?>>> calculatePartitionRange(Properties props);
@Override
public final String doSharding(final Collection<String> availableTargetNames, final PreciseShardingValue<Comparable<?>> shardingValue) {
ShardingSpherePreconditions.checkNotNull(shardingValue.getValue(), NullShardingValueException::new);
String suffix = String.valueOf(getPartition(shardingValue.getValue()));
return ShardingAutoTableAlgorithmUtils.findMatchedTargetName(availableTargetNames, suffix, shardingValue.getDataNodeInfo()).orElse(null);
}
@Override
public final Collection<String> doSharding(final Collection<String> availableTargetNames, final RangeShardingValue<Comparable<?>> shardingValue) {
Collection<String> result = new LinkedHashSet<>(availableTargetNames.size(), 1F);
int firstPartition = getFirstPartition(shardingValue.getValueRange());
int lastPartition = getLastPartition(shardingValue.getValueRange());
for (int partition = firstPartition; partition <= lastPartition; partition++) {
String suffix = String.valueOf(partition);
ShardingAutoTableAlgorithmUtils.findMatchedTargetName(availableTargetNames, suffix, shardingValue.getDataNodeInfo()).ifPresent(result::add);
}
return result;
}
private int getFirstPartition(final Range<Comparable<?>> valueRange) {
return valueRange.hasLowerBound() ? getPartition(valueRange.lowerEndpoint()) : 0;
}
private int getLastPartition(final Range<Comparable<?>> valueRange) {
return valueRange.hasUpperBound() ? getPartition(valueRange.upperEndpoint()) : partitionRange.size() - 1;
}
private Integer getPartition(final Comparable<?> value) {
for (Entry<Integer, Range<Comparable<?>>> entry : partitionRange.entrySet()) {
if (entry.getValue().contains(getLongValue(value))) {
return entry.getKey();
}
}
throw new UnsupportedSQLOperationException("");
}
private Long getLongValue(final Comparable<?> value) {
return Long.parseLong(value.toString());
}
@Override
public final int getAutoTablesAmount() {
return partitionRange.size();
}
}
```
|
The Washington D.C. Area Film Critics Association Award for Best Film is an annual award given out by the Washington D.C. Area Film Critics Association.
Winners
2000s
2010s
2020s
See also
Academy Award for Best Picture
References
Film, Best
Awards for best film
|
The Delta Psi, Alpha Chapter fraternity house is located at 434 Riverside Drive in the Morningside Heights neighborhood of Manhattan, New York City. It was purpose built in 1898 and continues to serve the Columbia chapter of the Fraternity of Delta Psi (aka St. Anthony Hall), a social and literary fraternity.
The chapter house was designed by two prominent New York City architects, Henry Hornbostel and George Carnegie Palmer. At this time of its construction, the press described it as "the best appointed and most costly [fraternity] building that has ever been erected in the United States".
For its architectural significance, the Delta Psi, Alpha Chapter building was added to the National Register of Historic Places on April 26, 1996.
History
On March 23, 1897, the Alpha chapter of the Fraternity of Delta Psi (St. Anthony Hall) purchased a wide lot on 434 Riverside Drive from Harriet B. Hale. The fraternity intended to build a new chapter house closer to Columbia University, which had recently moved to Morningside Heights. The fraternity's previous Renaissance Revival style chapter house, designed in 1879 by fraternity member William Hamilton Russell of the firm of James Renwick Jr., was at 29 E. 28th Street. In addition to proximity to campus, the new site "afforded breathtaking views of the Hudson River and New Jersey palisades."
In 1898, the fraternity hired the architectural firm of Wood, Palmer & Hornbostel to design its new chapter house. The architects were Henry Hornbostel and George Carnegie Palmer; the latter was a member of the Columbia chapter of St. Anthony Hall. The architects filed plans with the city on August 26, 1898. The plans called for a five-story building constructed of brick and stone, costing $45,000 (equivalent to $ in today's money). However, the actual cost of the chapter house was closer to $80,000 (equivalent to $ in today's money). In 1899, the lot was worth another $20,000 (equivalent to $ in today's money).
At the time the fraternity built this chapter house, students did not live on Columbia's campus. Thus, "Delta Psi was not only the first fraternity to erect its own chapter house near the new Columbia campus, but, in 1899, when it was completed, it was one of only a handful of buildings on Morningside Heights where students could live." Although two other fraternities also built chapter houses in the Morningside neighborhood, this is the only one still in use by a fraternity. Ultimately, land values increased so quickly that its cost outpriced student housing. By 1905, Columbia University provided on-campus residences for students.
Description
The Alpha chapter house was designed in Beaux Arts and French Renaissance revival styles. It is unknown why this style was chosen. The style may have been selected "because it was fashionable or because the red brick and limestone trim were similar to the materials used at Columbia's new buildings. However, the style was likely chosen because it resembled the earlier fraternity house on 28th Street, designed by James Renwick.
The building has five stories and a basement. The foundation is constructed of white Indiana limestone. The first story is completely faced with Indiana limestone, with the remaining stories being in red brick that is heavily trimmed in limestone. Above the fourth story, there is a stone cornice surrounding a carved cartouche with the fraternity's Greek letters ΔΨ.
The entrance stoop has granite steps that lead through an arched entrance with ornate wrought iron gates. The actual entrance is set back with a seven-foot wide covered porch or arcade that also served as a balcony for the second story (see photo to left). However, the original north-facing arcade and the windows above it are now blocked by an adjacent building that was constructed in 1910. The upper levels are L–shaped with light courts to provide natural light and ventilation for all rooms. The second, third, and fourth floors have balconies with wrought iron railings. The fifth floor had copper covered dormers. The pyramid-shaped roof is covered in slate. There is also a small yard at the back of the building.
The main entrance goes to an arcade that leads to an L–shaped hallway with Doric columns, paneled wainscotting, a dentil cornice, and wooden doors. The first and second floors contain public spaces, including a coat room, reception room, parlors, a ballroom, a billiard room, a study, and a dining room. The main parlor on the first floor is trapezoidal–shaped and features a large marble fireplace and overmantel which is decorated with owls, shields, and decorative moldings. The fireplace was given in memory of Joseph Wild Mackay who joined the fraternity in 1900. Also on the first floor, the Arts and Crafts style dining room stretches across the entire width of the building and features Dutch shelving, leaded windows, and wood wainscotting. The second-floor billiard room is still in use. The stairs have slate treads and iron risers, railings, and balusters. There were additional stairs for servants.
The upper three levels include bedrooms for twenty to 25 fraternity members. The third floor also includes a library with built-in shelving, a fireplace, and a molded plaster ceiling; the library is dedicated in memory of Henry Evelyn Pierrepont Jr, who joined the fraternity in 1896 and died in 1903. The basement includes a caretaker's room and a "secret chapter meeting room".
In 1906, fraternity historian Edward Fermor Hall wrote that the Alpha chapter house was "beautifully decorated and finished in marble at a large expense."
Noteworthy events
On July 11, 1915, Delta Psi alumnus Daniel Leroy Dresser committed suicide over financial problems in the library of the chapter house. Dresser was the brother-in-law of George Washington Vanderbilt II of Biltmore Estate.
The chandelier in the ballroom was featured on the cover of Vampire Weekend's first album.
See also
North American fraternity and sorority housing
References
Clubhouses on the National Register of Historic Places in Manhattan
Cultural infrastructure completed in 1898
Morningside Heights, Manhattan
Columbia University campus
St. Anthony Hall houses
Henry Hornbostel buildings
|
```c
/**
* @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.
*/
#include "stdlib/blas/base/zcopy.h"
/**
* Copies values from one complex double-precision floating-point vector to another complex double-precision floating-point vector.
*
* @param N number of indexed elements
* @param X input array
* @param strideX X stride length
* @param Y output array
* @param strideY Y stride length
*/
void c_zcopy( const int N, const void *X, const int strideX, void *Y, const int strideY ) {
double *x = (double *)X;
double *y = (double *)Y;
int ix;
int iy;
int i;
if ( N <= 0 ) {
return;
}
if ( strideX == 1 && strideY == 1 ) {
for ( i = 0; i < N*2; i += 2 ) {
y[ i ] = x[ i ];
y[ i+1 ] = x[ i+1 ];
}
return;
}
if ( strideX < 0 ) {
ix = 2 * (1-N) * strideX;
} else {
ix = 0;
}
if ( strideY < 0 ) {
iy = 2 * (1-N) * strideY;
} else {
iy = 0;
}
for ( i = 0; i < N; i++ ) {
y[ iy ] = x[ ix ];
y[ iy+1 ] = x[ ix+1 ];
ix += strideX * 2;
iy += strideY * 2;
}
return;
}
```
|
```shell
How to unmodify a modified file
Using tags for version control
You can use git offline!
`master` and `origin` aren't special
Remote repositories: viewing, editing and deleting
```
|
```c++
#include "env-inl.h"
#include "node_internals.h"
#include "util-inl.h"
#ifdef NODE_IMPLEMENTS_POSIX_CREDENTIALS
#include <grp.h> // getgrnam()
#include <pwd.h> // getpwnam()
#endif // NODE_IMPLEMENTS_POSIX_CREDENTIALS
#if !defined(_MSC_VER)
#include <unistd.h> // setuid, getuid
#endif
namespace node {
using v8::Array;
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::HandleScope;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
using v8::String;
using v8::TryCatch;
using v8::Uint32;
using v8::Value;
namespace per_process {
bool linux_at_secure = false;
} // namespace per_process
namespace credentials {
// Look up environment variable unless running as setuid root.
bool SafeGetenv(const char* key, std::string* text, Environment* env) {
#if !defined(__CloudABI__) && !defined(_WIN32)
if (per_process::linux_at_secure || getuid() != geteuid() ||
getgid() != getegid())
goto fail;
#endif
if (env != nullptr) {
HandleScope handle_scope(env->isolate());
TryCatch ignore_errors(env->isolate());
MaybeLocal<String> maybe_value = env->env_vars()->Get(
env->isolate(),
String::NewFromUtf8(env->isolate(), key).ToLocalChecked());
Local<String> value;
if (!maybe_value.ToLocal(&value)) goto fail;
String::Utf8Value utf8_value(env->isolate(), value);
if (*utf8_value == nullptr) goto fail;
*text = std::string(*utf8_value, utf8_value.length());
return true;
}
{
Mutex::ScopedLock lock(per_process::env_var_mutex);
if (const char* value = getenv(key)) {
*text = value;
return true;
}
}
fail:
text->clear();
return false;
}
static void SafeGetenv(const FunctionCallbackInfo<Value>& args) {
CHECK(args[0]->IsString());
Environment* env = Environment::GetCurrent(args);
Isolate* isolate = env->isolate();
Utf8Value strenvtag(isolate, args[0]);
std::string text;
if (!SafeGetenv(*strenvtag, &text, env)) return;
Local<Value> result =
ToV8Value(isolate->GetCurrentContext(), text).ToLocalChecked();
args.GetReturnValue().Set(result);
}
#ifdef NODE_IMPLEMENTS_POSIX_CREDENTIALS
static const uid_t uid_not_found = static_cast<uid_t>(-1);
static const gid_t gid_not_found = static_cast<gid_t>(-1);
static uid_t uid_by_name(const char* name) {
struct passwd pwd;
struct passwd* pp;
char buf[8192];
errno = 0;
pp = nullptr;
if (getpwnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr)
return pp->pw_uid;
return uid_not_found;
}
static char* name_by_uid(uid_t uid) {
struct passwd pwd;
struct passwd* pp;
char buf[8192];
int rc;
errno = 0;
pp = nullptr;
if ((rc = getpwuid_r(uid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
pp != nullptr) {
return strdup(pp->pw_name);
}
if (rc == 0) errno = ENOENT;
return nullptr;
}
static gid_t gid_by_name(const char* name) {
struct group pwd;
struct group* pp;
char buf[8192];
errno = 0;
pp = nullptr;
if (getgrnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr)
return pp->gr_gid;
return gid_not_found;
}
#if 0 // For future use.
static const char* name_by_gid(gid_t gid) {
struct group pwd;
struct group* pp;
char buf[8192];
int rc;
errno = 0;
pp = nullptr;
if ((rc = getgrgid_r(gid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
pp != nullptr) {
return strdup(pp->gr_name);
}
if (rc == 0)
errno = ENOENT;
return nullptr;
}
#endif
static uid_t uid_by_name(Isolate* isolate, Local<Value> value) {
if (value->IsUint32()) {
return static_cast<uid_t>(value.As<Uint32>()->Value());
} else {
Utf8Value name(isolate, value);
return uid_by_name(*name);
}
}
static gid_t gid_by_name(Isolate* isolate, Local<Value> value) {
if (value->IsUint32()) {
return static_cast<gid_t>(value.As<Uint32>()->Value());
} else {
Utf8Value name(isolate, value);
return gid_by_name(*name);
}
}
static void GetUid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->has_run_bootstrapping_code());
// uid_t is an uint32_t on all supported platforms.
args.GetReturnValue().Set(static_cast<uint32_t>(getuid()));
}
static void GetGid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->has_run_bootstrapping_code());
// gid_t is an uint32_t on all supported platforms.
args.GetReturnValue().Set(static_cast<uint32_t>(getgid()));
}
static void GetEUid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->has_run_bootstrapping_code());
// uid_t is an uint32_t on all supported platforms.
args.GetReturnValue().Set(static_cast<uint32_t>(geteuid()));
}
static void GetEGid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->has_run_bootstrapping_code());
// gid_t is an uint32_t on all supported platforms.
args.GetReturnValue().Set(static_cast<uint32_t>(getegid()));
}
static void SetGid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->owns_process_state());
CHECK_EQ(args.Length(), 1);
CHECK(args[0]->IsUint32() || args[0]->IsString());
gid_t gid = gid_by_name(env->isolate(), args[0]);
if (gid == gid_not_found) {
// Tells JS to throw ERR_INVALID_CREDENTIAL
args.GetReturnValue().Set(1);
} else if (setgid(gid)) {
env->ThrowErrnoException(errno, "setgid");
} else {
args.GetReturnValue().Set(0);
}
}
static void SetEGid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->owns_process_state());
CHECK_EQ(args.Length(), 1);
CHECK(args[0]->IsUint32() || args[0]->IsString());
gid_t gid = gid_by_name(env->isolate(), args[0]);
if (gid == gid_not_found) {
// Tells JS to throw ERR_INVALID_CREDENTIAL
args.GetReturnValue().Set(1);
} else if (setegid(gid)) {
env->ThrowErrnoException(errno, "setegid");
} else {
args.GetReturnValue().Set(0);
}
}
static void SetUid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->owns_process_state());
CHECK_EQ(args.Length(), 1);
CHECK(args[0]->IsUint32() || args[0]->IsString());
uid_t uid = uid_by_name(env->isolate(), args[0]);
if (uid == uid_not_found) {
// Tells JS to throw ERR_INVALID_CREDENTIAL
args.GetReturnValue().Set(1);
} else if (setuid(uid)) {
env->ThrowErrnoException(errno, "setuid");
} else {
args.GetReturnValue().Set(0);
}
}
static void SetEUid(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->owns_process_state());
CHECK_EQ(args.Length(), 1);
CHECK(args[0]->IsUint32() || args[0]->IsString());
uid_t uid = uid_by_name(env->isolate(), args[0]);
if (uid == uid_not_found) {
// Tells JS to throw ERR_INVALID_CREDENTIAL
args.GetReturnValue().Set(1);
} else if (seteuid(uid)) {
env->ThrowErrnoException(errno, "seteuid");
} else {
args.GetReturnValue().Set(0);
}
}
static void GetGroups(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(env->has_run_bootstrapping_code());
int ngroups = getgroups(0, nullptr);
if (ngroups == -1) return env->ThrowErrnoException(errno, "getgroups");
std::vector<gid_t> groups(ngroups);
ngroups = getgroups(ngroups, groups.data());
if (ngroups == -1)
return env->ThrowErrnoException(errno, "getgroups");
groups.resize(ngroups);
gid_t egid = getegid();
if (std::find(groups.begin(), groups.end(), egid) == groups.end())
groups.push_back(egid);
MaybeLocal<Value> array = ToV8Value(env->context(), groups);
if (!array.IsEmpty())
args.GetReturnValue().Set(array.ToLocalChecked());
}
static void SetGroups(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK_EQ(args.Length(), 1);
CHECK(args[0]->IsArray());
Local<Array> groups_list = args[0].As<Array>();
size_t size = groups_list->Length();
MaybeStackBuffer<gid_t, 64> groups(size);
for (size_t i = 0; i < size; i++) {
gid_t gid = gid_by_name(
env->isolate(), groups_list->Get(env->context(), i).ToLocalChecked());
if (gid == gid_not_found) {
// Tells JS to throw ERR_INVALID_CREDENTIAL
args.GetReturnValue().Set(static_cast<uint32_t>(i + 1));
return;
}
groups[i] = gid;
}
int rc = setgroups(size, *groups);
if (rc == -1) return env->ThrowErrnoException(errno, "setgroups");
args.GetReturnValue().Set(0);
}
static void InitGroups(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK_EQ(args.Length(), 2);
CHECK(args[0]->IsUint32() || args[0]->IsString());
CHECK(args[1]->IsUint32() || args[1]->IsString());
Utf8Value arg0(env->isolate(), args[0]);
gid_t extra_group;
bool must_free;
char* user;
if (args[0]->IsUint32()) {
user = name_by_uid(args[0].As<Uint32>()->Value());
must_free = true;
} else {
user = *arg0;
must_free = false;
}
if (user == nullptr) {
// Tells JS to throw ERR_INVALID_CREDENTIAL
return args.GetReturnValue().Set(1);
}
extra_group = gid_by_name(env->isolate(), args[1]);
if (extra_group == gid_not_found) {
if (must_free) free(user);
// Tells JS to throw ERR_INVALID_CREDENTIAL
return args.GetReturnValue().Set(2);
}
int rc = initgroups(user, extra_group);
if (must_free) free(user);
if (rc) return env->ThrowErrnoException(errno, "initgroups");
args.GetReturnValue().Set(0);
}
#endif // NODE_IMPLEMENTS_POSIX_CREDENTIALS
static void Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "safeGetenv", SafeGetenv);
#ifdef NODE_IMPLEMENTS_POSIX_CREDENTIALS
READONLY_TRUE_PROPERTY(target, "implementsPosixCredentials");
env->SetMethodNoSideEffect(target, "getuid", GetUid);
env->SetMethodNoSideEffect(target, "geteuid", GetEUid);
env->SetMethodNoSideEffect(target, "getgid", GetGid);
env->SetMethodNoSideEffect(target, "getegid", GetEGid);
env->SetMethodNoSideEffect(target, "getgroups", GetGroups);
if (env->owns_process_state()) {
env->SetMethod(target, "initgroups", InitGroups);
env->SetMethod(target, "setegid", SetEGid);
env->SetMethod(target, "seteuid", SetEUid);
env->SetMethod(target, "setgid", SetGid);
env->SetMethod(target, "setuid", SetUid);
env->SetMethod(target, "setgroups", SetGroups);
}
#endif // NODE_IMPLEMENTS_POSIX_CREDENTIALS
}
} // namespace credentials
} // namespace node
NODE_MODULE_CONTEXT_AWARE_INTERNAL(credentials, node::credentials::Initialize)
```
|
```ruby
homepage "path_to_url"
sha256 your_sha256_hash
license "MIT"
bottle do
sha256 cellar: :any_skip_relocation, arm64_sonoma: your_sha256_hash
sha256 cellar: :any_skip_relocation, arm64_ventura: your_sha256_hash
sha256 cellar: :any_skip_relocation, arm64_monterey: your_sha256_hash
sha256 cellar: :any_skip_relocation, sonoma: your_sha256_hash
sha256 cellar: :any_skip_relocation, ventura: your_sha256_hash
sha256 cellar: :any_skip_relocation, monterey: your_sha256_hash
end
depends_on xcode: ["13.3", :build]
depends_on :macos
uses_from_macos "swift" => :build
def install
system "make", "install", "PREFIX=#{prefix}"
end
test do
(testpath/"Cartfile.resolved").write <<~EOS
github "realm/realm-swift" "v10.20.2"
EOS
assert_match "None", shell_output("#{bin}/license-plist --suppress-opening-directory")
end
end
```
|
Panic Room is a 2002 American thriller film directed by David Fincher. The film stars Jodie Foster and Kristen Stewart as a mother and daughter whose new home is invaded by burglars, played by Forest Whitaker, Jared Leto, and Dwight Yoakam. The script was written by David Koepp, whose screenplay was inspired by news coverage in 2000 about panic rooms.
The film was Fincher's fifth feature film, following Fight Club (1999). Fincher and Koepp brought together a crew of people with whom each had worked before. The house and its panic room were built on a Raleigh Studios lot. Nicole Kidman was originally cast as the mother, but she left after aggravating a previous injury. Her departure threatened the completion of the film, but Foster quickly replaced Kidman. The filmmakers used computer-generated imagery to create the illusion of the film camera moving through the house's rooms. Foster became pregnant during the shooting schedule, so filming was suspended until after she gave birth. The film's production cost .
The film was commercially released in the United States and Canada on , 2002. The film grossed on its opening weekend. In the United States and Canada, it grossed . In other territories, it grossed for a worldwide total of . The film was well-received by critics, who praised Foster's performance and the film's suspense. Panic Room has been assessed for its portrayal of childhood and feminism, the elements of video surveillance and diabetes, and its thematic approach to mortality.
Plot
Recently divorced Meg Altman and her eleven-year-old daughter, Sarah, move into a four-story brownstone in New York City's Upper West Side. The house's previous owner, a reclusive millionaire, installed a "panic room" to protect the occupants from intruders. The room is reinforced by concrete and steel on all sides and a thick steel door. There is also an extensive security system with multiple surveillance cameras and a public address system.
On Meg and Sarah's first night, three men break into the home: Junior, the previous owner's grandson; Burnham, an employee of the home's security company; and Raoul, a thug Junior has recruited. They intend to steal bearer bonds locked inside a floor safe inside the panic room by the previous owners, as Junior doesn't want to share them with his extended family when his grandfather's estate is settled in probate.
When Meg awakes during the night to use the bathroom, she sees the men on the security cameras, and she and Sarah rush to the panic room. To force them out, the men pump propane gas into the room's air vents. Meg ignites the gas while she and Sarah cover themselves with fireproof blankets; the ignited propane leaves Junior badly burned. Meg taps into the main telephone line and calls her ex-husband, Stephen. As she attempts to explain their situation, the intruders cut the line, abruptly ending the call.
When all attempts to breach the room fail, Junior gives up on the robbery, while letting slip that there is more money in the safe than he initially disclosed. When he attempts to leave, Raoul fatally shoots him then forces Burnham to continue with the robbery. Stephen arrives and is immediately taken hostage. Raoul severely beats him, making sure Meg sees it on the security camera. Sarah, a diabetic, then suffers a seizure as her glucagon syringes are in her bedroom.
Raoul tricks Meg into thinking it is safe to temporarily leave the panic room and, when she leaves to retrieve Sarah's medication, the men enter the room with Sarah inside. Meg manages to throw the med kit in just as Burnham closes the door, inadvertently crushing Raoul's hand. She pleads with the men to give Sarah her medication, which Burnham does. Two policemen later arrive at the house following up on Stephen's earlier 911 call and complaints from the neighbors. To protect Sarah, Meg convinces the officers everything is fine and they leave. Meanwhile, Burnham opens the safe and finds $22 million in bearer bonds inside.
As the men prepare to leave using Sarah as a hostage, Meg leads them into an ambush where she uses a sledgehammer to knock Raoul over a banister and into a stairwell. As Burnham flees, the injured Raoul crawls back up and overpowers Meg, preparing to bludgeon her with the sledgehammer. Burnham, hearing Sarah's terrified screams, rushes back and shoots Raoul, killing him. The police, alerted by Meg's earlier odd behavior, arrive back at the house in force and apprehend Burnham, who is forced to drop the bearer bonds, which scatter in the wind.
A few days later, Meg and Sarah search the newspaper for a new, smaller home, having recovered from their harrowing ordeal.
Cast
Jodie Foster stars as Meg Altman, a recently divorced woman who, with her daughter Sarah, looks for a new home in New York City. Nicole Kidman was originally cast as Meg, but she left the project due to a knee injury. Foster, who almost joined the cast of Fincher's 1997 film The Game, replaced Kidman. Fincher said Kidman's portrayal was "about glamour and physicality", while Foster's portrayal was "more political". Meg was originally written to be helpless, but with Foster's involvement, the character was revised to be stronger. The casting change also led to Meg's being rewritten to be similar to her daughter, whereas Meg had been different from her before. Foster became pregnant soon after she started filming. She told the filmmakers, and they decided to keep filming her scenes but with a wardrobe that would conceal her pregnancy. Studio executives did not like the dailies and suspended production until Foster gave birth and returned to perform re-shoots. Foster was reportedly paid for her role.
Kristen Stewart stars as Sarah, Meg's diabetic daughter. Hayden Panettiere was originally cast as Sarah, but when she left the project toward the end of 2000, Stewart was cast in the role. Panic Room was Stewart's second feature film after The Safety of Objects (2001). When Kidman was cast as Meg, Fincher said Stewart was "to complement [Kidman's portrayal], to be her antithesis, tomboyish, androgynous, dismissive, a teenager at ten years old. It was about the daughter being a parent to her mother." When Foster replaced Kidman, the character Meg was rewritten so she and Sarah would be similar.
Forest Whitaker, Jared Leto, and Dwight Yoakam star as the film's burglars, Burnham, Junior, and Raoul, respectively. Whitaker's character Burnham was originally written to be "a slick, technical type" and the designer of the panic room in Meg and Sarah's home. Fincher did not think a designer could be persuaded to break into a home, so he rewrote the character to be a blue-collar worker who installs panic rooms for a living. The director told Whitaker to watch Key Largo (1948) and to emulate Humphrey Bogart's character. Whitaker said he liked Burnham's "conflicted" nature and preferred it to Raoul's villainy. Raoul was originally written to be "a giant scary hulking guy", but Fincher rewrote him to be "this wiry, mean kind of ex-con white trash guy". In one revised instance, Raoul punches Meg instead of slapping her to be reinforced as "an appalling character". The role of Raoul was originally offered to Maynard James Keenan, whom Fincher had directed in a music video for A Perfect Circle's "Judith". Keenan was too busy as the lead singer for Tool, so Fincher then offered the role to Yoakam, knowing him from his performance in Sling Blade (1996). For the role of Junior, Fincher cast Leto, who was in the cast of Fincher's previous film Fight Club (1999). As part of atypical class division, Junior is "the uptown rich kid", where Burnham is blue-collar, and Raoul is undefinable.
Patrick Bauchau had a minor role as Meg's ex-husband Stephen. Kidman, though she left the primary role due to her knee injury, had an uncredited off-screen role as the voice of Stephen's supermodel girlfriend. Screenwriter Andrew Kevin Walker, who was a credited writer for Seven and The Game and an uncredited writer for Fight Club, had a cameo in Panic Room as a sleepy neighbor.
Production
David Fincher – director
David Koepp – screenwriter, producer
Ceán Chaffin – producer
Judy Hofflund – producer
Gavin Polone – producer
Howard Shore – composer
Conrad W. Hall – cinematographer
Darius Khondji – cinematographer
James Haygood – editor
Angus Wall – editor
Arthur Max – production designer
Keith Neely – art director
James E. Tocci – art director
Jon Danniells – set decorator
Garrett Lewis – set decorator
Michael Kaplan – costume designer
Panic Room was directed by David Fincher based on a screenplay written by David Koepp. The film, produced at Columbia Pictures, was Fincher's fifth feature film, following Fight Club (1999). Koepp was also a producer for Panic Room, and he was joined by Judy Hofflund and Gavin Polone, with whom he collaborated on Stir of Echoes (1999). Fincher included as producer Ceán Chaffin, with whom he had worked on commercials and music videos. Fincher also included in his initial crew people with whom he had worked before: cinematographer Darius Khondji, production designer Arthur Max, costume designer Michael Kaplan, and editors James Haygood and Angus Wall.
Fincher envisioned Panic Room as a popcorn movie about survival. His previous film Fight Club had 400 scenes and 100 locations, so he wanted to simplify the production of Panic Room. To this end, he wanted to focus production on a single set and to plan the scenes and shots thoroughly before the start of filming. Despite the preparation, he experienced difficulty in production with changes in the cast and the crew as well as the inherent inflexibility of his initial planning.
Development
Screenwriter David Koepp was inspired by news coverage in 2000 about how safe rooms were becoming prevalent among the wealthy living in urban areas. He sold the script to Sony Pictures for . Before Fincher's involvement, director Ridley Scott was briefly connected to the project, and actor-director Forest Whitaker studied the script before declining the opportunity to direct. Fincher said he was interested in the script's omniscience and that he was reminded of "the specific subjectivity" of Rear Window (1954). He also saw Panic Room as a cross between Rear Window and Straw Dogs (1971), though he was concerned "a modern audience" would compare Panic Room more to Home Alone (1990) than to Rear Window.
Fincher also saw Panic Room as a crime thriller similar to The Treasure of the Sierra Madre (1948), where money is "an object that everyone's after for the wrong reasons". The director was also interested in the story's conciseness of happening in one place and in one night, and how the screenplay was well-laid out to let the director decide a variety of shots and use of set-pieces. Fincher also saw the project as a way to be "in lock-step with the audience" in a change of pace from his previous films.
Koepp's screenplay emphasized pace over exposition. Koepp and Fincher agreed to streamline the film so the opening would introduce the characters as soon as possible. Fincher also sought to lay out the film so audiences could see characters make plans and thus be ahead of them, calling the tense foresight "a very cinematic notion". He wanted to track the different characters' agendas and to also keep scenes chronological, so he set up "computer-generated motion-control shots" to move the camera around the set. He planned scenes in which parallel scenes could be seen through the panic room's video monitors and also intercut between different characters. The final screenplay was similar in outline to the original one; there were minor changes in dialogue and specific moments, especially in the interaction between Meg and Sarah Altman due to Foster replacing Kidman. Explicit mention of Sarah's diabetes, such as the emergency syringe containing glucagon, were removed from the dialogue. Careful beverage intake, refrigerated medicine bottles, and Sarah's glucometer watch were intended as evidence of her diabetes.
Pre-production
The house was built on a soundstage on a Raleigh Studios lot. The set was designed by production designer Arthur Max, and it cost to build. The panic room was by . Three versions of the room were built so Fincher could film scenes from multiple angles. A 3D computer model of the set on the soundstage was designed. Fincher, who had done pre-visualization for Fight Club, used the model to design shots and decide their sequence. The computer model also enabled the camera to have "total freedom to travel" inside the house. Fincher said, "What we were just trying to do with CG was to say, there's no camera operator, there's no crew, there's no track, and the camera can go everywhere." The crew applied photogrammetry—"mapping still images over the surface of computer-generated 'sets'". The filming schedule was also shortened since camera setups could be evaluated and discarded virtually. Fincher had two-thirds of Panic Rooms shots planned before the start of filming. Director Steven Soderbergh reviewed Fincher's test footage and warned him that excessive planning would make actual production difficult for him and his crew.
Fincher sought to light his film less than most other films; he believed darkness contributed to the scare factor. Entering production, he initially planned to film the first half of the film in near-total darkness but decided that it required too much patience from audiences. Instead, he chose a "shadowy ambience" as a backdrop for Meg and Sarah Altman.
Filming
Casting began in 2000, with Nicole Kidman and Hayden Panettiere cast as Meg and Sarah Altman, the film's mother and daughter. Forest Whitaker, Jared Leto, and Dwight Yoakam were also cast as the film's burglars. In December 2000, before the start of filming, Panettiere left the project, and was replaced by Kristen Stewart. Filming began in January 2001. Shortly after the start of filming, cinematographer Darius Khondji was fired from the film. Khondji said he was fired after a conflict with a crew member that he did not want to name, but David Fincher said he and Khondji could not agree "on aspects of production". Much of the film was already planned in pre-production, and Khondji could not be given flexibility. Fincher replaced Khondji with Conrad W. Hall, with whom he found "a balance". Khondji said he supported Hall as his replacement.
After two weeks of filming, at the end of January 2001, Kidman was injured on set. An x-ray revealed a hairline fracture underneath one of her knee joints. The fracture was an injury from Kidman's filming of Moulin Rouge! (2001), and the fracture had never fully healed. When Kidman left the project, Fincher continued filming scenes that did not include her character. During the same time of Kidman's departure, the Writers Guild of America and the Screen Actors Guild were threatening to strike over contractual disputes, so Fincher was pressured to re-cast the role of Meg Altman before it took place. Since the film was early in production, Fincher was ready to shut down, but the studio wanted to continue production and find a replacement. If the studio had shut down production permanently, it would have collected from insurance. If production was shut down then restarted, it would cost the studio , necessitating a quick replacement for Kidman. Rumored actors included Sandra Bullock, Angelina Jolie, and Robin Wright. Jodie Foster was previously occupied with directing duties of Flora Plum before its star Russell Crowe was injured and left the project, leading to that production's shutdown. To join Panic Room, Foster also stepped down as head of the awards jury at the 2001 Cannes Film Festival. Foster had a week to prepare for her role before filming resumed.
Five weeks after Foster began filming Panic Room, she learned she was pregnant. She informed Fincher and his producer Chaffin of her pregnancy, and they decided to continue filming. Fincher did not want to rush production, so Foster changed her wardrobe from a tank top to a heavy sweater to disguise indications of her pregnancy. For action scenes, stunt double Jill Stokesberry replaced Foster.
In the film's progression, the house degrades in quality, so Fincher filmed scenes in continuity as the set changed. He also filmed many sequences twice due to their near-parallel appearance on the panic room's video monitors. Editor Wall said there were for the film with most set-ups having two cameras. One repeated take was when Raoul attempts to break into the panic room through the plaster ceiling below it. The plaster took 45 minutes to replace, so combined with repeated takes, a scene that was an eighth of a page in the script took two days to film. Another repeated take was one five-second shot being filmed over a hundred times: Meg being attacked by Raoul and dropping Sarah's medical kit. The shot was repeated so it would look like Meg did not toss the kit but instead lost it. Simultaneously, the kit needed to land in frame and in focus for the audience. Fincher argued for repeated takes so he could combine performances by the actors for "fluid" scenes. He also repeated takes with Stewart to ensure that her acting would be comparable to Foster's veteran performance.
The studio planned to release Panic Room in February 2002, but it determined that production could not be completed by then. Executives reviewed dailies of the film's opening scene and did not like Foster "hiding her stomach under a coat and purse". (Foster was also suffering from a sprained hip from distended ligaments due to her pregnancy.) The studio suspended production until after Foster's childbirth and rescheduled for the film to be released in March 2002. Foster gave birth in September 2001, and she returned to perform re-shoots, including the opening scene. She also returned two months later for additional filming, which concluded that November. Columbia Pictures screened the film for test audiences, who rated poorly the ending with the SWAT raid and Burnham's capture. By the screening, the set had been deconstructed due to storage costs, and Fincher estimated that it would cost to rebuild enough of the set to reshoot the ending. Instead, editors Haygood and Wall revisited Burnham's scenes and chose takes in which the character would appear less sympathetic. The final production budget for Panic Room was .
Visual and practical effects
A seamless shot at the beginning of Panic Room took nine days to film on set but took several months to complete in post-production. The shot was a combination of camera footage and computer-generated effects. Koepp originally wrote the opening scene to be a series of shots that would zero in on the brownstone house, but Fincher instead chose a sequence of landmarks in New York City with credits hovering in front of them before the sequence transited seamlessly to introduce the film's main characters. The opening titles were inspired by those seen in The Trouble with Harry (1955) and North by Northwest (1959). The scene of Burnham's arrest also used computer-generated effects. Several scenes also involved practical effects: Junior's injuries from a flaming gas burn and Stephen Altman's bloodied, beaten self. A team of puppeteers was used to move Stephen's sticking-out collarbone. Fincher also sent the film reel to be digitally color-corrected as he had done for Fight Club and Seven.
Analysis
Conspiracy thrillers and feminism
Academic Jyotsna Kapur identifies Panic Room as one of several American conspiracy thrillers in the 2000s that re-cast the subject of childhood as "one of horror and alarm", where it had previously been a subject of celebration in family films dating back to the early 1980s. Kapur also says the depiction of paranoia in the decade's conspiracy thrillers is divided by gender, describing the male protagonist as "an idealized subject who thinks fast on his feet and cuts through fear to find the conspirators". In contrast, the female protagonist "gives in to her fear, turns delusional and vulnerable to suggestion"; Kapur cites Meg Altman in Panic Room as such a depiction with her divorcee status and her residence in a home too big for her and her daughter Sarah. The academic says calling this depiction merely a sexist stereotype is too dismissive: "It is logical that anxieties around the home and loss of children would privilege women because the domestic sphere has remained a gendered space." Kapur recalls 1940s films wherein a woman enters the husband's home as a stranger, with "the house and the husband as sources of dependence and dread". She contrasts them with films like Panic Room, in which the female protagonists instead defend against dangerous intruders. She writes, "They are not economically dependent on the marriage. Yet they portray for most of the film an image of feminized vulnerability, replaying the racist trope of diminutive white women in need of protection from outsider threats."
Medicine and technology
Panic Room is one of several films at the turn of the 21st century that use video surveillance as a key element. In particular, video surveillance is featured to illustrate aspects of a "surveillance society". The home is wired with a closed-circuit television system, and the images are displayed in the home's panic room. Since the burglars want to access the safe in the panic room where Meg and her daughter Sarah are hiding, there is an irreconcilable contradiction of freedom and safety. Dietmar Kammerer says there is no closed system within the home for the characters: "There is always communication; every action provokes a reaction." In contrast, the film's "camera eye" can travel unimpeded throughout the home, passing through walls. The surveillance footage in the film is never the camera eye; the camera eye itself observes the footage on the monitors. Of the cameras, Kammerer says, they are "Extremely mobile, but unstable: the surveillance technology in Panic Room is useful and harmful, good and evil at once." When the cameras are destroyed, Meg and Sarah are able to overcome the burglars. Kammerer says the cameras reflect ambivalence in the film, between "freedom and security, openness and closedness".
In the film, Sarah is diabetic. Kevin L. Ferguson says, "With diabetes, this self-aware focus on the ethics of the body is drawn sharply by films that also raise the older form of direct, punitive power. This is the reason why diabetics appear with frequency in films involving criminality and law." In a review of nearly forty films with diabetes as a key element, Panic Room is one of the only three that shows a glucometer (a device diabetics use to measure their glucose; Sarah wears a glucometer as a watch.) Sarah's diabetes in the film is never explicitly outlined for audiences, but they hear dialogue about moderating beverage intake and see the glucometer count down. Ferguson says, "The glucometer arranges the viewer's acknowledgement of diabetic selfcare, thus implicating the viewer in the process of control. The pure watchfulness of cinemagoers mimics the controlling relationship diabetic characters must endure." Though mother and daughter bond in the film, the mother actively monitors her daughter's health. Ferguson says, "Panic Rooms emphasis on vision and technology necessitates a paternalistic, monitoring attitude towards the diabetic character." He also notes that the glucometer parallels the overarching surveillance system in the film in being read "excessively".
Approach to mortality
Academic John Kitterman says audiences see Panic Room as a way to confront their fears and to achieve catharsis, but he argues that the film cannot provide that experience authentically. He notes that the film's protagonist Meg Altman is reminded by the panic room of author Edgar Allan Poe, who wrote several short stories related to premature burial. Kitterman highlights one story, "The Premature Burial", as synonymous with Panic Room. He says, in both works, "It is in the representing or acting out of such fears of being buried alive or being the victim of a home invasion that the protagonist actually calls for that trauma to happen." He says that Meg's nervous recognition of the panic room guarantees that her fear will come to pass. Though the home "looks like a mausoleum", the combination of the panic room's being able to monitor all the rooms and the unbounded movement of the film's camera leads audiences to believe they have some control over confronting their fears. Kitterman says the confrontation is unauthentic because of the function of Jacques Lacan's symbolic order, "We can never find what we are looking for because truth and reality exist on a different plane of discovery... Truth is hidden in the symbolic order, and no panoptical vision is going to reveal it to us." Kitterman says the film hides the truth of mortality, especially by making everywhere in the film visible to audiences. He concludes, "[Fincher] hides the truth behind a veil of visibility, using the camera to create a hegemony of vision that brainwashes us all into believing that what we are seeing is real. But the real of death cannot be symbolized."
Theatrical run
Columbia Pictures marketed Panic Room as being produced by the same director who produced Seven and Fight Club. Fincher disagreed with the approach because he believed that Panic Room did not match the tone of his previous two films and that it would not appeal to the same audiences. He believed Panic Room would appeal more to audiences who saw Kiss the Girls (1997) and The Bone Collector (1999). He also disagreed with the studio's marketing materials for Panic Room, which advertised it as "the most terrifying movie ever made". Fincher also argued with the studio about the poster design, which he believed reflected the film's themes, and the studio relented in publishing Fincher's poster.
Panic Room had its world premiere on , 2002 in Los Angeles. Fincher refused to edit the film to receive a PG-13 rating (parental guidance for children under 13) from the Motion Picture Association of America, so the MPAA gave the film an R rating (restricted to filmgoers at least 17 years old) for violence and language. It was commercially released in the United States and Canada on March 29, 2002. It was screened in and grossed on its opening weekend. It ranked first at the box office, and for both actor Jodie Foster and director David Fincher, the opening weekend gross was a personal best to date. It surpassed The Matrix (1999) to have the biggest Easter holiday-weekend opening and also had the third biggest opening to date for a non-supernatural thriller film, following Hannibal (2001) and Ransom (1996). Audiences polled by CinemaScore, during the opening-weekend, gave Panic Room a "B" grade on an A+ to F scale. The audience demographic was 53% female and 47% male, and 62% of audience members were aged 25 years and older.
In the film's second weekend (April 5–7) in the United States and Canada, it ranked first again with , competing mainly with the new release High Crimes. The film went on to gross at the US and Canadian box office and in other territories' box offices for a worldwide total of . (In 2006, the film had a re-release in Hong Kong that grossed , increasing the total to .) The film was Fincher's second highest-grossing to date after Seven, which grossed worldwide. In the United States and Canada, Panic Room ranks fifth among David Fincher's films in box office gross. Adjusted for inflation, Panic Room ranks third. Worldwide, unadjusted for inflation, it ranks fifth.
Critical reception
Critics called Panic Room "a high-tension narrative". They compared the film to the works of Alfred Hitchcock, both positively and negatively. Several critics thought the film was too mainstream after Fincher's Fight Club. Rotten Tomatoes reported that 76% of 188 sampled critics gave the film positive reviews, with an average rating of 6.9/10. The consensus states: "Elevated by David Fincher's directorial talent and Jodie Foster's performance, Panic Room is a well-crafted, above-average thriller." Metacritic, which uses a weighted average, gave the film a score of 65 out of 100 based on 36 critics, indicating "generally favorable reviews".
Joe Morgenstern of The Wall Street Journal said, "Seven was stylishly gloomy, and Fight Club was smarmily pretentious, while Panic Room has been admirably stripped down to atmosphere as a function of architecture, and action as a consequence of character." Morgenstern commended the characters Meg and Sarah as feminist heroines and also called the home invaders "intriguing". He also applauded Foster's performance and the film's cinematography, and he said to Koepp's script as "all worked out too". Film critic Roger Ebert gave the film three stars out of four, describing Panic Room as close to "the ideal of a thriller existing entirely in a world of physical and psychological plausibility." Ebert wrote, "There are moments when I want to shout advice at the screen, but just as often the characters are ahead of me." Ebert also called Fincher "a visual virtuoso", and applauded Foster's performance as "spellbinding".
Home media
Panic Room was first released on VHS and DVD on September 17, 2002. The studio produced VHS copies only for rental and not for sale, believing that owners of DVD players were more likely to buy the film. The studio used the design from the theatrical release poster for the video cover, where Fincher had wanted a black cover that would differ from the poster. Though previsualization supervisor Ron Frankel wanted to include materials to show storyboard animation, the DVD was released as a single-disc edition with no audio commentary or other features. Fincher also chose not to include on the DVD scenes filmed with Nicole Kidman before she was replaced by Jodie Foster. In its first week, the film ranked second in DVD sales after Monsters, Inc., though it ranked first in DVD rentals. In March 2004, the studio released a special edition DVD, which consisted of three discs, two which provided featurettes of the pre-production, production, and post-production processes for the film. The DVD also had several commentary tracks, including one by the director. Author John T. Caldwell cites the special edition DVD of Panic Room as an example of demonstrating directorial control to "aesthetically elevate" the film.
Columbia Pictures sold the television rights for Panic Room to Turner Broadcasting and CBS, who shared the rights over five years. In September 2004, Turner aired the film on channels TBS and TNT for 12 months, and afterward, CBS aired the film three times in an 18-month span. Turner resumed airing Panic Room for 30 months after CBS's turn.
A Blu-ray version of the film has yet to be released, but it is available in 1080p HD on Amazon Prime Video, iTunes, Google Play, and other streaming services.
Accolades
Howard Shore won from the American Society of Composers, Authors and Publishers an ASCAP Award in the Top Box Office Film music category for his scores for Panic Room and The Lord of the Rings: The Two Towers. The Art Directors Guild nominated Panic Room for the Excellence in Production Design for a Contemporary Film Award. The Online Film Critics Society Award nominated Panic Room for Best Editing. Panic Room won an award at the 3rd Golden Trailer Awards for having the Best Horror/Thriller film trailer, beating fellow nominees Signs, Brotherhood of the Wolf, Jurassic Park III, and No Such Thing. For her performance in the film, Jodie Foster was nominated for a Saturn Award for Best Actress.
See also
List of films featuring home invasions
List of films featuring surveillance
List of films featuring diabetes
List of thriller films of the 2000s
List of American films of 2002
Cinema of the United States
Notes
References
Footnotes
Bibliography
Further reading
(Novelization based on the screenplay written by David Koepp.)
External links
2002 films
2002 crime thriller films
2002 psychological thriller films
American crime thriller films
American psychological thriller films
Columbia Pictures films
Films about security and surveillance
Films directed by David Fincher
Films produced by David Koepp
Films scored by Howard Shore
Films set in New York City
Films shot in Los Angeles
Films shot in New York City
Films with screenplays by David Koepp
Home invasions in film
Films about mother–daughter relationships
2000s English-language films
2000s American films
|
```java
package apoc.mongodb;
import apoc.util.Util;
import java.io.Closeable;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import org.bson.Document;
public interface MongoDbCollInterface extends Closeable {
Map<String, Object> first(Map<String, Object> params);
Stream<Map<String, Object>> all(Map<String, Object> query, Long skip, Long limit);
long count(Map<String, Object> query);
long count(Document query);
Stream<Map<String, Object>> aggregate(List<Document> pipeline);
Stream<Map<String, Object>> find(
Map<String, Object> query, Map<String, Object> project, Map<String, Object> sort, Long skip, Long limit);
Stream<Map<String, Object>> find(Document query, Document project, Document sort, int skip, int limit);
void insert(List<Map<String, Object>> docs);
void insertDocs(List<Document> docs);
long update(Map<String, Object> query, Map<String, Object> update);
long update(Document query, Document update);
long delete(Map<String, Object> query);
long delete(Document query);
default void safeClose() {
Util.close(this);
}
class Factory {
public static MongoDbCollInterface create(
String url,
String db,
String coll,
boolean compatibleValues,
boolean extractReferences,
boolean objectIdAsMap) {
try {
return new MongoDBColl(url, db, coll, compatibleValues, extractReferences, objectIdAsMap);
} catch (Exception e) {
throw new RuntimeException("Could not create MongoDBColl instance", e);
}
}
public static MongoDbCollInterface create(String url, MongoDbConfig conf) {
try {
return new MongoDBColl(url, conf);
} catch (Exception e) {
throw new RuntimeException("Could not create MongoDBColl instance", e);
}
}
}
}
```
|
The 1973–74 WCHL season was the eighth season for the Western Canada Hockey League. Twelve teams completed a 68-game season. The Regina Pats won the President's Cup before going on to win the Memorial Cup.
League notes
The Vancouver Nats relocated to Kamloops, British Columbia to become the Kamloops Chiefs
The Winnipeg Jets became the Winnipeg Clubs.
Regular season
Final standings
Scoring leaders
Note: GP = Games played; G = Goals; A = Assists; Pts = Points; PIM = Penalties in minutes
1974 WCHL Playoffs
League quarter-finals
Swift Current defeated Flin Flon 4 games to 3
Regina defeated Saskatoon 4 games to 2
New Westminster defeated Medicine Hat 4 games to 2
Calgary defeated Edmonton 4 games to 1
League semi-finals
Regina defeated Swift Current 4 games to 2
Calgary defeated New Westminster 4 games to 1
WHL Championship
Regina defeated Calgary 4 games to 0
All-Star game
On January 29, the West All-Stars defeated the East All-Stars 6–5 at Edmonton, Alberta with a crowd of 2,471.
WHL awards
All-Star Team
Goaltender: Larry Hendrick, Edmonton Oil Kings
Defenseman: Pat Price, Saskatoon Blades
Defenseman: Ron Greschner, New Westminster Bruins & Greg Joly, Regina Pats (tied)
Centerman: Ron Chipperfield, Brandon Wheat Kings & Dennis Sobchuk, Regina Pats (tied)
Left Winger: Clark Gillies, Regina Pats
Right Winger: Danny Gare, Calgary Centennials
See also
1974 Memorial Cup
1974 NHL Entry Draft
1973 in sports
1974 in sports
References
whl.ca
2005–06 WHL Guide
Western Hockey League seasons
WCHL
|
South C or South Compton ( during colonial times) is a middle-class residential estate located in the southland area of Nairobi.
South C lies next to Wilson Airport. It is bordered by South B to the north-east, Langata Estate to the west and the Nairobi National Park to the south. Schools in South C include Andalucia academy, Kinderworld academy, Shree cutchi leva patel (Samaj), Shree cutchi satsang (swaminarayan), Nairobi Muslim girls boarding.
The headquarters of the Kenya Red Cross Society is located in South C as is the Criminal Investigation Department (C.I.D) Training School of the Kenya Police, National Environmental Management Authority Headquarters (NEMA), Kenya National Bureau of Standards Head office (KEBS) and the expansive Toyota Training Academy.
Major colleges like the College of Insurance and Management University of Africa are also based in South C.
South C is home to several sports clubs and hotels. The clubs include The South C Sports Club, Ministry of Works (MOW) Sports Club, Kenya Motor Sports Club, and the Ngara Sports Club. The Ngara Sport Club cricket ground is located in South C. Some of the hotels in South C are The Boma, The Red Court Hotel, Ole Sereni and Eka Hotel
A drive-in outdoor cinema, one among few in Kenya, is located at Nairobi's South C along Mombasa Road at Bellevue.
A number of musicians, comedians and DJs in Kenya's music industry come from the South C. Nameless, E-Sir, Longombas and K-rupt live there.
South C has recently become famous among residents of St. Louis, Missouri for being the birthplace of Martin Sophia, owner of the production company Martin's Entertainment.
References
Kenya Redcross Society
Geeskaafrika Magazine
UN Security Council
Trueblaq
South C Map
C.I.D
Pulse Magazine
Satellite view of South C
South C Ward
Suburbs of Nairobi
|
Legacy pollution or legacy pollutants are persistent materials in the environment that were created through a polluting industry or process that have polluting effects after the process has finished. Frequently these include persistent organic pollutants, heavy metals or other chemicals residual in the environment long after the industrial or extraction processes that produced them. Often these are chemicals produced by industry and polluted before there was widespread awareness of the toxic effects of the pollutants, and subsequently regulated or banned. Notable legacy pollutants include mercury, PCBs, Dioxins and other chemicals that are widespread health and environmental effects. Sites for legacy pollutants include mining sites, industrial parks, waterways contaminated by industry, and other dump sites.
These chemicals often have outsized impact in countries jurisdictions with little or no environmental monitoring or regulation—because the chemical were often produced in new jurisdictions after they were banned in more heavily regulated jurisdictions. Often in these countries, there is a lack of capacity in environmental regulatory, health and civic infrastructure to address the impact of the pollutants.
The impact of legacy pollutants can be visible many years after the initial polluting process, and require environmental remediation. Grassroots communities and environmental defender frequently advocate for responsibility of industry and states through environmental justice action and advocacy for recognition of human rights, such as the right to a healthy environment.
Types of sites
Brownfields
Mine tailings
Abandoned mines
Abandoned gas wells
International policy
The Stockholm Convention on Persistent Organic Pollutants is one of the main international mechanisms for supporting the elimination of legacy persistent organic pollutants such as PCBs.
References
Pollution
|
Carrie Frances Ricci is an American attorney and retired United States Army lieutenant colonel who serves as general counsel of the Army in the Biden administration.
Education
Ricci earned a Bachelor of Science in Business Administration from Georgetown University, a Juris Doctor from the University of Maryland Francis King Carey School of Law, a Master of Laws in military and international law from the Judge Advocate General's Legal Center and School, and a Master of Laws in intellectual property, privacy, and information technology from the George Washington University Law School.
Career
Ricci served in the Judge Advocate General's Corps from 1988 to 2010, retiring with the rank of lieutenant colonel. During her tenure, Ricci served in the Army Office of the General Counsel, United States Army Intelligence and Security Command, and at Fort Hood. After retiring, Ricci served as associate general counsel at the Department of Defense Education Activity from 2010 to 2012. She was also a member of the Fort Hood Independent Review Committee and Administrative Conference of the United States. She joined the United States Department of Agriculture in 2012 and served as assistant and associate general counsel for marketing and regulation during her tenure.
President Joe Biden announced Ricci's nomination to be general counsel of the Army on September 21, 2021, followed by a formal nomination on September 27. Her nomination was reported out of the Senate Armed Services Committee on December 8, and she was confirmed in the Senate by voice vote on December 14. Ricci was sworn in on January 3, 2022.
References
Living people
American lawyers
American military lawyers
Georgetown University alumni
University of Maryland Francis King Carey School of Law alumni
The Judge Advocate General's Legal Center and School alumni
George Washington University Law School alumni
United States Department of Agriculture officials
General Counsels of the United States Army
Year of birth missing (living people)
Biden administration personnel
|
The Council for a Beautiful Israel (CBI) () is a public non-profit organization focused on improving the quality of life in Israel. CBI was Israel's first environmental association.
History
The Council for a Beautiful Israel was founded in 1968 by the Interior Committee of the Knesset and Aura Herzog, who served as its international president. CBI oversees environmental awareness programs, environmental action on a national and local level, green urban projects and competitions revolving around environmental awareness.
In 2010, work began on a new environmental and educational center in Kiryat HaLeom, Jerusalem.
Most of the Council's work is carried out by volunteers, including children, who are known as the 'Guardians of a Beautiful Israel'.
Awards
The Yakir Award is awarded every year by the President of Israel for an outstanding contribution to the Jewish community in Israel and the Diaspora, especially in environmental issues and the preservation of quality of life in Israel. .
References
External links
The Council for a beautiful Israel
About the Council for a Beautiful Israel
The Council for a Beautiful Israel Projects
Nature conservation in Israel
|
The 2016 CEB Cup, the inaugural tournament of a new, annual European baseball competition, was held from June 1, to June 5, 2016. It was hosted in Rouen, France, and Chartres, France.
List of competing teams
First round
Pool A
|}
Pool B
|}
Second round
Pool C
|}
Semi-finals
|}
Third round
7th/8th Playoff
|}
Vienna Wanderers were relegated to the Federations Cup.
There will be no 5th/6th playoff so both teams will finish in joint 5th place.
3rd/4th Playoff
|}
Final
|}
Rouen Huskies were promoted to the CEB Champions Cup.
References
See also
European Baseball Championship
Asia Series
Caribbean Series
Baseball awards#Europe
European Cup (baseball)
International baseball competitions in Europe
Baseball in France
International sports competitions hosted by France
|
The 1988 Nabisco Grand Prix was the only men's tennis circuit held that year. It incorporated the four grand slam tournaments, three World Championship Tennis tournaments and the Grand Prix tournaments.
Schedule
The table below shows the 1988 Nabisco Grand Prix schedule (a precursor to the ATP Tour).
Key
January
February
March
April
May
June
July
August
September
October
November
December
Grand Prix rankings
List of tournament winners
The list of winners and number of Grand Prix titles won, alphabetically by last name:
Andre Agassi - Memphis, Charleston, Forest Hills, Stuttgart, Stratton Mountain, Livingston (6)
Boris Becker - Indian Wells, Dallas, London, Indianapolis, Tokyo Indoors, Stockholm, Season-Ending Championships (7)
Jay Berger - São Paulo (1)
Darren Cahill - Gstaad (1)
Kent Carlsson - Madrid, Hamburg, Kitzbühel, St. Vincent, Barcelona (5)
Michael Chang - San Francisco (1)
Andrei Chesnokov - Orlando (1)
Jimmy Connors - Washington, D.C., Toulouse (2)
Yahiya Doumbia - Lyon (1)
Stefan Edberg - Rotterdam, Wimbledon, Basel (3)
Marcelo Filippini - Båstad (1)
John Fitzgerald - Sydney (1)
Brad Gilbert - Tel Aviv (1)
Dan Goldie - Seoul (1)
Jakob Hlasek - Wembley, Johannesburg (2)
Ramesh Krishnan - Wellington (1)
Henri Leconte - Nice, Brussels (2)
Ivan Lendl - Monte Carlo, Rome, Canada (3)
Alberto Mancini - Bologna (1)
Amos Mansdorf - Auckland, Paris (2)
Wally Masur - Newport (1)
Luiz Mattar - Guarujá (1)
Tim Mayotte - Philadelphia, Schenectady, Brisbane, Frankfurt (4)
John McEnroe - Tokyo, Detroit (2)
Miloslav Mečíř - Seoul Olympics (1)
Thomas Muster - Boston, Bordeaux, Prague, Bari (4)
Massimiliano Narducci - Florence (1)
Yannick Noah - Milan (1)
Guillermo Pérez Roldán - Munich (1)
Mikael Pernfors - Los Angeles, Scottsdale (2)
Christian Saceanu - Bristol (1)
Emilio Sánchez - Hilversum (1)
Javier Sánchez - Buenos Aires (1)
Horst Skoff - Athens, Vienna (2)
Milan Šrejber - Rye Brook (1)
Jonas Svensson - Metz (1)
Marián Vajda - Geneva (1)
Mats Wilander - Australian Open, Miami, Roland Garros, Cincinnati, US Open, Palermo (6)
Mark Woodforde - Adelaide (1)
Jaime Yzaga - Itaparica (1)
Slobodan Živojinović - Sydney Indoors (1)
The following players won their first title in 1988:
Darren Cahill
Michael Chang
Yahiya Doumbia
Marcelo Filippini
Jakob Hlasek
Alberto Mancini
Massimiliano Narducci
Mikael Pernfors
Christian Saceanu
Javier Sánchez
Horst Skoff
Milan Šrejber
See also
Tennis exhibitions in 1988
1988 WTA Tour
References
ATP Archive 1988: Nabisco Grand Prix Tournaments Accessed 22/10/2010.
History Mens Professional Tours:Accessed 22/10/2010.
Further reading
Grand Prix tennis circuit seasons
Grand Prix
|
Myanmar participated in the 2015 Southeast Asian Games from 5th to 16th June 2015.
Competitors
Medal summary
Medal by sport
Medal by date
Medalists
Multiple medalists
References
External links
Nations at the 2015 SEA Games
2015
Southeast Asian Games
Southeast Asian Games
|
is a railway station on the Aoimori Railway Line in the town of Oirase in Aomori Prefecture, Japan, operated by the third sector railway operator Aoimori Railway Company.
Lines
Mukaiyama Station is served by the Aoimori Railway Line, and is 79.7 kilometers from the terminus of the line at Aomori Station. It is 659.5 kilometers from Tokyo Station.
Station layout
Mukaiyama Station has a single ground-level island platform serving two tracks connected to the station building by a footbridge. The station is unattended.
Platforms
History
The station opened on July 10, 1936. With the privatization of JNR on April 1, 1987, it came under the operational control of East Japan Railway Company (JR East). With the opening of the Tohoku Shinkansen extension to , the section of the Tohoku Main Line including this station was transferred to the Aoimori Railway on December 4, 2010.
Surrounding area
Kawano Green Farm
See also
List of Railway Stations in Japan
References
External links
Aoimori Railway station information
Railway stations in Aomori Prefecture
Railway stations in Japan opened in 1936
Oirase, Aomori
Aoimori Railway Line
|
In the folklore of the Sámi, a Stállo (also Staaloe, Stalo or Northern Sami Stállu) is a large, human-like creature who likes to eat people and who therefore is usually in some form of hostilities with a human. Stallos are clumsy and stupid, and thus humans often gain the upper hand over them.
The Vindelfjällen Nature Reserve contains the remains of ancient, large building foundations, considered by the Sami to be the remains of Stallo dwellings. There is also a huge stone placed on some small pebbles on top near Lake Giengeljaure named stalostenen, which literally means "the Stallo stone." Legend dictates that a Stallo would have placed a stone here to prove his strength.
Stallo sites
On account of the identification of relics of ancient buildings with the 'stallo' in the southern part of the Sámi area of Sweden, archaeologists have come to refer to such relics as '' generally, following the lead of Ernst Manker's 1960 study Fångstgropar och stalotomter ('hunting pits and stallo sites'). Such buildings are actually round or oval, with a diameter of four to six metres, arranged linearly in groups of two to eight (or, more rarely, more, up to fifteen). Around sixty such sites are known, distributed along what is now the Norway-Sweden border, from Frostviken in Jämtland county to the south, to Devddesvuopmi in Troms to the north. They are found above the tree line, at heights between 550 and 850 metres. They seem to have been in most extensive use around 800–1050 CE, that is, during the Viking Age. Scholars agree that these were temporary dwellings, probably for use in the warmer months, and that they reflect a change in the economic habits of their users, almost certainly associated with hunting or herding reindeer. Nevertheless, there is extensive debate over whether the inhabitants were ethnically Norse or Sámi, where their permanent habitations were located, and their purpose. As of 2014, debate was ongoing, but opinion at that time favoured the idea that the stallo sites were used by Sámi people, partly because the layout of the buildings corresponds to later Sámi dwellings.
In folklore
Stallo appears in Sámi folktales, such as How the Stalos were Tricked, Stalo och Kauras, and The Tale of Njunje Paggas.
See also
Jötunn
Ogre
Oni
Troll
References
Further reading
HATT, EMILIE DEMANT, and Barbara Sjoholm. "Folktales". In: By the Fire: Sami Folktales and Legends. Minneapolis; London: University of Minnesota Press, 2019. pp. 58-67. Accessed September 12, 2021. doi:10.5749/j.ctvfjcx2d.9.
HATT, EMILIE DEMANT, and Barbara Sjoholm. "Field Notes and Commentary". In: By the Fire: Sami Folktales and Legends. Minneapolis; London: University of Minnesota Press, 2019. pp. 102-104. Accessed September 12, 2021. doi:10.5749/j.ctvfjcx2d.11.
Koskimies, August V., Toivo I. Itkonen, and Lea Laitinen. “BELIEF LEGENDS.” In: Inari Sámi Folklore: Stories from Aanaar. Edited by Tim Frandy. University of Wisconsin Press, 2019. pp. 87-97. https://doi.org/10.2307/j.ctvfjcxnm.15.
Giants
Mythic humanoids
Sámi fairy tales
Archaeological sites in Sweden
|
```java
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
package io.camunda.optimize.service.importing.zeebe.mediator;
import static io.camunda.optimize.MetricEnum.NEW_PAGE_FETCH_TIME_METRIC;
import io.camunda.optimize.OptimizeMetrics;
import io.camunda.optimize.dto.zeebe.usertask.ZeebeUserTaskRecordDto;
import io.camunda.optimize.service.importing.PositionBasedImportMediator;
import io.camunda.optimize.service.importing.engine.mediator.MediatorRank;
import io.camunda.optimize.service.importing.engine.service.zeebe.ZeebeUserTaskImportService;
import io.camunda.optimize.service.importing.zeebe.db.ZeebeUserTaskFetcher;
import io.camunda.optimize.service.importing.zeebe.handler.ZeebeUserTaskImportIndexHandler;
import io.camunda.optimize.service.util.BackoffCalculator;
import io.camunda.optimize.service.util.configuration.ConfigurationService;
import io.camunda.zeebe.protocol.record.ValueType;
import java.util.List;
public class ZeebeUserTaskImportMediator
extends PositionBasedImportMediator<ZeebeUserTaskImportIndexHandler, ZeebeUserTaskRecordDto> {
private ZeebeUserTaskFetcher zeebeUserTaskFetcher;
public ZeebeUserTaskImportMediator(
final ZeebeUserTaskImportIndexHandler importIndexHandler,
final ZeebeUserTaskFetcher zeebeUserTaskFetcher,
final ZeebeUserTaskImportService importService,
final ConfigurationService configurationService,
final BackoffCalculator idleBackoffCalculator) {
this.importIndexHandler = importIndexHandler;
this.zeebeUserTaskFetcher = zeebeUserTaskFetcher;
this.importService = importService;
this.configurationService = configurationService;
this.idleBackoffCalculator = idleBackoffCalculator;
}
@Override
public MediatorRank getRank() {
return MediatorRank.INSTANCE_SUB_ENTITIES;
}
@Override
protected boolean importNextPage(final Runnable importCompleteCallback) {
return importNextPagePositionBased(getUserTasks(), importCompleteCallback);
}
@Override
protected String getRecordType() {
return ValueType.USER_TASK.name();
}
@Override
protected Integer getPartitionId() {
return zeebeUserTaskFetcher.getPartitionId();
}
private List<ZeebeUserTaskRecordDto> getUserTasks() {
return OptimizeMetrics.getTimer(NEW_PAGE_FETCH_TIME_METRIC, getRecordType(), getPartitionId())
.record(
() ->
zeebeUserTaskFetcher.getZeebeRecordsForPrefixAndPartitionFrom(
importIndexHandler.getNextPage()));
}
}
```
|
Sigurd Hart or Sigurd Hjort was a legendary king of Ringerike (modern central south Norway), during the late 9th or early 10th centuries. he is mentioned in Ragnarssona þáttr ("The Tale of Ragnar's Sons") and in Halvdan Svartes saga ("Halfdan the Black's Saga").
Ragnarssona þáttr states that Sigurd Hart was the son of Helgi the Sharp (the great-great-grandson of king Ring of Ringerike) of the Dagling dynasty and Helgi's wife Aslaug. Helgi was reportedly the son-in-law of Sigurd Snake-in-the-Eye (one of Ragnar Lodbrok's sons) and Blaeja, the daughter of king Aelle II of Northumbria.
Biography
Traditional sources state that Sigurd Hart was only 12 years old when he slew a berserker named Hildibrand in a duel, and 11 other men. He married a woman named Ingeborg (supposedly the daughter of the historical Jutish chieftain Harald Klak, c. 785 – c. 852, although Harald was probably too old for that to be true). Sigurd Hart and Ingeborg had children named Guttorm Sigurdsson and Ragnhild Sigurdsdotter. When Sigurd Hart's uncle, king Fróði of Ringerike died, Sigurd Hart supposedly went to Norway to succeed him as king of Ringerike.
There are a number of unlikely claims or implied claims about Sigurd Hart's descendants in Ragnarssona þáttr, Heimskringla, and Fagrskinna.
One is the suggestion that he was the father of Ragnhild Sigurdsdotter, who was kidnapped by, and the wife of, Halfdan the Black (c. 810 – c. 860), and mother of Harald Fairhair. This would seem impossible unless two different men named Sigurd Hart were involved – given that most sources suggest that his father was active in the late 9th century, which would make Sigurd Hart about two generations younger than Ragnhild Sigurdsdotter.
Another unlikely claim suggests that the legendary Danish king Harthacanute (born c. 880) was a descendant of Sigurd Hart, although Harthacanute may well have been born before Sigurd. (Harthacanute succeeded Sigtrygg Gnupasson as the king of Zealand, Scania and Halland, but he lost Viken (Oslofjord). He was the father of Gorm the Old (born before 900), the king of Denmark. Gorm succeeded his father as king and married Thyra. Gorm's son, Harald Bluetooth (born c. 935) succeeded his father as king and married Gyrid of Sweden. They had a son named Sweyn Forkbeard. Sweyn succeeded his father as king and married Gunhild (Świętosława of Poland). They had a son named Cnut the Great. Sweyn also ruled England in his lifetime and established the Danish Empire. When Sweyn died, his elder son Harald Svendsen became the King of Denmark, while England's former king, Ethelred reclaimed the throne. Following Harald's death, his brother Cnut the Great became king, re-established the Danish North Sea Empire. He married Emma of Normandy with whom he had a son named Harthacnut. When Cnut died, Harthacnut became king of Denmark and England. Upon his death, Edward the Confessor became ruler of England in 1042.)
References
Heroes in Norse myths and legends
Norwegian petty kings
Viking warriors
9th-century Norwegian monarchs
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var tape = require( 'tape' );
var isnan = require( '@stdlib/math/base/assert/is-nan' );
var abs = require( '@stdlib/math/base/special/abs' );
var PINF = require( '@stdlib/constants/float64/pinf' );
var NINF = require( '@stdlib/constants/float64/ninf' );
var EPS = require( '@stdlib/constants/float64/eps' );
var logpmf = require( './../lib' );
// FIXTURES //
var smallP = require( './fixtures/julia/small_p.json' );
var largeP = require( './fixtures/julia/large_p.json' );
// TESTS //
tape( 'main export is a function', function test( t ) {
t.ok( true, __filename );
t.strictEqual( typeof logpmf, 'function', 'main export is a function' );
t.end();
});
tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
var y = logpmf( NaN, 1.0 );
t.equal( isnan( y ), true, 'returns NaN' );
y = logpmf( 0.0, NaN );
t.equal( isnan( y ), true, 'returns NaN' );
t.end();
});
tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
var y = logpmf( PINF, 0.01 );
t.equal( y, NINF, 'returns -Infinity' );
t.end();
});
tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
var y = logpmf( -20.0, 0.5 );
t.equal( y, NINF, 'returns -Infinity' );
y = logpmf( -4.0, 0.5 );
t.equal( y, NINF, 'returns -Infinity' );
y = logpmf( -1.0, 0.5 );
t.equal( y, NINF, 'returns -Infinity' );
t.end();
});
tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
var y = logpmf( -1.3, 0.5 );
t.equal( y, NINF, 'returns -Infinity' );
y = logpmf( 2.4, 0.5 );
t.equal( y, NINF, 'returns -Infinity' );
y = logpmf( 0.5, 0.5 );
t.equal( y, NINF, 'returns -Infinity' );
t.end();
});
tape( 'if provided a success probability `p` outside of `[0,1]`, the function always returns `NaN`', function test( t ) {
var y;
y = logpmf( 2.0, -1.0 );
t.equal( isnan( y ), true, 'returns NaN' );
y = logpmf( 0.0, 1.5 );
t.equal( isnan( y ), true, 'returns NaN' );
t.end();
});
tape( 'the function evaluates the logpmf for `x` given small parameter `p`', function test( t ) {
var expected;
var delta;
var tol;
var x;
var p;
var y;
var i;
expected = smallP.expected;
x = smallP.x;
p = smallP.p;
for ( i = 0; i < x.length; i++ ) {
y = logpmf( x[i], p[i] );
if ( y === expected[i] ) {
t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
} else {
delta = abs( y - expected[ i ] );
tol = 2.0 * EPS * abs( expected[ i ] );
t.ok( delta <= tol, 'within tolerance. x: '+x[ i ]+'. p: '+p[i]+'. y: '+y+'. E: '+expected[ i ]+'. : '+delta+'. tol: '+tol+'.' );
}
}
t.end();
});
tape( 'the function evaluates the logpmf for `x` given large parameter `p`', function test( t ) {
var expected;
var delta;
var tol;
var x;
var p;
var y;
var i;
expected = largeP.expected;
x = largeP.x;
p = largeP.p;
for ( i = 0; i < x.length; i++ ) {
y = logpmf( x[i], p[i] );
if ( y === expected[i] ) {
t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
} else {
delta = abs( y - expected[ i ] );
tol = 1.5 * EPS * abs( expected[ i ] );
t.ok( delta <= tol, 'within tolerance. x: '+x[ i ]+'. p: '+p[i]+'. y: '+y+'. E: '+expected[ i ]+'. : '+delta+'. tol: '+tol+'.' );
}
}
t.end();
});
```
|
```go
// Code generated by smithy-go-codegen DO NOT EDIT.
package ec2
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/ec2/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Information about one or more Traffic Mirror targets.
func (c *Client) DescribeTrafficMirrorTargets(ctx context.Context, params *DescribeTrafficMirrorTargetsInput, optFns ...func(*Options)) (*DescribeTrafficMirrorTargetsOutput, error) {
if params == nil {
params = &DescribeTrafficMirrorTargetsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeTrafficMirrorTargets", params, optFns, c.addOperationDescribeTrafficMirrorTargetsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeTrafficMirrorTargetsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeTrafficMirrorTargetsInput struct {
// Checks whether you have the required permissions for the action, without
// actually making the request, and provides an error response. If you have the
// required permissions, the error response is DryRunOperation . Otherwise, it is
// UnauthorizedOperation .
DryRun *bool
// One or more filters. The possible values are:
//
// - description : The Traffic Mirror target description.
//
// - network-interface-id : The ID of the Traffic Mirror session network
// interface.
//
// - network-load-balancer-arn : The Amazon Resource Name (ARN) of the Network
// Load Balancer that is associated with the session.
//
// - owner-id : The ID of the account that owns the Traffic Mirror session.
//
// - traffic-mirror-target-id : The ID of the Traffic Mirror target.
Filters []types.Filter
// The maximum number of results to return with a single call. To retrieve the
// remaining results, make another call with the returned nextToken value.
MaxResults *int32
// The token for the next page of results.
NextToken *string
// The ID of the Traffic Mirror targets.
TrafficMirrorTargetIds []string
noSmithyDocumentSerde
}
type DescribeTrafficMirrorTargetsOutput struct {
// The token to use to retrieve the next page of results. The value is null when
// there are no more results to return.
NextToken *string
// Information about one or more Traffic Mirror targets.
TrafficMirrorTargets []types.TrafficMirrorTarget
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeTrafficMirrorTargetsMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeTrafficMirrorTargets{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeTrafficMirrorTargets{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "DescribeTrafficMirrorTargets"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = addRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addTimeOffsetBuild(stack, c); err != nil {
return err
}
if err = addUserAgentRetryMode(stack, options); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeTrafficMirrorTargets(options.Region), middleware.Before); err != nil {
return err
}
if err = addRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
// DescribeTrafficMirrorTargetsPaginatorOptions is the paginator options for
// DescribeTrafficMirrorTargets
type DescribeTrafficMirrorTargetsPaginatorOptions struct {
// The maximum number of results to return with a single call. To retrieve the
// remaining results, make another call with the returned nextToken value.
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// DescribeTrafficMirrorTargetsPaginator is a paginator for
// DescribeTrafficMirrorTargets
type DescribeTrafficMirrorTargetsPaginator struct {
options DescribeTrafficMirrorTargetsPaginatorOptions
client DescribeTrafficMirrorTargetsAPIClient
params *DescribeTrafficMirrorTargetsInput
nextToken *string
firstPage bool
}
// NewDescribeTrafficMirrorTargetsPaginator returns a new
// DescribeTrafficMirrorTargetsPaginator
func NewDescribeTrafficMirrorTargetsPaginator(client DescribeTrafficMirrorTargetsAPIClient, params *DescribeTrafficMirrorTargetsInput, optFns ...func(*DescribeTrafficMirrorTargetsPaginatorOptions)) *DescribeTrafficMirrorTargetsPaginator {
if params == nil {
params = &DescribeTrafficMirrorTargetsInput{}
}
options := DescribeTrafficMirrorTargetsPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &DescribeTrafficMirrorTargetsPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *DescribeTrafficMirrorTargetsPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next DescribeTrafficMirrorTargets page.
func (p *DescribeTrafficMirrorTargetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeTrafficMirrorTargetsOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
optFns = append([]func(*Options){
addIsPaginatorUserAgent,
}, optFns...)
result, err := p.client.DescribeTrafficMirrorTargets(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
// DescribeTrafficMirrorTargetsAPIClient is a client that implements the
// DescribeTrafficMirrorTargets operation.
type DescribeTrafficMirrorTargetsAPIClient interface {
DescribeTrafficMirrorTargets(context.Context, *DescribeTrafficMirrorTargetsInput, ...func(*Options)) (*DescribeTrafficMirrorTargetsOutput, error)
}
var _ DescribeTrafficMirrorTargetsAPIClient = (*Client)(nil)
func newServiceMetadataMiddleware_opDescribeTrafficMirrorTargets(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "DescribeTrafficMirrorTargets",
}
}
```
|
```go
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package main
import (
"context"
"errors"
"fmt"
"io"
"os"
"strings"
"github.com/pulumi/pulumi/pkg/v3/backend"
"github.com/pulumi/pulumi/pkg/v3/backend/display"
"github.com/pulumi/pulumi/sdk/v3/go/common/util/cmdutil"
"github.com/pulumi/pulumi/sdk/v3/go/common/workspace"
"github.com/spf13/cobra"
)
func newWhoAmICmd() *cobra.Command {
var whocmd whoAmICmd
cmd := &cobra.Command{
Use: "whoami",
Short: "Display the current logged-in user",
Long: "Display the current logged-in user\n" +
"\n" +
"Displays the username of the currently logged in user.",
Args: cmdutil.NoArgs,
Run: cmdutil.RunFunc(func(cmd *cobra.Command, args []string) error {
return whocmd.Run(cmd.Context())
}),
}
cmd.PersistentFlags().BoolVarP(
&whocmd.jsonOut, "json", "j", false, "Emit output as JSON")
cmd.PersistentFlags().BoolVarP(
&whocmd.verbose, "verbose", "v", false,
"Print detailed whoami information")
return cmd
}
type whoAmICmd struct {
jsonOut bool
verbose bool
Stdout io.Writer // defaults to os.Stdout
// currentBackend is a reference to the top-level currentBackend function.
// This is used to override the default implementation for testing purposes.
currentBackend func(context.Context, *workspace.Project, display.Options) (backend.Backend, error)
}
func (cmd *whoAmICmd) Run(ctx context.Context) error {
if cmd.Stdout == nil {
cmd.Stdout = os.Stdout
}
if cmd.currentBackend == nil {
cmd.currentBackend = currentBackend
}
currentBackend := cmd.currentBackend // shadow the top-level function
opts := display.Options{
Color: cmdutil.GetGlobalColorization(),
}
// Try to read the current project
project, _, err := readProject()
if err != nil && !errors.Is(err, workspace.ErrProjectNotFound) {
return err
}
b, err := currentBackend(ctx, project, opts)
if err != nil {
return err
}
name, orgs, tokenInfo, err := b.CurrentUser()
if err != nil {
return err
}
if cmd.jsonOut {
return fprintJSON(cmd.Stdout, WhoAmIJSON{
User: name,
Organizations: orgs,
URL: b.URL(),
TokenInformation: tokenInfo,
})
}
if cmd.verbose {
fmt.Fprintf(cmd.Stdout, "User: %s\n", name)
fmt.Fprintf(cmd.Stdout, "Organizations: %s\n", strings.Join(orgs, ", "))
fmt.Fprintf(cmd.Stdout, "Backend URL: %s\n", b.URL())
if tokenInfo != nil {
tokenType := "unknown"
if tokenInfo.Team != "" {
tokenType = "team: " + tokenInfo.Team
} else if tokenInfo.Organization != "" {
tokenType = "organization: " + tokenInfo.Organization
}
fmt.Fprintf(cmd.Stdout, "Token type: %s\n", tokenType)
fmt.Fprintf(cmd.Stdout, "Token name: %s\n", tokenInfo.Name)
} else {
fmt.Fprintf(cmd.Stdout, "Token type: personal\n")
}
} else {
fmt.Fprintf(cmd.Stdout, "%s\n", name)
}
return nil
}
// WhoAmIJSON is the shape of the --json output of this command.
type WhoAmIJSON struct {
User string `json:"user"`
Organizations []string `json:"organizations,omitempty"`
URL string `json:"url"`
TokenInformation *workspace.TokenInformation `json:"tokenInformation,omitempty"`
}
```
|
```yaml
cloud_id: {{env["ANYSCALE_CLOUD_ID"]}}
region: us-west-2
max_workers: 3
head_node_type:
name: head_node
instance_type: m5.xlarge
worker_node_types:
- name: worker_node
instance_type: g3s.xlarge
min_workers: 2
max_workers: 2
use_spot: false
aws:
BlockDeviceMappings:
- DeviceName: /dev/sda1
Ebs:
DeleteOnTermination: true
VolumeSize: 150
```
|
```python
#
#
# 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.
import unittest
from functools import partial
import hypothesis.strategies as st
import numpy as np
from auto_scan_test import PassAutoScanTest
from program_config import ProgramConfig, TensorConfig
class TestConvHardSigmoidMkldnnFusePass(PassAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True
def sample_program_config(self, draw):
data_format = draw(st.sampled_from(["NCHW", "NHWC"]))
dilations = draw(st.sampled_from([[1, 1], [2, 2], [1, 2]]))
padding_algorithm = draw(st.sampled_from(["EXPLICIT", "SAME", "VALID"]))
groups = draw(st.sampled_from([1, 2, 4]))
paddings = draw(st.sampled_from([[0, 3], [1, 2, 3, 4]]))
strides = draw(st.sampled_from([[1, 1], [2, 2], [1, 2]]))
slope = draw(st.floats(min_value=0, max_value=10))
offset = draw(st.floats(min_value=0, max_value=10))
batch_size = draw(st.integers(min_value=1, max_value=4))
def generate_input():
if data_format == "NCHW":
return np.random.random([batch_size, 48, 64, 64]).astype(
np.float32
)
else:
return np.random.random([batch_size, 64, 64, 48]).astype(
np.float32
)
def generate_weight():
return np.random.random([16, int(48 / groups), 3, 3]).astype(
np.float32
)
ops_config = [
{
"op_type": "conv2d",
"op_inputs": {
"Input": ["input_data"],
"Filter": ["input_weight"],
},
"op_outputs": {"Output": ["conv_output"]},
"op_attrs": {
"data_format": data_format,
"dilations": dilations,
"padding_algorithm": padding_algorithm,
"groups": groups,
"paddings": paddings,
"strides": strides,
},
},
{
"op_type": "hard_sigmoid",
"op_inputs": {"X": ["conv_output"]},
"op_outputs": {"Out": ["sigmoid_output"]},
"op_attrs": {"slope": slope, "offset": offset},
},
]
ops = self.generate_op_config(ops_config)
program_config = ProgramConfig(
ops=ops,
weights={
"input_weight": TensorConfig(data_gen=partial(generate_weight))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
},
outputs=["sigmoid_output"],
)
return program_config
def sample_predictor_configs(self, program_config):
config = self.create_inference_config(use_mkldnn=True)
yield config, ["fused_conv2d"], (1e-5, 1e-5)
def test(self):
self.run_and_statis(
quant=False, passes=["conv_activation_onednn_fuse_pass"]
)
if __name__ == "__main__":
unittest.main()
```
|
Pudding Creek is a long 2nd order tributary to the Banister River in Pittsylvania County, Virginia.
Course
Pudding Creek rises in a pond about 2 miles east-southeast of Woods Store, Virginia and then flows northeast to join the Banister River about 0.5 miles northeast of Jones Mill.
Watershed
Pudding Creek drains of area, receives about 45.9 in/year of precipitation, has a wetness index of 439.65, and is about 37% forested.
See also
List of Virginia Rivers
References
Rivers of Virginia
Rivers of Pittsylvania County, Virginia
Tributaries of the Roanoke River
|
Sir Robert Thorpe KS JP (died 29 June 1372) was a British justice. He was the son of another Sir Robert Thorpe, and is occasionally confused with another Robert Thorpe who was second master of Pembroke College, Cambridge at around the same time. The Thorpe family produced many prominent lawyers, including William de Thorpe, Chief Justice of the King's Bench, who may have been influential in guiding Robert towards a judicial career. In 1339 he was made a Serjeant-at-law, and between 1345 and 1356 served as a King's Serjeant. He served as a Justice of the Peace in Cambridgeshire, Huntingdonshire, Norfolk, Suffolk, Bedfordshire and Buckinghamshire, and was also involved in Assize, Gaol delivery and Oyer and terminer. On 27 June 1356 he was appointed as Chief Justice of the Common Pleas and knighted, and on 1 October he was awarded a grant of £40 to support his new position (£33,784 in 2023). He was a member of the councils of both the Black Prince and John of Gaunt, and was appointed a Trier of Petitions at every Parliament between 1362 and 1371.
In 1368 he took part in the trial of the Steward of the King's Household, Sir John de la Lee, and in 1371 he was part of a commission inquiring into the embezzlement of money by Sir William Latimer. An anti-clerical movement in 1371 forced the King to dismiss the Lord Chancellor, treasurer, and keeper of the privy seal and replace them with laymen; as a result, Thorpe was appointed as Chancellor to replace William of Wykeham, a position he took up on 14 April. He held the position for only a year until his death on 29 June 1372.
References
John Campbell, Baron Campbell, Lives of The Lord Chancellors and Keepers of the Great Seal of England, pp. 229–232
1372 deaths
Chief Justices of the Common Pleas
Knights Bachelor
Serjeants-at-law (England)
Lord chancellors of England
14th-century English judges
Year of birth unknown
English justices of the peace
|
```sqlpl
-- MySQL dump 10.17 Distrib 10.3.12-MariaDB, for Linux (x86_64)
--
-- Host: localhost Database: schema-generator@todo
-- ------------------------------------------------------
-- Server version 5.7.23
--
-- Table structure for table `Todo`
--
DROP TABLE IF EXISTS `Todo`;
CREATE TABLE `Todo` (
`id` char(25) CHARACTER SET utf8 NOT NULL,
`text` mediumtext COLLATE utf8mb4_unicode_ci NOT NULL,
`done` tinyint(1) NOT NULL,
`updatedAt` datetime(3) NOT NULL,
`createdAt` datetime(3) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
--
-- Table structure for table `User`
--
DROP TABLE IF EXISTS `User`;
CREATE TABLE `User` (
`id` char(25) CHARACTER SET utf8 NOT NULL,
`name` mediumtext COLLATE utf8mb4_unicode_ci NOT NULL,
`updatedAt` datetime(3) NOT NULL,
`createdAt` datetime(3) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
--
-- Table structure for table `_RelayId`
--
DROP TABLE IF EXISTS `_RelayId`;
CREATE TABLE `_RelayId` (
`id` char(25) CHARACTER SET utf8 NOT NULL,
`stableModelIdentifier` char(25) CHARACTER SET utf8 NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `id_UNIQUE` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
--
-- Table structure for table `_TodoToUser`
--
DROP TABLE IF EXISTS `_TodoToUser`;
CREATE TABLE `_TodoToUser` (
`A` char(25) CHARACTER SET utf8 NOT NULL,
`B` char(25) CHARACTER SET utf8 NOT NULL,
UNIQUE KEY `AB_unique` (`A`,`B`),
KEY `A` (`A`),
KEY `B` (`B`),
CONSTRAINT `_TodoToUser_ibfk_1` FOREIGN KEY (`A`) REFERENCES `Todo` (`id`) ON DELETE CASCADE,
CONSTRAINT `_TodoToUser_ibfk_2` FOREIGN KEY (`B`) REFERENCES `User` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- Dump completed on 2019-04-29 12:50:23
```
|
```php
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarDumper\Tests;
use Symfony\Component\VarDumper\Cloner\VarCloner;
use Symfony\Component\VarDumper\Dumper\HtmlDumper;
/**
* @author Nicolas Grekas <p@tchwork.com>
*/
class HtmlDumperTest extends \PHPUnit_Framework_TestCase
{
public function testGet()
{
require __DIR__.'/Fixtures/dumb-var.php';
$dumper = new HtmlDumper('php://output');
$dumper->setDumpHeader('<foo></foo>');
$dumper->setDumpBoundaries('<bar>', '</bar>');
$cloner = new VarCloner();
$cloner->addCasters(array(
':stream' => function ($res, $a) {
unset($a['uri'], $a['wrapper_data']);
return $a;
},
));
$data = $cloner->cloneVar($var);
ob_start();
$dumper->dump($data);
$out = ob_get_clean();
$out = preg_replace('/[ \t]+$/m', '', $out);
$var['file'] = htmlspecialchars($var['file'], ENT_QUOTES, 'UTF-8');
$intMax = PHP_INT_MAX;
preg_match('/sf-dump-\d+/', $out, $dumpId);
$dumpId = $dumpId[0];
$res = (int) $var['res'];
$closure54 = '';
$r = defined('HHVM_VERSION') ? '' : '<a class=sf-dump-ref>#%d</a>';
if (PHP_VERSION_ID >= 50400) {
$closure54 = <<<EOTXT
<span class=sf-dump-meta>class</span>: "<span class=sf-dump-str title="48 characters">Symfony\Component\VarDumper\Tests\HtmlDumperTest</span>"
<span class=sf-dump-meta>this</span>: <abbr title="Symfony\Component\VarDumper\Tests\HtmlDumperTest" class=sf-dump-note>HtmlDumperTest</abbr> {{$r} …}
EOTXT;
}
$this->assertStringMatchesFormat(
<<<EOTXT
<foo></foo><bar><span class=sf-dump-note>array:24</span> [<samp>
"<span class=sf-dump-key>number</span>" => <span class=sf-dump-num>1</span>
<span class=sf-dump-key>0</span> => <a class=sf-dump-ref href=#{$dumpId}-ref01 title="2 occurrences">&1</a> <span class=sf-dump-const>null</span>
"<span class=sf-dump-key>const</span>" => <span class=sf-dump-num>1.1</span>
<span class=sf-dump-key>1</span> => <span class=sf-dump-const>true</span>
<span class=sf-dump-key>2</span> => <span class=sf-dump-const>false</span>
<span class=sf-dump-key>3</span> => <span class=sf-dump-num>NAN</span>
<span class=sf-dump-key>4</span> => <span class=sf-dump-num>INF</span>
<span class=sf-dump-key>5</span> => <span class=sf-dump-num>-INF</span>
<span class=sf-dump-key>6</span> => <span class=sf-dump-num>{$intMax}</span>
"<span class=sf-dump-key>str</span>" => "<span class=sf-dump-str title="5 characters">déjà</span>\\n"
<span class=sf-dump-key>7</span> => b"<span class=sf-dump-str title="2 binary or non-UTF-8 characters">é</span>\\x00"
"<span class=sf-dump-key>[]</span>" => []
"<span class=sf-dump-key>res</span>" => <span class=sf-dump-note>stream resource</span> <a class=sf-dump-ref>@{$res}</a><samp>
<span class=sf-dump-meta>wrapper_type</span>: "<span class=sf-dump-str title="9 characters">plainfile</span>"
<span class=sf-dump-meta>stream_type</span>: "<span class=sf-dump-str title="5 characters">STDIO</span>"
<span class=sf-dump-meta>mode</span>: "<span class=sf-dump-str>r</span>"
<span class=sf-dump-meta>unread_bytes</span>: <span class=sf-dump-num>0</span>
<span class=sf-dump-meta>seekable</span>: <span class=sf-dump-const>true</span>
<span class=sf-dump-meta>timed_out</span>: <span class=sf-dump-const>false</span>
<span class=sf-dump-meta>blocked</span>: <span class=sf-dump-const>true</span>
<span class=sf-dump-meta>eof</span>: <span class=sf-dump-const>false</span>
<span class=sf-dump-meta>options</span>: []
</samp>}
"<span class=sf-dump-key>obj</span>" => <abbr title="Symfony\Component\VarDumper\Tests\Fixture\DumbFoo" class=sf-dump-note>DumbFoo</abbr> {<a class=sf-dump-ref href=#{$dumpId}-ref2%d title="2 occurrences">#%d</a><samp id={$dumpId}-ref2%d>
+<span class=sf-dump-public title="Public property">foo</span>: "<span class=sf-dump-str title="3 characters">foo</span>"
+"<span class=sf-dump-public title="Runtime added dynamic property">bar</span>": "<span class=sf-dump-str title="3 characters">bar</span>"
</samp>}
"<span class=sf-dump-key>closure</span>" => <span class=sf-dump-note>Closure</span> {{$r}<samp>{$closure54}
<span class=sf-dump-meta>parameters</span>: <span class=sf-dump-note>array:2</span> [<samp>
"<span class=sf-dump-key>\$a</span>" => []
"<span class=sf-dump-key>&\$b</span>" => <span class=sf-dump-note>array:2</span> [<samp>
"<span class=sf-dump-key>typeHint</span>" => "<span class=sf-dump-str title="3 characters">PDO</span>"
"<span class=sf-dump-key>default</span>" => <span class=sf-dump-const>null</span>
</samp>]
</samp>]
<span class=sf-dump-meta>file</span>: "<span class=sf-dump-str title="%d characters">{$var['file']}</span>"
<span class=sf-dump-meta>line</span>: "<span class=sf-dump-str title="%d characters">{$var['line']} to {$var['line']}</span>"
</samp>}
"<span class=sf-dump-key>line</span>" => <span class=sf-dump-num>{$var['line']}</span>
"<span class=sf-dump-key>nobj</span>" => <span class=sf-dump-note>array:1</span> [<samp>
<span class=sf-dump-index>0</span> => <a class=sf-dump-ref href=#{$dumpId}-ref03 title="2 occurrences">&3</a> {<a class=sf-dump-ref href=#{$dumpId}-ref2%d title="3 occurrences">#%d</a>}
</samp>]
"<span class=sf-dump-key>recurs</span>" => <a class=sf-dump-ref href=#{$dumpId}-ref04 title="2 occurrences">&4</a> <span class=sf-dump-note>array:1</span> [<samp id={$dumpId}-ref04>
<span class=sf-dump-index>0</span> => <a class=sf-dump-ref href=#{$dumpId}-ref04 title="2 occurrences">&4</a> <span class=sf-dump-note>array:1</span> [<a class=sf-dump-ref href=#{$dumpId}-ref04 title="2 occurrences">&4</a>]
</samp>]
<span class=sf-dump-key>8</span> => <a class=sf-dump-ref href=#{$dumpId}-ref01 title="2 occurrences">&1</a> <span class=sf-dump-const>null</span>
"<span class=sf-dump-key>sobj</span>" => <abbr title="Symfony\Component\VarDumper\Tests\Fixture\DumbFoo" class=sf-dump-note>DumbFoo</abbr> {<a class=sf-dump-ref href=#{$dumpId}-ref2%d title="2 occurrences">#%d</a>}
"<span class=sf-dump-key>snobj</span>" => <a class=sf-dump-ref href=#{$dumpId}-ref03 title="2 occurrences">&3</a> {<a class=sf-dump-ref href=#{$dumpId}-ref2%d title="3 occurrences">#%d</a>}
"<span class=sf-dump-key>snobj2</span>" => {<a class=sf-dump-ref href=#{$dumpId}-ref2%d title="3 occurrences">#%d</a>}
"<span class=sf-dump-key>file</span>" => "<span class=sf-dump-str title="%d characters">{$var['file']}</span>"
b"<span class=sf-dump-key>bin-key-é</span>" => ""
</samp>]
</bar>
EOTXT
,
$out
);
}
/**
* @requires extension mbstring
*/
public function testCharset()
{
$var = mb_convert_encoding('', 'CP1251', 'UTF-8');
$dumper = new HtmlDumper('php://output', 'CP1251');
$dumper->setDumpHeader('<foo></foo>');
$dumper->setDumpBoundaries('<bar>', '</bar>');
$cloner = new VarCloner();
$data = $cloner->cloneVar($var);
$out = fopen('php://memory', 'r+b');
$dumper->dump($data, $out);
rewind($out);
$out = stream_get_contents($out);
$this->assertStringMatchesFormat(
<<<EOTXT
<foo></foo><bar>b"<span class=sf-dump-str title="7 binary or non-UTF-8 characters">Словарь</span>"
</bar>
EOTXT
,
$out
);
}
}
```
|
The Philippine fairy-bluebird (Irena cyanogastra) is a species of bird in the family Irenidae. It is endemic to the Philippines being found in the islands of Luzon, Mindanao, Samar and Bohol.
Its natural habitats are tropical moist lowland forest and tropical moist montane forest. They are seen in mixed flocks along with Philippine bulbuls, Blue-headed fantails and other forest birds. It is threatened by habitat loss and hunting for both food and pet trade.
Mythology
This species is considered as sacred to the Tagalog people as it is perceived as the tigmamanukan omen. It is believed to be a messenger of Bathala, the supreme creator god of precolonial, indigenous Tagalog religion.
In old Tagalog mythology in southern Luzon, the Philippine fairy-bluebirds were known as the tigmamanukan omen birds. According to legend, Bathala ordered a tigmamanukan bird to crack in open a bamboo stalk from which came Malakas and Maganda, the first humans.
In another legend, Bathala also sends the tigmamanukan bird (sometimes in the forms of a snake or lizard) to aid humans if they need to proceed or stop a journey. If a traveler sees a tigmamanukan omen passing from right to left, it is “labay” or divine approval to proceed with the journey. If the tigmamanukan omen passes from left to right, the traveller should not proceed, or else he or she will never return. All tigmamanukan omen birds are said to live on the mythical Mount Batala sacred to the god.
See also
Asian fairy-bluebird
References
External links
Image at ADW
Philippine fairy-bluebird
Endemic birds of the Philippines
Philippine fairy-bluebird
Taxonomy articles created by Polbot
|
```scala
/*
*/
package akka.stream.alpakka.mqtt.scaladsl
import akka.Done
import akka.stream.alpakka.mqtt._
import akka.stream.alpakka.mqtt.impl.{MqttFlowStage, MqttFlowStageWithAck}
import akka.stream.scaladsl.{Flow, Keep}
import scala.concurrent.Future
/**
* Scala API
*
* MQTT flow factory.
*/
object MqttFlow {
/**
* Create a flow to send messages to MQTT AND subscribe to MQTT messages (without a commit handle).
*
* The materialized value completes on successful connection to the MQTT broker.
*
* @param bufferSize max number of messages read from MQTT before back-pressure applies
* @param defaultQos Quality of service level applied for messages not specifying a message specific value
*/
def atMostOnce(connectionSettings: MqttConnectionSettings,
subscriptions: MqttSubscriptions,
bufferSize: Int,
defaultQos: MqttQoS): Flow[MqttMessage, MqttMessage, Future[Done]] =
Flow
.fromGraph(
new MqttFlowStage(connectionSettings, subscriptions.subscriptions, bufferSize, defaultQos)
)
.map(_.message)
/**
* Create a flow to send messages to MQTT AND subscribe to MQTT messages with a commit handle to acknowledge message reception.
*
* The materialized value completes on successful connection to the MQTT broker.
*
* @param bufferSize max number of messages read from MQTT before back-pressure applies
* @param defaultQos Quality of service level applied for messages not specifying a message specific value
*/
def atLeastOnce(connectionSettings: MqttConnectionSettings,
subscriptions: MqttSubscriptions,
bufferSize: Int,
defaultQos: MqttQoS): Flow[MqttMessage, MqttMessageWithAck, Future[Done]] =
Flow.fromGraph(
new MqttFlowStage(connectionSettings, subscriptions.subscriptions, bufferSize, defaultQos, manualAcks = true)
)
/**
* Create a flow to send messages to MQTT AND subscribe to MQTT messages with a commit handle to acknowledge message reception.
* The acknowledge are fired in both messages
* The materialized value completes on successful connection to the MQTT broker.
*
* @param bufferSize max number of messages read from MQTT before back-pressure applies
* @param defaultQos Quality of service level applied for messages not specifying a message specific value
*/
def atLeastOnceWithAck(connectionSettings: MqttConnectionSettings,
subscriptions: MqttSubscriptions,
bufferSize: Int,
defaultQos: MqttQoS): Flow[MqttMessageWithAck, MqttMessageWithAck, Future[Done]] =
Flow.fromGraph(
new MqttFlowStageWithAck(connectionSettings,
subscriptions.subscriptions,
bufferSize,
defaultQos,
manualAcks = true)
)
def atLeastOnceWithAckForJava(
connectionSettings: MqttConnectionSettings,
subscriptions: MqttSubscriptions,
bufferSize: Int,
defaultQos: MqttQoS
): Flow[javadsl.MqttMessageWithAck, MqttMessageWithAck, Future[Done]] =
Flow
.fromFunction(MqttMessageWithAck.fromJava)
.viaMat(atLeastOnceWithAck(connectionSettings, subscriptions, bufferSize, defaultQos))(Keep.right)
}
```
|
```smalltalk
Extension { #name : 'ClyBrowserMorph' }
{ #category : '*Calypso-SystemTools-Core' }
ClyBrowserMorph >> allowSilentlyRemoveMethods: methods whichHaveSenders: senders [
| singleSender sendersCount |
sendersCount := senders size.
sendersCount = 0 ifTrue: [ ^true].
methods size = 1 & (sendersCount = 1) ifFalse: [^false].
singleSender := senders itemAt: 1.
^singleSender == methods first
]
{ #category : '*Calypso-SystemTools-Core' }
ClyBrowserMorph >> confirmEmptySystemQuery: aQuery [
| showResult result |
result := aQuery execute.
result isEmpty ifTrue: [ ^true ].
showResult := self morphicUIManager confirm: 'There are '
, result size asString, ' ', aQuery description, '. Show them?'.
showResult ifTrue: [self spawnQueryBrowserOn: aQuery].
^false
]
{ #category : '*Calypso-SystemTools-Core' }
ClyBrowserMorph >> confirmUnusedVariablesInDefiningClass: variables [
| refQuery classScope |
classScope := ClyBothMetaLevelClassScope ofAll: (variables collect: [:each | each definingClass]) in: navigationEnvironment.
refQuery := ClyVariableReferencesQuery ofAny: variables from: classScope.
^self confirmEmptySystemQuery: refQuery
]
{ #category : '*Calypso-SystemTools-Core' }
ClyBrowserMorph >> decorateMethodEditor: aMethodEditor [
]
{ #category : '*Calypso-SystemTools-Core' }
ClyBrowserMorph >> isMethodSelected: aMethod [
^self methodSelection includesActualObject: aMethod
]
```
|
Wild Horse Pass Motorsports Park is a 450-acre (180 ha) motorsport racing complex, located in Chandler, Arizona, United States, about southeast of downtown Phoenix.
History
The facility opened as Firebird International Raceway in 1983.
In 1985, Firebird hosted the NHRA Fallnationals, the first National NHRA event held at the complex. Gene Snow would win the Top Fuel championship while Bob Glidden clinched the 1985 NHRA world championship.
On May 17, 1987, it held its only IMSA GT race, the Arizona 300.
In December 1992, Three-time Formula One Champion Ayrton Senna tested an IndyCar on the East Course with Team Penske. Senna was intrigued, but eventually decided to stay in Formula One.
In March 2013, it was announced that the land owner, the Gila River Indian Community and the operator of Firebird International Raceway, Charlie Allen could not reach an agreement on a lease extension and that the complex would close in April. The complex would stay closed throughout March until the Gila River Indian Community announced that they signed a lease agreement with a new operator in June, the complex would change names from Firebird International Raceway to Wild Horse Pass Motorsports Park, named after the neighboring tribal casino and resort Wild Horse Pass while also receiving an investment of more than $1 million in renovations, including repaving the drag-strip.
On Feb 22, 2014, Wild Horse Pass Motorsports Park would reopen and host its first event since closing, the NHRA Arizona National.
In March 2022, it was announced that Wild Horse Pass Motorsports Park would close in February 2023, after NHRA Arizona Nationals, due to the widening of Interstate 10. Radford Racing School and the Radford Racing course will remain open after Wild Horse Pass Motorsports Park closes.
Circuits
References
External links
World Sports Racing Prototypes - 1987 IMSA GT Championship results
NHRA Division 7 drag racing venues
Motorsport venues in Arizona
Buildings and structures in Chandler, Arizona
Transportation in Chandler, Arizona
IMSA GT Championship circuits
Sports venues in Maricopa County, Arizona
Off-road racing venues in the United States
1983 establishments in Arizona
Sports venues completed in 1983
|
The Sony Xperia 1 V is an Android smartphone manufactured by Sony. Launched on May 11, 2023, it succeeds the Xperia 1 IV as the latest flagship of Sony's Xperia series. The device was announced along with the mid-range Xperia 10 V, with expected release dates by June 2023 for Japan and European markets and July 2023 for the US.
See also
List of longest smartphone telephoto lenses
References
Notes
Android (operating system) devices
Flagship smartphones
Sony smartphones
Mobile phones introduced in 2023
Mobile phones with multiple rear cameras
Mobile phones with 4K video recording
|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing,
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* specific language governing permissions and limitations
*/
/**
* Pulsar broker interceptor.
*/
package org.apache.pulsar.broker.intercept;
```
|
Kwame Addo-Kufuor (born 14 July 1940) is a Ghanaian politician and physician. Addo-Kufuor was a member of parliament for Manhyia, and from 2001 to 2007, he was the Minister for Defence under President John Kufuor, his brother. Between June 2008 and 2009, he was the Minister for Interior.
Early life and education
Addo-Kufuor was born on 14 July 1940. He graduated from the University of Cambridge. He holds a bachelor's degree in medicine from the university. He also studied at the Middlesex Medical School Hospital and Jesus College.
Career
Addo-Kufuor is a medical doctor by profession.
Political career
Addo-Kufuor is a member of the New Patriotic Party. He became a member of parliament in January 1997 after emerging as a winner in the General Election in December 1996. He was elected once more as the member of parliament for the Manhyia constituency in the fourth parliament of the fourth Republic of Ghana.
Elections
1997 Parliamentary Elections
Addo was first elected into Parliament during the December 1996 Ghanaian General Elections for the Manhyia Constituency in the Ashanti Region of Ghana. He polled 59,227 votes out of the 72,789 valid votes cast representing 63.30% against Yaw Addai Boadu an NDC member who polled 13,562 representing 14.50%. He was re-elected with 64,067 votes out of the 78,368 valid votes cast representing 81.80% against Samuel B.Donkoh an NDC member who polled 12,244 votes representing 15.60%, Salifu Mumuni and PNC member who polled 1,614 votes representing 2.10% and Nana O. Boateng who polled 443 votes representing 0.60%.
2004 Parliamentary Elections
Addo-Kufuor was elected as the member of parliament for the Bekwai constituency of the Ashanti Region of Ghana in the 2004 Ghanaian general elections. He won on the ticket of the New Patriotic Party. His constituency was a part of the 36 parliamentary seats out of 39 seats won by the New Patriotic Party in that election for the Ashanti Region. The New Patriotic Party won a total of 128 parliamentary seats out of 230 seats. He was elected with 66,210 votes out of 87,629 total valid votes cast. This was equivalent to 75.6% of total valid votes cast. He was elected over Salifu Mumuni of the People's National Convention, Kwame Boateng of the National Democratic Congress, E. A. Ohene Darko of the Convention People's Party, and Kofi Pervical Akpaloo an independent candidate. These obtained 667, 9,550, 498 and 10,704 votes respectively of total votes cast.4,6 These were equivalent to 0.8%, 10.9%, 0.6% and 12.2% respectively of total valid votes cast.
Personal life
Addo-Kufuor is a Christian.
Bibliography
Kwame Addo-Kufuor: Gold Coast Boy (A Memoir). Digibooks Ghana Ltd, 2015, .
References
External links
1940 births
Living people
People from Kumasi
Politicians from Ashanti Region
New Patriotic Party politicians
Defence ministers of Ghana
Interior ministers of Ghana
Ghanaian medical doctors
Ghanaian MPs 1997–2001
Ghanaian MPs 2001–2005
Ghanaian MPs 2005–2009
Alumni of Achimota School
Alumni of Jesus College, Cambridge
Alumni of Middlesex University
Ghanaian expatriates in the United Kingdom
People from Ashanti Region
|
```objective-c
/**
* Authors:
* - Christian Parpart <trapni@dawanda.com>
*
* This program is free software: you can redistribute it and/or modify it under
* or any later version.
*
* In accordance with Section 7(e) of the license, the licensing of the Program
* under the license does not imply a trademark license. Therefore any rights,
* title and interest in our trademarks remain entirely with us.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the license for more details.
*
* You can be released from the requirements of the license by purchasing a
* commercial license. Buying such a license is mandatory as soon as you develop
* commercial activities involving this program without disclosing the source
* code of your own applications
*/
#ifndef sw_x0_TimeRange_h
#define sw_x0_TimeRange_h
#include <eventql/util/UnixTime.h>
#include <eventql/util/duration.h>
#include <cstdio>
/**
* @brief High resolution time span.
*
* A timespan is a tuple of a fixed begin and a duration.
*/
class TimeRange {
public:
constexpr TimeRange(UnixTime start, Duration duration);
constexpr TimeRange(UnixTime start, UnixTime end);
constexpr TimeRange(const TimeRange& other);
constexpr TimeRange();
constexpr UnixTime start() const;
constexpr Duration duration() const;
constexpr UnixTime end() const;
constexpr TimeRange backward(Duration by) const;
constexpr TimeRange forward(Duration by) const;
constexpr bool operator==(const TimeRange& other) const;
constexpr bool operator!=(const TimeRange& other) const;
private:
const UnixTime start_;
const Duration duration_;
};
#include <eventql/util/TimeRange_impl.h>
#endif
```
|
```c
/*
* VARCem Virtual ARchaeological Computer EMulator.
* An emulator of (mostly) x86-based PC systems and devices,
* using the ISA,EISA,VLB,MCA and PCI system buses, roughly
* spanning the era between 1981 and 1995.
*
* Handle WinPcap library processing.
*
*
*
* Authors: Fred N. van Kempen, <decwiz@yahoo.com>
*
*
* 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 entire
* above 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.
*/
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <wchar.h>
#include <stdbool.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <winsock2.h>
#else
# include <poll.h>
# include <unistd.h>
# include <fcntl.h>
# include <sys/select.h>
#endif
#define HAVE_STDARG_H
#include <86box/86box.h>
#include <86box/device.h>
#include <86box/plat.h>
#include <86box/plat_dynld.h>
#include <86box/thread.h>
#include <86box/timer.h>
#include <86box/network.h>
#include <86box/net_event.h>
#define PCAP_PKT_BATCH NET_QUEUE_LEN
enum {
NET_EVENT_STOP = 0,
NET_EVENT_TX,
NET_EVENT_RX,
NET_EVENT_MAX
};
#ifdef __APPLE__
# include <pcap/pcap.h>
#else
typedef int bpf_int32;
typedef unsigned int bpf_u_int32;
/*
* The instruction data structure.
*/
struct bpf_insn {
unsigned short code;
unsigned char jt;
unsigned char jf;
bpf_u_int32 k;
};
/*
* Structure for "pcap_compile()", "pcap_setfilter()", etc..
*/
struct bpf_program {
unsigned int bf_len;
struct bpf_insn *bf_insns;
};
typedef struct pcap_if pcap_if_t;
# define PCAP_ERRBUF_SIZE 256
struct pcap_pkthdr {
struct timeval ts;
bpf_u_int32 caplen;
bpf_u_int32 len;
};
struct pcap_if {
struct pcap_if *next;
char *name;
char *description;
void *addresses;
bpf_u_int32 flags;
};
struct pcap_send_queue {
unsigned int maxlen; /* Maximum size of the queue, in bytes. This
variable contains the size of the buffer field. */
unsigned int len; /* Current size of the queue, in bytes. */
char *buffer; /* Buffer containing the packets to be sent. */
};
typedef struct pcap_send_queue pcap_send_queue;
typedef void (*pcap_handler)(unsigned char *user, const struct pcap_pkthdr *h, const unsigned char *bytes);
#endif
typedef struct {
void *pcap; /* handle to pcap lib instance */
netcard_t *card; /* netcard linked to us */
thread_t *poll_tid;
net_evt_t tx_event;
net_evt_t stop_event;
netpkt_t pkt;
netpkt_t pktv[PCAP_PKT_BATCH];
uint8_t mac_addr[6];
#ifdef _WIN32
struct pcap_send_queue *pcap_queue;
#endif
} net_pcap_t;
typedef struct {
char *intf_name;
uint8_t *mac_addr;
} net_pcap_params_t;
static volatile void *libpcap_handle; /* handle to WinPcap DLL */
/* Pointers to the real functions. */
static const char *(*f_pcap_lib_version)(void);
static int (*f_pcap_findalldevs)(pcap_if_t **, char *);
static void (*f_pcap_freealldevs)(void *);
static void *(*f_pcap_open_live)(const char *, int, int, int, char *);
static int (*f_pcap_compile)(void *, void *, const char *, int, bpf_u_int32);
static int (*f_pcap_setfilter)(void *, void *);
static const unsigned char
*(*f_pcap_next)(void *, void *);
static int (*f_pcap_sendpacket)(void *, const unsigned char *, int);
static void (*f_pcap_close)(void *);
static int (*f_pcap_setnonblock)(void *, int, char *);
static int (*f_pcap_set_immediate_mode)(void *, int);
static int (*f_pcap_set_promisc)(void *, int);
static int (*f_pcap_set_snaplen)(void *, int);
static int (*f_pcap_dispatch)(void *, int, pcap_handler callback, unsigned char *user);
static void *(*f_pcap_create)(const char *, char *);
static int (*f_pcap_activate)(void *);
static void *(*f_pcap_geterr)(void *);
#ifdef _WIN32
static HANDLE (*f_pcap_getevent)(void *);
static int (*f_pcap_sendqueue_queue)(void *, void *, void *);
static unsigned int (*f_pcap_sendqueue_transmit)(void *, void *, int sync);
static void *(*f_pcap_sendqueue_alloc)(unsigned int memsize);
static void (*f_pcap_sendqueue_destroy)(void *);
#else
static int (*f_pcap_get_selectable_fd)(void *);
#endif
static dllimp_t pcap_imports[] = {
{"pcap_lib_version", &f_pcap_lib_version },
{ "pcap_findalldevs", &f_pcap_findalldevs },
{ "pcap_freealldevs", &f_pcap_freealldevs },
{ "pcap_open_live", &f_pcap_open_live },
{ "pcap_compile", &f_pcap_compile },
{ "pcap_setfilter", &f_pcap_setfilter },
{ "pcap_next", &f_pcap_next },
{ "pcap_sendpacket", &f_pcap_sendpacket },
{ "pcap_close", &f_pcap_close },
{ "pcap_setnonblock", &f_pcap_setnonblock },
{ "pcap_set_immediate_mode", &f_pcap_set_immediate_mode},
{ "pcap_set_promisc", &f_pcap_set_promisc },
{ "pcap_set_snaplen", &f_pcap_set_snaplen },
{ "pcap_dispatch", &f_pcap_dispatch },
{ "pcap_create", &f_pcap_create },
{ "pcap_activate", &f_pcap_activate },
{ "pcap_geterr", &f_pcap_geterr },
#ifdef _WIN32
{ "pcap_getevent", &f_pcap_getevent },
{ "pcap_sendqueue_queue", &f_pcap_sendqueue_queue },
{ "pcap_sendqueue_transmit", &f_pcap_sendqueue_transmit},
{ "pcap_sendqueue_alloc", &f_pcap_sendqueue_alloc },
{ "pcap_sendqueue_destroy", &f_pcap_sendqueue_destroy },
#else
{ "pcap_get_selectable_fd", &f_pcap_get_selectable_fd },
#endif
{ NULL, NULL },
};
#ifdef ENABLE_PCAP_LOG
int pcap_do_log = ENABLE_PCAP_LOG;
static void
pcap_log(const char *fmt, ...)
{
va_list ap;
if (pcap_do_log) {
va_start(ap, fmt);
pclog_ex(fmt, ap);
va_end(ap);
}
}
#else
# define pcap_log(fmt, ...)
#endif
static void
net_pcap_rx_handler(uint8_t *user, const struct pcap_pkthdr *h, const uint8_t *bytes)
{
net_pcap_t *pcap = (net_pcap_t *) user;
memcpy(pcap->pkt.data, bytes, h->caplen);
pcap->pkt.len = h->caplen;
network_rx_put_pkt(pcap->card, &pcap->pkt);
}
/* Send a packet to the Pcap interface. */
void
net_pcap_in(void *pcap, uint8_t *bufp, int len)
{
if (pcap == NULL)
return;
f_pcap_sendpacket(pcap, bufp, len);
}
void
net_pcap_in_available(void *priv)
{
net_pcap_t *pcap = (net_pcap_t *) priv;
net_event_set(&pcap->tx_event);
}
#ifdef _WIN32
static void
net_pcap_thread(void *priv)
{
net_pcap_t *pcap = (net_pcap_t *) priv;
pcap_log("PCAP: polling started.\n");
HANDLE events[NET_EVENT_MAX];
events[NET_EVENT_STOP] = net_event_get_handle(&pcap->stop_event);
events[NET_EVENT_TX] = net_event_get_handle(&pcap->tx_event);
events[NET_EVENT_RX] = f_pcap_getevent(pcap->pcap);
bool run = true;
struct pcap_pkthdr h;
while (run) {
int ret = WaitForMultipleObjects(NET_EVENT_MAX, events, FALSE, INFINITE);
switch (ret - WAIT_OBJECT_0) {
case NET_EVENT_STOP:
net_event_clear(&pcap->stop_event);
run = false;
break;
case NET_EVENT_TX:
net_event_clear(&pcap->tx_event);
int packets = network_tx_popv(pcap->card, pcap->pktv, PCAP_PKT_BATCH);
for (int i = 0; i < packets; i++) {
h.caplen = pcap->pktv[i].len;
f_pcap_sendqueue_queue(pcap->pcap_queue, &h, pcap->pktv[i].data);
}
f_pcap_sendqueue_transmit(pcap->pcap, pcap->pcap_queue, 0);
pcap->pcap_queue->len = 0;
break;
case NET_EVENT_RX:
f_pcap_dispatch(pcap->pcap, PCAP_PKT_BATCH, net_pcap_rx_handler, (unsigned char *) pcap);
break;
default:
break;
}
}
pcap_log("PCAP: polling stopped.\n");
}
#else
static void
net_pcap_thread(void *priv)
{
net_pcap_t *pcap = (net_pcap_t *) priv;
pcap_log("PCAP: polling started.\n");
struct pollfd pfd[NET_EVENT_MAX];
pfd[NET_EVENT_STOP].fd = net_event_get_fd(&pcap->stop_event);
pfd[NET_EVENT_STOP].events = POLLIN | POLLPRI;
pfd[NET_EVENT_TX].fd = net_event_get_fd(&pcap->tx_event);
pfd[NET_EVENT_TX].events = POLLIN | POLLPRI;
pfd[NET_EVENT_RX].fd = f_pcap_get_selectable_fd((void *) pcap->pcap);
pfd[NET_EVENT_RX].events = POLLIN | POLLPRI;
/* As long as the channel is open.. */
while (1) {
poll(pfd, NET_EVENT_MAX, -1);
if (pfd[NET_EVENT_STOP].revents & POLLIN) {
net_event_clear(&pcap->stop_event);
break;
}
if (pfd[NET_EVENT_TX].revents & POLLIN) {
net_event_clear(&pcap->tx_event);
int packets = network_tx_popv(pcap->card, pcap->pktv, PCAP_PKT_BATCH);
for (int i = 0; i < packets; i++) {
net_pcap_in(pcap->pcap, pcap->pktv[i].data, pcap->pktv[i].len);
}
}
if (pfd[NET_EVENT_RX].revents & POLLIN) {
f_pcap_dispatch(pcap->pcap, PCAP_PKT_BATCH, net_pcap_rx_handler, (unsigned char *) pcap);
}
}
pcap_log("PCAP: polling stopped.\n");
}
#endif
/*
* Prepare the (Win)Pcap module for use.
*
* This is called only once, during application init,
* to check for availability of PCAP, and to retrieve
* a list of (usable) intefaces for it.
*/
int
net_pcap_prepare(netdev_t *list)
{
char errbuf[PCAP_ERRBUF_SIZE];
pcap_if_t *devlist;
int i = 0;
/* Try loading the DLL. */
#ifdef _WIN32
/* Add the Npcap directory to the DLL search path. */
char npcap_dir[512];
GetSystemDirectoryA(npcap_dir, 480);
strcat(npcap_dir, "\\Npcap");
SetDllDirectoryA(npcap_dir);
libpcap_handle = dynld_module("wpcap.dll", pcap_imports);
SetDllDirectoryA(NULL); /* reset the DLL search path */
#elif defined __APPLE__
libpcap_handle = dynld_module("libpcap.dylib", pcap_imports);
#else
libpcap_handle = dynld_module("libpcap.so", pcap_imports);
#endif
if (libpcap_handle == NULL) {
pcap_log("PCAP: error loading pcap module\n");
return (-1);
}
/* Retrieve the device list from the local machine */
if (f_pcap_findalldevs(&devlist, errbuf) == -1) {
pcap_log("PCAP: error in pcap_findalldevs: %s\n", errbuf);
return (-1);
}
for (pcap_if_t *dev = devlist; dev != NULL; dev = dev->next) {
if (i >= (NET_HOST_INTF_MAX - 1))
break;
/**
* we initialize the strings to NULL first for strncpy
*/
memset(list->device, '\0', sizeof(list->device));
memset(list->description, '\0', sizeof(list->description));
strncpy(list->device, dev->name, sizeof(list->device) - 1);
if (dev->description) {
strncpy(list->description, dev->description, sizeof(list->description) - 1);
} else {
/* if description is NULL, set the name. This allows pcap to display *something* useful under WINE */
strncpy(list->description, dev->name, sizeof(list->description) - 1);
}
list++;
i++;
}
/* Release the memory. */
f_pcap_freealldevs(devlist);
return i;
}
/*
* Copy error message to the error buffer
* and log if enabled.
*/
void net_pcap_error(char *errbuf, const char *message) {
strncpy(errbuf, message, NET_DRV_ERRBUF_SIZE);
pcap_log("PCAP: %s\n", message);
}
/*
* Initialize (Win)Pcap for use.
*
* We already know we have PCAP available, as this
* is called when the network activates itself and
* tries to attach to the network module.
*/
void *
net_pcap_init(const netcard_t *card, const uint8_t *mac_addr, void *priv, char *netdrv_errbuf)
{
char errbuf[PCAP_ERRBUF_SIZE];
char *str;
char filter_exp[255];
struct bpf_program fp;
char errbuf_prep[NET_DRV_ERRBUF_SIZE];
char *intf_name = (char *) priv;
/* Did we already load the library? */
if (libpcap_handle == NULL) {
net_pcap_error(netdrv_errbuf, "net_pcap_init without handle");
return NULL;
}
/* Get the PCAP library name and version. */
strcpy(errbuf, f_pcap_lib_version());
str = strchr(errbuf, '(');
if (str != NULL)
*(str - 1) = '\0';
pcap_log("PCAP: initializing, %s\n", errbuf);
/* Get the value of our capture interface. */
if ((intf_name[0] == '\0') || !strcmp(intf_name, "none")) {
net_pcap_error(netdrv_errbuf, "No interface configured");
return NULL;
}
pcap_log("PCAP: interface: %s\n", intf_name);
net_pcap_t *pcap = calloc(1, sizeof(net_pcap_t));
pcap->card = (netcard_t *) card;
memcpy(pcap->mac_addr, mac_addr, sizeof(pcap->mac_addr));
if ((pcap->pcap = f_pcap_create(intf_name, errbuf)) == NULL) {
snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, " Unable to open device: %s!\n", intf_name);
net_pcap_error(netdrv_errbuf, errbuf_prep);
free(pcap);
return NULL;
}
if (f_pcap_setnonblock(pcap->pcap, 1, errbuf) != 0)
pcap_log("PCAP: failed nonblock %s\n", errbuf);
if (f_pcap_set_immediate_mode(pcap->pcap, 1) != 0)
pcap_log("PCAP: error setting immediate mode\n");
if (f_pcap_set_promisc(pcap->pcap, 1) != 0)
pcap_log("PCAP: error enabling promiscuous mode\n");
if (f_pcap_set_snaplen(pcap->pcap, NET_MAX_FRAME) != 0)
pcap_log("PCAP: error setting snaplen\n");
if (f_pcap_activate(pcap->pcap) != 0) {
snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, "%s", (char *)f_pcap_geterr(pcap->pcap));
net_pcap_error(netdrv_errbuf, errbuf_prep);
f_pcap_close(pcap->pcap);
free(pcap);
return NULL;
}
/* Create a MAC address based packet filter. */
pcap_log("PCAP: installing filter for MAC=%02x:%02x:%02x:%02x:%02x:%02x\n",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
sprintf(filter_exp,
"( ((ether broadcast) or (ether multicast) or (ether dst %02x:%02x:%02x:%02x:%02x:%02x)) and not (ether src %02x:%02x:%02x:%02x:%02x:%02x) )",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5],
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
if (f_pcap_compile(pcap->pcap, &fp, filter_exp, 0, 0xffffffff) != -1) {
if (f_pcap_setfilter(pcap->pcap, &fp) != 0) {
snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, "Error installing filter (%s)\n", filter_exp);
net_pcap_error(netdrv_errbuf, errbuf_prep);
f_pcap_close(pcap->pcap);
free(pcap);
return NULL;
}
} else {
snprintf(errbuf_prep, NET_DRV_ERRBUF_SIZE, "Could not compile filter (%s) : %s!\n", filter_exp, (char *)f_pcap_geterr(pcap->pcap));
net_pcap_error(netdrv_errbuf, errbuf_prep);
f_pcap_close(pcap->pcap);
free(pcap);
return NULL;
}
#ifdef _WIN32
pcap->pcap_queue = f_pcap_sendqueue_alloc(PCAP_PKT_BATCH * NET_MAX_FRAME);
#endif
for (int i = 0; i < PCAP_PKT_BATCH; i++) {
pcap->pktv[i].data = calloc(1, NET_MAX_FRAME);
}
pcap->pkt.data = calloc(1, NET_MAX_FRAME);
net_event_init(&pcap->tx_event);
net_event_init(&pcap->stop_event);
pcap->poll_tid = thread_create(net_pcap_thread, pcap);
return pcap;
}
/* Close up shop. */
void
net_pcap_close(void *priv)
{
if (!priv)
return;
net_pcap_t *pcap = (net_pcap_t *) priv;
pcap_log("PCAP: closing.\n");
/* Tell the thread to terminate. */
net_event_set(&pcap->stop_event);
/* Wait for the thread to finish. */
pcap_log("PCAP: waiting for thread to end...\n");
thread_wait(pcap->poll_tid);
pcap_log("PCAP: thread ended\n");
for (int i = 0; i < PCAP_PKT_BATCH; i++) {
free(pcap->pktv[i].data);
}
free(pcap->pkt.data);
#ifdef _WIN32
f_pcap_sendqueue_destroy((void *) pcap->pcap_queue);
#endif
/* OK, now shut down Pcap itself. */
f_pcap_close(pcap->pcap);
net_event_close(&pcap->tx_event);
net_event_close(&pcap->stop_event);
free(pcap);
}
const netdrv_t net_pcap_drv = {
&net_pcap_in_available,
&net_pcap_init,
&net_pcap_close,
NULL
};
```
|
Bapi Bari Jaa is a 2012 Indian Bengali romantic comedy film directed by Sudeshna Roy and Abhijit Guha. The movie is jointly produced by Shree Venkatesh Films and Idea Creations, and stars Arjun Chakrabarty and Mimi Chakraborty in lead roles with Shalmi Barman, Tista Dutta and Anindya Chatterjee in pivotal roles. The film is about youngsters and the story of the film revolves around a young sheltered man who suddenly discovers life when he comes out on to the streets one day. The movie was released on 7 December 2012.
Plot
Five childhood friends – Bapi, Dola, Jijo, Hasna and Riju – are just out of college and hangs out together. Bapi, the younger son of a rich jeweller in Kolkata happens to be the money contributors for his friends. While Bapi joins his family business, other friends are looking out for jobs. Jijo gets into a relationship with Hasna. Riju thinks that he is into a relationship with a girl five years older than him. One day Riju's world was shattered when she introduced Riju to her fiancé, and calls him her brother. Riju got himself drunk, and all the friends left him alone outside the bar. While returning from the pub with Dola, Bapi realised that he must have got some feelings for Dola. One day, when Dola came to Bapi's house, he asked Dola "who is Bishwayan da?". They got into an argument and Bapi kissed Dola. Dola freed herself and told that they are just friends, but gave Bapi another kiss on his cheek. Further, she told that Bapi is not manly enough and lacks any mystery in his life. Another day Bapi's sister-in-law found adult magazines and evidence of masturbation, asks Bapi's elder brother to get Bapi married.
Bapi goes to see his prospective bride, where he meets Sheuli, a middle-class girl. Sheuli asks Bapi if he loves someone else. He confesses that he loves Dola. Sheuli told that she will help him to get Dola, but he must call off the marriage. Bapi introduces Sheuli to his friends. Dola seemed jealous about Sheuli and asked Bapi that this is not the ideal time to marry. Bapi gets a job of a salesman on the advice of Sheuli and struggles to impress Dola. In the meantime, Sheuli and Bapi seem to fall in love with each other. Dola realises that she loves Bapi and wants to be with him. One day Bapi went to Sheuli's home, where she asks him to stay away. It is seen that Sheuli meets her old boyfriend, who returned to the city. Dola confessed her love before Bapi, and told him not to leave his salesman job.
Cast
Arjun Chakrabarty as Bapi
Mimi Chakraborty as Dola
Shalmi Barman as Sheuli
Anindya Chatterjee as Jijo
Tista Dutta as Hasna
Dhurbojyoti Sarkar as Riju
Avrajit Chakraborty as Biltu
Bulbuli Choubey Panja as Biltu's wife
Oindrila Saha as Biltu's daughter
Abir Chatterjee as Bishe Da
Srijit Mukherji as Bishwayan Da
Soundtrack
References
2012 films
Indian romantic comedy films
Films set in Kolkata
2012 romantic comedy films
Bengali-language Indian films
2010s Bengali-language films
Films directed by Abhijit Guha and Sudeshna Roy
|
```java
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
package io.camunda.zeebe.gateway.impl.probes.health;
import static java.util.Objects.requireNonNull;
import io.camunda.zeebe.broker.client.api.BrokerClusterState;
import java.util.Optional;
import java.util.function.Supplier;
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
/**
* Health indicator that signals whether the gateway is aware of any nodes in the cluster. If the
* gateway is not aware of any nodes this indicates a potential network topology problem
*/
public class ClusterAwarenessHealthIndicator implements HealthIndicator {
private final Supplier<Optional<BrokerClusterState>> clusterStateSupplier;
public ClusterAwarenessHealthIndicator(
final Supplier<Optional<BrokerClusterState>> clusterStateSupplier) {
this.clusterStateSupplier = requireNonNull(clusterStateSupplier);
}
@Override
public Health health() {
final var optClusterState = clusterStateSupplier.get();
if (optClusterState.isEmpty()) {
return Health.down().build();
} else {
if (optClusterState.get().getBrokers().isEmpty()) {
return Health.down().build();
} else {
return Health.up().build();
}
}
}
}
```
|
Izra' District () is a district (mantiqah) administratively belonging to Daraa Governorate, Syria. At the 2004 Census it had a population of 246,804. Its administrative centre is the city of Izra'.
Sub-districts
The district of Izra' is divided into six sub-districts or Nāḥiyas (population according to 2004 official census):
Izra Subdistrict (ناحية ازرع): population 56,760.
Jasim Subdistrict (ناحية جاسم): population 39,624.
Al-Hirak Subdistrict (ناحية الحراك): population 40,979.
Nawa Subdistrict (ناحية نوى): population 57,404.
Al-Shaykh Subdistrict (ناحية الشيخ مسكين): population 34,370.
Tasil Subdistrict (ناحية تسيل): population 17,778.
References
Districts of Daraa Governorate
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
// MODULES //
var files = require( './file_list.js' );
// MAIN //
var db = new Array( files.length );
// EXPORTS //
module.exports = db;
```
|
The Railway Mail Service (RMS) Library is a major collection of materials pertaining to en route distribution history. Incorporated in May 2003, it can assist researchers interested in Railway Mail Service, route agent, Seapost, Railway Post Office (RPO), and Highway Post Office (HPO) history. The collection has many unique, original-source documents that provide answers to questions dealing with the transportation and distribution of USA Mail between 1862 and 1977, as well as other countries during the 19th century and 20th century.
History
The RMS Library has grown from the AmeRPO ("American RPO") Society Library established in the early 1950s by Bryant Alden Long, co-author of Mail by Rail. After a period of stagnation, it was acquired by Hershel Rankin, who renamed it the RMS Library. When he was 80 years old and no longer able to handle research requests, Dr. Frank R. Scheer purchased the collection. Over a two-year period, the collection was moved from Florida to Virginia and renamed the "Railway Mail Service Library."
The collection
The RMS Library has every major book published about the Railway Mail Service/Postal Transportation Service (RMS/PTS). It also has many periodical articles written about en route distribution, and continually seeks ones that are not represented. There are six types of original-source documentation in the collection, however. These are:
Photographs of HPO and RPO vehicles
The Railway Post Office and Postal Transport Journal issues between 1905 and 1959
Oral recollections of former clerks on audio and videotapes, as well as movies about the RMS/PTS
General orders describing weekly changes within several divisions
General and standpoint schemes of mail distribution
Schedules of mail trains/routes. Schemes and schedules are particularly helpful for understanding how the network of mail transportation and distribution activities operated, as well as when routes began, ended, or underwent significant changes.
Since 1982, several major additions have been made to the collection. These include the Edwin Bergman scheme and schedule collection, Lloyd Jackson's, John Kay's, Lawrence Kruse's, Ed Maloney's, and Roy Schmidt's postal artifacts, Carm Cosentino's Transfer Office covers, Charles Scott's Fifth Division RMS records, worldwide postal emblems assembled by Len Cohen, James Mundy's postal locks, Lt. Col (ret) A. B. "Chip" Komoroske's railroad books, H. W. "Red" Reed's post office route maps, John McClelland's 1905 to 1949 bound issues of The Railway Post Office, as well as Paul Nagle's set of the Postal Transport Journal between 1950 and 1959. A multitude of other historically-significant resources have been acquired from many former railway and highway postal clerks.
Activities
As with most archival libraries, the principal activities are assisting research inquiries, organizing and filing the collection, as well as preservation of materials. The largest artifact in the collection is the building that became the Library's home on October 16, 2003: the Boyce, Virginia, railroad station. Built in 1913 and in service on the Norfolk and Western Railway for more than four decades, it was used for the town post office during the 1970s. Inside the 24 by 46 feet freight room are 20 filing cabinets and more than 500 feet of shelving. Artifact displays will be presented in the former baggage and waiting rooms after 2005.
Expansion
The RMS Library also seeks to buy or exchange documents, publications, and artifacts to expand the collection's scope and coverage. Items that are acquired are preserved in a climate-controlled environment. Rarer items are restored or treated to insure their existence for use by future researchers.
Potential Move
An article published February 9, 2019, in The Winchester Star describes Dr. Scheer's intent to move much of the library's collection to another site in Boyce, leaving space in the old depot "available for public use, such as for a town visitor’s center, wedding receptions and other special events, or model railroad club layouts." Revenue from its use as a venue would provide income for the building's maintenance
Scope
The limited scope of the collection – doing a few specific things well – combined with Dr. Scheer's personal knowledge of transportation and postal history, permits better responses to user queries than many other non-specialized organizations can provide. The RMS Library also participates in inter-library loans or will provide photo-reproductions of items at five cents per page. Inquiries pertaining to RMS Library holdings or persons seeking research assistance should contact Dr. Scheer, at the library.
References
Rail transportation in the United States
United States Postal Service
2003 establishments in the United States
|
The Daylight Saving for South East Queensland Referendum Bill 2010 was a bill tabled in the Queensland Parliament on 14 April 2010, by Independent Member Peter Wellington. Wellington had called for a referendum to be held at the next State election on introduction of daylight saving time for South East Queensland. The Bill proposed a split-time zone for the state of Queensland and had suggested that the local government areas of Brisbane, Gold Coast, Sunshine Coast, Ipswich, Logan, Scenic Rim, Redland and Moreton Bay be included in the daylight saving time zone, while the rest of the state remains on standard time.
Drafting
In early 2010, the Daylight Saving for South East Queensland (DS4SEQ) political party approached Wellington to introduce a private member's bill. As Wellington agreed with the principles of the DS4SEQ proposal, specifically the dual time zone arrangement, he drafted the Daylight Saving for South East Queensland Referendum Bill 2010.
Response
In response to this bill, Leader of the Opposition John-Paul Langbroek, immediately announced that he would not support the bill, saying "We will not be supporting a referendum on daylight saving," and "I don't want to make an interstate problem an intrastate problem."
The Premier of Queensland, Anna Bligh, announced a community consultation process, which resulted in over 74,000 respondents participating, 64 per cent of whom supported a trial of daylight saving, while 63 per cent were also in favour of holding a referendum. On 7 June 2010, and after reviewing the favourable consultation results, Bligh announced that her Government would not support the bill because regional Queenslanders were overwhelmingly opposed to daylight saving. DS4SEQ called for Bligh and her government to reconsider their position.
The bill was defeated in Queensland Parliament on 15 June 2011.
Previous daylight saving referendum
Queensland had had one referendum on daylight saving, held on 22 February 1992, with the question: "Are you in favour of daylight saving?", which was defeated with a 54.5 per cent 'no' vote. The vote on this referendum was after Queensland had trialled daylight saving over a three-year period, from 1989/90 to 1991/92. The referendum result displayed a distinct trend—that public opinion on daylight saving in Queensland is geographically divided, with the 'no' vote strongest in the north and west regional districts, while the 'yes' vote was strongest in the state's metropolitan south-east.
See also
Time in Australia
Daylight saving time around the world
References
External links
Daylight Saving for South East Queensland Referendum Bill 2010
Daylight Saving for South East Queensland Party official website
Referendums in Queensland
2010 in Australian law
Daylight saving time in Australia
2010s in Queensland
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.