QVariantMap NetworkManager::Security8021xSetting::secretsToMap() const
{
QVariantMap secrets;
if (!password().isEmpty()) {
secrets.insert(QLatin1String(NM_SETTING_802_1X_PASSWORD), password());
}
if (!passwordRaw().isEmpty()) {
secrets.insert(QLatin1String(NM_SETTING_802_1X_PASSWORD_RAW), passwordRaw());
}
if (!privateKeyPassword().isEmpty()) {
secrets.insert(QLatin1String(NM_SETTING_802_1X_PRIVATE_KEY_PASSWORD), privateKeyPassword());
}
if (!phase2PrivateKeyPassword().isEmpty()) {
secrets.insert(QLatin1String(NM_SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD), phase2PrivateKeyPassword());
}
if (!pin().isEmpty()) {
secrets.insert(QLatin1String(NM_SETTING_802_1X_PIN), pin());
}
return secrets;
}
SkDeviceProfile::SkDeviceProfile(float gammaExp, float contrast,
LCDConfig config, FontHintLevel level) {
fGammaExponent = pin(gammaExp, 0, 10);
fContrastScale = pin(contrast, 0, 1);
fLCDConfig = config;
fFontHintLevel = level;
}
void PinNode::drawShape( QPainter & p )
{
initPainter( p );
double v = pin() ? pin()->voltage() : 0.0;
QColor voltageColor = Component::voltageColor( v );
QPen pen = p.pen();
if ( isSelected() )
pen = m_selectedColor;
else if ( m_bShowVoltageColor )
pen = voltageColor;
if (m_pinPoint) {
bool drawDivPoint;
QPoint divPoint = findConnectorDivergePoint(&drawDivPoint);
m_pinPoint->setVisible(drawDivPoint);
m_pinPoint->move( divPoint.x()-1, divPoint.y()-1 );
m_pinPoint->setBrush( pen.color() );
m_pinPoint->setPen( pen.color() );
}
// Now to draw on our current/voltage bar indicators
int length = calcLength( v );
if ( (numPins() == 1) && m_bShowVoltageBars && length != 0 ) {
// we can assume that v != 0 as length != 0
double i = pin()->current();
double iProp = calcIProp(i);
int thickness = calcThickness(iProp);
p.setPen( QPen( voltageColor, thickness ) );
// The node line (drawn at the end of this function) will overdraw
// some of the voltage bar, so we need to adapt the length
if ( (v > 0) && (((225 < m_dir) && (m_dir < 315)) || ((45 < m_dir) && (m_dir < 135))) )
length--;
else if ( (v < 0) && (((135 < m_dir) && (m_dir < 225)) || ((315 < m_dir) || (m_dir < 45))) )
length++;
if ( (m_dir > 270) || (m_dir <= 90) )
p.drawLine( 3, 0, 3, length );
else p.drawLine( 3, 0, 3, -length );
}
pen.setWidth( (numPins() > 1) ? 2 : 1 );
p.setPen( pen );
p.drawLine( 0, 0, m_length, 0 );
deinitPainter( p );
}
void Animation::setOutput(unsigned char val)
{
if (! _buzzer)
analogWrite(pin(), val);
else if (val == 0)
noTone(pin());
else {
int note = 10*val;
tone(pin(), note);
}
}
// beep for a quarter of a second
void beep(void) {
outputs(pin(0) | pin(1));
pinOff(1);
byte i = 0;
while (i < 250) {
delay(1);
pinOn(pin(0));
delay(1);
pinOff(pin(0));
i++;
}
}
bool MakeSingleTrackTemplateChunk(WDL_FastString* _in, WDL_FastString* _out, bool _delItems, bool _delEnvs, int _tmpltIdx, bool _obeyOffset)
{
if (_in && _in->GetLength() && _out && _in!=_out)
{
_out->Set("");
// truncate to the track #_tmpltIdx found in the template
SNM_ChunkParserPatcher pin(_in);
if (pin.GetSubChunk("TRACK", 1, _tmpltIdx, _out) >= 0)
{
int* offsOpt = _obeyOffset ? (int*)GetConfigVar("templateditcursor") : NULL; // >= REAPER v4.15
// remove receives from the template as we deal with a single track
// note: possible with multiple tracks in a same template file (w/ routings between those tracks)
SNM_TrackEnvParserPatcher pout(_out);
pout.RemoveLine("TRACK", "AUXRECV", 1, -1, "MIDIOUT");
if (_delItems) // remove items from template (in one go)
pout.RemoveSubChunk("ITEM", 2, -1);
else if (offsOpt && *offsOpt) { // or offset them if needed
double add = GetCursorPositionEx(NULL);
pout.ParsePatch(SNM_D_ADD, 2, "ITEM", "POSITION", -1, 1, &add);
}
if (_delEnvs) // remove all envs from template (in one go)
pout.RemoveEnvelopes();
else if (offsOpt && *offsOpt) // or offset them if needed
pout.OffsetEnvelopes(GetCursorPositionEx(NULL));
return true;
}
}
return false;
}
static bool_t
xdrrx_putbytes(XDR *axdrs, caddr_t addr, u_int len)
{
afs_int32 code;
XDR * xdrs = (XDR *)axdrs;
struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
#if defined(KERNEL) && defined(AFS_AIX32_ENV)
char *saddr = (char *)&code;
saddr -= STACK_TO_PIN;
/*
* Hack of hacks: Aix3.2 only guarantees that the next 2K of stack in pinned. Under
* splnet (disables interrupts), which is set throughout rx, we can't swap in stack
* pages if we need so we panic. Since sometimes, under splnet, we'll use more than
* 2K stack we could try to bring the next few stack pages in here before we call the rx
* layer. Of course this doesn't guarantee that those stack pages won't be swapped
* out between here and calling splnet. So we now pin (and unpin) them instead to
* guarantee that they remain there.
*/
if (pin(saddr, STACK_TO_PIN)) {
/* XXX There's little we can do by continue XXX */
saddr = NULL;
rx_pin_failed++;
}
#endif
code = (rx_Write(call, addr, len) == len);
#if defined(KERNEL) && defined(AFS_AIX32_ENV)
if (saddr)
unpin(saddr, STACK_TO_PIN);
#endif
return code;
}
/* allocate space for sender */
void *
osi_AllocSmallSpace(size_t size)
{
struct osi_packet *tp;
AFS_STATCNT(osi_AllocSmallSpace);
if (size > AFS_SMALLOCSIZ)
osi_Panic("osi_AllocSmallS: size=%d\n", (int)size);
if (!freeSmallList) {
afs_stats_cmperf.SmallBlocksAlloced++;
afs_stats_cmperf.SmallBlocksActive++;
tp = afs_osi_Alloc(AFS_SMALLOCSIZ);
#ifdef KERNEL_HAVE_PIN
pin((char *)tp, AFS_SMALLOCSIZ);
#endif
return (char *)tp;
}
afs_stats_cmperf.SmallBlocksActive++;
ObtainWriteLock(&osi_fsplock, 327);
tp = freeSmallList;
if (tp)
freeSmallList = tp->next;
ReleaseWriteLock(&osi_fsplock);
return (char *)tp;
}
Value DocumentSourceCursor::serialize(bool explain) const {
// we never parse a documentSourceCursor, so we only serialize for explain
if (!explain)
return Value();
Lock::DBRead lk(_ns);
Client::Context ctx(_ns, storageGlobalParams.dbpath, /*doVersion=*/false);
ClientCursorPin pin(_cursorId);
ClientCursor* cursor = pin.c();
uassert(17135, "Cursor deleted. Was the collection or database dropped?",
cursor);
Runner* runner = cursor->getRunner();
runner->restoreState();
return Value(DOC(getSourceName() <<
DOC("query" << Value(_query)
<< "sort" << (!_sort.isEmpty() ? Value(_sort) : Value())
<< "limit" << (_limit ? Value(_limit->getLimit()) : Value())
<< "fields" << (!_projection.isEmpty() ? Value(_projection) : Value())
// << "indexOnly" << canUseCoveredIndex(cursor)
// << "cursorType" << cursor->c()->toString()
))); // TODO get more plan information
}
/* allocate space for sender */
void *
osi_AllocLargeSpace(size_t size)
{
struct osi_packet *tp;
AFS_ASSERT_GLOCK();
AFS_STATCNT(osi_AllocLargeSpace);
if (size > AFS_LRALLOCSIZ)
osi_Panic("osi_AllocLargeSpace: size=%d\n", (int)size);
afs_stats_cmperf.LargeBlocksActive++;
if (!freePacketList) {
char *p;
afs_stats_cmperf.LargeBlocksAlloced++;
p = afs_osi_Alloc(AFS_LRALLOCSIZ);
#ifdef KERNEL_HAVE_PIN
/*
* Need to pin this memory since under heavy conditions this memory
* could be swapped out; the problem is that we could inside rx where
* interrupts are disabled and thus we would panic if we don't pin it.
*/
pin(p, AFS_LRALLOCSIZ);
#endif
return p;
}
ObtainWriteLock(&osi_flplock, 324);
tp = freePacketList;
if (tp)
freePacketList = tp->next;
ReleaseWriteLock(&osi_flplock);
return (char *)tp;
}
// rolling friction works as follow: the idealization of the contact of a spherical object
// with a another surface is a point that pass by the center of the sphere.
// in most cases this is enough to model the collision but in insufficient for modeling
// the rolling friction. In reality contact with the sphere with the other surface is not
// a point but a contact patch. A contact patch has the property the it generates a fix
// constant rolling torque that opposes the movement of the sphere.
// we can model this torque by adding a clamped torque aligned to the instantaneously axis
// of rotation of the ball. and with a magnitude of the stopping angular acceleration.
void CustomDryRollingFriction::SubmitConstrainst (dFloat timestep, int threadIndex)
{
dVector omega;
dFloat omegaMag;
dFloat torqueFriction;
// get the omega vector
NewtonBodyGetOmega(m_body0, &omega[0]);
omegaMag = dSqrt (omega % omega);
if (omegaMag > 0.1f) {
// tell newton to used this the friction of the omega vector to apply the rolling friction
dVector pin (omega.Scale (1.0f / omegaMag));
NewtonUserJointAddAngularRow (m_joint, 0.0f, &pin[0]);
// calculate the acceleration to stop the ball in one time step
NewtonUserJointSetRowAcceleration (m_joint, -omegaMag / timestep);
// set the friction limit proportional the sphere Inertia
torqueFriction = m_frictionTorque * m_frictionCoef;
NewtonUserJointSetRowMinimumFriction (m_joint, -torqueFriction);
NewtonUserJointSetRowMaximumFriction (m_joint, torqueFriction);
} else {
// when omega is too low sheath a little bit and damp the omega directly
omega = omega.Scale (0.2f);
NewtonBodySetOmega(m_body0, &omega[0]);
}
}
// 计时器设置为PWM捕获器，此时只能捕获1路
// eg: TIM5, CH2, 捕获PA1
void Timer::mode_pwm_input(PinTypedef p) {
Pin pin(p); // 函数调用后变量就消失了
uint8_t tmp = this->GPIO_AF_TIM(this->TIM);
// 看看tmp有没有问题
pin.mode_pwm_input(tmp);
NVIC_InitTypeDef NVIC_InitStructure; // 中断初始化器
NVIC_InitStructure.NVIC_IRQChannel = this->IRQn;
// 低频高优先级原则，20mS的捕获中断设为最高优先级
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // IRQ 通道使能
NVIC_Init(&NVIC_InitStructure);
// 时钟预分频
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructrue; // 计时器分频初始化器
TIM_TimeBaseStructrue.TIM_Prescaler = PRESCALER;
TIM_TimeBaseStructrue.TIM_Prescaler = PRESCALER;
switch (this->TIM_No) {
case (1):
case (8):
case (9):
case (10):
case (11): {
TIM_TimeBaseStructrue.TIM_Prescaler = PRESCALER_APB2;
break;
}
}
TIM_TimeBaseStructrue.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructrue.TIM_Period = PERIOD;
TIM_TimeBaseStructrue.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseInit(this->TIM, &TIM_TimeBaseStructrue);
// 设置TIM5 CH2 pin为外部信号输入
// CCR2测频率
// CCR1测占空比
TIM_ICInitTypeDef TIM_ICInitStructure; // 计时器模块初始化器
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2; // input channel 2
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising; // 上升沿中断
TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI; // map IC1 to TI1
TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1; // 输入分频，不分频
TIM_ICInitStructure.TIM_ICFilter = 0x00; //滤波设置，经历几个周期跳变认定波形稳定0x0～0xF
TIM_PWMIConfig(this->TIM, &TIM_ICInitStructure);
/* Select the TIM5 Input Trigger: TI2FP2 */
TIM_SelectInputTrigger(this->TIM, TIM_TS_TI2FP2);
TIM_SelectSlaveMode(this->TIM,TIM_SlaveMode_Reset);//TIM从模式：触发信号的上升沿重新初始化计数器和触发寄存器的更新事件
TIM_SelectMasterSlaveMode(this->TIM,TIM_MasterSlaveMode_Enable); //启动定时器的被动触发
TIM_Cmd(this->TIM, ENABLE); // run TIM5
// 设置中断ISR为PWM Input模式中断
// this->set_IRQHandler(Timer::PWM_Input_Handler_Dispatch);
if ((TIM_No==1)||(TIM_No==8))
TIM_ITConfig(this->TIM, TIM_IT_Update, ENABLE); // 打开中断，不要
else
TIM_ITConfig(this->TIM, TIM_IT_CC2, ENABLE); // 打开中断，TIM_IT_Update不要
}
static void handleCursorCommand(CursorId id, BSONObj& cmdObj, BSONObjBuilder& result) {
BSONElement batchSizeElem = cmdObj.getFieldDotted("cursor.batchSize");
const long long batchSize = batchSizeElem.isNumber()
? batchSizeElem.numberLong()
: 101; // same as query
ClientCursorPin pin(id);
ClientCursor* cursor = pin.c();
massert(16958, "Cursor shouldn't have been deleted",
cursor);
verify(cursor->isAggCursor);
PipelineRunner* runner = dynamic_cast<PipelineRunner*>(cursor->getRunner());
verify(runner);
try {
const string cursorNs = cursor->ns(); // we need this after cursor may have been deleted
// can't use result BSONObjBuilder directly since it won't handle exceptions correctly.
BSONArrayBuilder resultsArray;
const int byteLimit = MaxBytesToReturnToClientAtOnce;
BSONObj next;
for (int objCount = 0; objCount < batchSize; objCount++) {
// The initial getNext() on a PipelineRunner may be very expensive so we don't do it
// when batchSize is 0 since that indicates a desire for a fast return.
if (runner->getNext(&next, NULL) != Runner::RUNNER_ADVANCED) {
pin.deleteUnderlying();
id = 0;
cursor = NULL; // make it an obvious error to use cursor after this point
break;
}
if (resultsArray.len() + next.objsize() > byteLimit) {
// too big. next will be the first doc in the second batch
runner->pushBack(next);
break;
}
resultsArray.append(next);
}
if (cursor) {
// If a time limit was set on the pipeline, remaining time is "rolled over" to the
// cursor (for use by future getmore ops).
cursor->setLeftoverMaxTimeMicros( cc().curop()->getRemainingMaxTimeMicros() );
}
BSONObjBuilder cursorObj(result.subobjStart("cursor"));
cursorObj.append("id", id);
cursorObj.append("ns", cursorNs);
cursorObj.append("firstBatch", resultsArray.arr());
cursorObj.done();
}
catch (...) {
// Clean up cursor on way out of scope.
pin.deleteUnderlying();
throw;
}
}
const char *_graph_pin(t_graphical *graph,
const t_server *server,
const char *data)
{
if (!graph || !server || !data || !data[0])
return ("suc\n");
return (pin(get_player_for_id(server, atoi(data))));
}
void pin(int num)
{
if(num>9)
{
pin(num/10);
}
printf("%d",num%10);
}
void DocumentSourceCursor::loadBatch() {
if (!_cursorId) {
dispose();
return;
}
// We have already validated the sharding version when we constructed the cursor
// so we shouldn't check it again.
Lock::DBRead lk(_ns);
Client::Context ctx(_ns, storageGlobalParams.dbpath, /*doVersion=*/false);
ClientCursorPin pin(_cursorId);
ClientCursor* cursor = pin.c();
uassert(16950, "Cursor deleted. Was the collection or database dropped?",
cursor);
Runner* runner = cursor->getRunner();
runner->restoreState();
int memUsageBytes = 0;
BSONObj obj;
Runner::RunnerState state;
while ((state = runner->getNext(&obj, NULL)) == Runner::RUNNER_ADVANCED) {
// TODO SERVER-11831: consider using documentFromBsonWithDeps(obj, _dependencies)
_currentBatch.push_back(Document(obj));
if (_limit) {
if (++_docsAddedToBatches == _limit->getLimit()) {
break;
}
verify(_docsAddedToBatches < _limit->getLimit());
}
memUsageBytes += _currentBatch.back().getApproximateSize();
if (memUsageBytes > MaxBytesToReturnToClientAtOnce) {
// End this batch and prepare cursor for yielding.
runner->saveState();
cc().curop()->yielded();
return;
}
}
// If we got here, there won't be any more documents, so destroy the cursor and runner.
_cursorId = 0;
pin.deleteUnderlying();
uassert(16028, "collection or index disappeared when cursor yielded",
state != Runner::RUNNER_DEAD);
uassert(17285, "cursor encountered an error",
state != Runner::RUNNER_ERROR);
massert(17286, str::stream() << "Unexpected return from Runner::getNext: " << state,
state == Runner::RUNNER_EOF || state == Runner::RUNNER_ADVANCED);
}
void Conference::LoadList(){
CListCtrl *conf= (CListCtrl*)GetDlgItem(IDC_CONFLIST);
conf->DeleteAllItems();
std::string header = "/oneworld/conf_list?api_token=";
header+=((CmicrosipDlg*)GetParent())->getToken();
CInternetSession session;
CHttpConnection *pConnection = session.GetHttpConnection(_T("89.163.142.253"));
char result[500];
CString request(header.c_str());
CHttpFile *pFile = pConnection->OpenRequest(1,request);
if(!pFile->SendRequest())
return;
pFile->Read((void*)result,500);
char* status = strchr(result,']'); //checking if data is receive and is parseable
char* eom = strchr(result,'}');
#ifdef _DEBUG
_cprintf("Size: %p, %p, %d\n",result, status, (status-result));
#endif
if(status==NULL)
result[eom-result+1]='\0';
else if(status - result < 4998)
result[status - result +2]='\0';
#ifdef _DEBUG
_cprintf("Result: %s\n",result);
#endif
cJSON *root = cJSON_Parse(result);
cJSON *msg = cJSON_GetObjectItem(root,"msg");
if((status==NULL && msg == NULL) || status-result >= 4999 )
return;
else if(status==NULL)
return;
cJSON *data = cJSON_GetObjectItem(root,"data");
int size=cJSON_GetArraySize(root);
#ifdef _DEBUG
_cprintf("Size: %d\n",size);
#endif
size=cJSON_GetArraySize(data);
#ifdef _DEBUG
_cprintf("Size: %d\n",size);
#endif
for(int i=0;i<size;i++){
cJSON* item= cJSON_GetArrayItem(data,i);
CString confNum(cJSON_GetObjectItem(item,"confno")->valuestring);
CString pin(cJSON_GetObjectItem(item,"pin")->valuestring);
#ifdef _DEBUG
_cprintf("Item: %s\n",(CT2CA)confNum);
_cprintf("Pin: %s\n",(CT2CA)pin);
#endif
int index = conf->InsertItem(i, confNum);
conf->SetItemText(index, 1, pin);
//conf->SetItemData(i, &confNum);
}
}
void PinDialog::accept()
{
if (m_type == PinPuk) {
if (pin() != pin2()) {
showErrorMessage(PinCodesDoNotMatch);
return;
} else if (puk().length() < 8) {
showErrorMessage(PukCodeTooShort);
return;
}
}
if (pin().length() < 4) {
showErrorMessage(PinCodeTooShort);
return;
}
QDialog::accept();
}
PropertyOffset Structure::removePropertyWithoutTransition(JSGlobalData& globalData, PropertyName propertyName)
{
ASSERT(isUncacheableDictionary());
ASSERT(!m_enumerationCache);
materializePropertyMapIfNecessaryForPinning(globalData);
pin();
return remove(propertyName);
}
virtual void filterSpan(const SkPMColor shader[], int count,
SkPMColor result[]) {
unsigned addR = SkColorGetR(fAdd);
unsigned addG = SkColorGetG(fAdd);
unsigned addB = SkColorGetB(fAdd);
for (int i = 0; i < count; i++) {
SkPMColor c = shader[i];
if (c) {
unsigned a = SkGetPackedA32(c);
unsigned scaleA = SkAlpha255To256(a);
unsigned r = pin(SkGetPackedR32(c) + SkAlphaMul(addR, scaleA), a);
unsigned g = pin(SkGetPackedG32(c) + SkAlphaMul(addG, scaleA), a);
unsigned b = pin(SkGetPackedB32(c) + SkAlphaMul(addB, scaleA), a);
c = SkPackARGB32(a, r, g, b);
}
result[i] = c;
}
}
void object::test<1>()
{
{
GC::Handle<existing> h=new GC::Wrapper<existing>();
GC::Handle<existing>::Pin pin(h);
GC::Controller::forceGC();
ensure_equals(exists,true);
}
GC::Controller::forceGC();
ensure_equals(exists,false);
}
size_t Structure::removePropertyWithoutTransition(JSGlobalData& globalData, const Identifier& propertyName)
{
ASSERT(isUncacheableDictionary());
ASSERT(!m_enumerationCache);
materializePropertyMapIfNecessaryForPinning(globalData);
pin();
size_t offset = remove(propertyName);
return offset;
}
main()
{
iNPstream pin("test1");
char c;
char buf[256];
while (!pin.eof())
{
pin.getline(buf,256);
cout <<buf<<endl;
}
}
PropertyOffset Structure::addPropertyWithoutTransition(JSGlobalData& globalData, PropertyName propertyName, unsigned attributes, JSCell* specificValue)
{
ASSERT(!enumerationCache());
if (m_specificFunctionThrashCount == maxSpecificFunctionThrashCount)
specificValue = 0;
materializePropertyMapIfNecessaryForPinning(globalData);
pin();
return putSpecificValue(globalData, propertyName, attributes, specificValue);
}
void EditRatioWindow::react_Move(Point point,MouseKey mkey)
{
if( pane.contains(point) )
{
if( Change(hilight,true) ) redraw();
if( mkey&MouseKey_Left ) pin(point);
}
else
{
if( Change(hilight,false) ) redraw();
}
}
static void handleCursorCommand(CursorId id, BSONObj& cmdObj, BSONObjBuilder& result) {
BSONElement batchSizeElem = cmdObj.getFieldDotted("cursor.batchSize");
const long long batchSize = batchSizeElem.isNumber()
? batchSizeElem.numberLong()
: 101; // same as query
// Using limited cursor API that ignores many edge cases. Should be sufficient for commands.
ClientCursor::Pin pin(id);
ClientCursor* cursor = pin.c();
massert(16958, "Cursor shouldn't have been deleted",
cursor);
// Make sure this cursor won't disappear on us
fassert(16959, !cursor->c()->shouldDestroyOnNSDeletion());
fassert(16960, !cursor->c()->requiresLock());
try {
// can't use result BSONObjBuilder directly since it won't handle exceptions correctly.
BSONArrayBuilder resultsArray;
const int byteLimit = MaxBytesToReturnToClientAtOnce;
for (int objs = 0;
objs < batchSize && cursor->ok() && resultsArray.len() <= byteLimit;
objs++) {
// TODO may need special logic if cursor->current() would cause results to be > 16MB
resultsArray.append(cursor->current());
cursor->advance();
}
// The initial ok() on a cursor may be very expensive so we don't do it when batchSize
// is 0 since that indicates a desire for a fast return.
if (batchSize != 0 && !cursor->ok()) {
// There is no more data. Kill the cursor.
pin.release();
ClientCursor::erase(id);
id = 0;
}
BSONObjBuilder cursorObj(result.subobjStart("cursor"));
cursorObj.append("id", id);
cursorObj.append("ns", cursor->ns());
cursorObj.append("firstBatch", resultsArray.arr());
cursorObj.done();
}
catch (...) {
// Clean up cursor on way out of scope.
pin.release();
ClientCursor::erase(id);
throw;
}
}
Value DocumentSourceCursor::serialize(bool explain) const {
// we never parse a documentSourceCursor, so we only serialize for explain
if (!explain)
return Value();
Status explainStatus(ErrorCodes::InternalError, "");
scoped_ptr<TypeExplain> plan;
{
Lock::DBRead lk(_ns);
Client::Context ctx(_ns, storageGlobalParams.dbpath, /*doVersion=*/false);
ClientCursorPin pin(_cursorId);
ClientCursor* cursor = pin.c();
uassert(17135, "Cursor deleted. Was the collection or database dropped?",
cursor);
Runner* runner = cursor->getRunner();
runner->restoreState();
TypeExplain* explainRaw;
explainStatus = runner->getExplainPlan(&explainRaw);
if (explainStatus.isOK())
plan.reset(explainRaw);
runner->saveState();
}
MutableDocument out;
out["query"] = Value(_query);
if (!_sort.isEmpty())
out["sort"] = Value(_sort);
if (_limit)
out["limit"] = Value(_limit->getLimit());
if (!_projection.isEmpty())
out["fields"] = Value(_projection);
if (explainStatus.isOK()) {
out["plan"] = Value(extractInfo(plan));
} else {
out["planError"] = Value(explainStatus.toString());
}
return out.freezeToValue();
}
int main()
{
PinD2 pin(1);
pin.setPin(true);
MotorPort port;
port.setPinA(true);
port.setPinA(false);
StepMotor<MotorPort> motor;
motor.action();
return 0;
}
//! Gets called after we are certain that this pin isn't in use.
bool PinManager::insertPin(const std::string& p_pinNumber, const std::string& p_mode)
{
boost::shared_ptr<GPIOPin> pin(new GPIOPin(p_pinNumber, p_mode));
if (pin)
{
m_pinsInUse.insert(std::make_pair(p_pinNumber, pin));
std::cout << "successfully inserted pin " << std::endl;
std::cout << "Pin number is " << pin.get() << std::endl;
return true;
}
else
{
std::cout << "Failed to insert pin" << std::endl;
return false;
}
}
size_t Structure::addPropertyWithoutTransition(JSGlobalData& globalData, const Identifier& propertyName, unsigned attributes, JSCell* specificValue)
{
ASSERT(!m_enumerationCache);
if (m_specificFunctionThrashCount == maxSpecificFunctionThrashCount)
specificValue = 0;
materializePropertyMapIfNecessaryForPinning(globalData);
pin();
size_t offset = putSpecificValue(globalData, propertyName, attributes, specificValue);
if (propertyStorageSize() > propertyStorageCapacity())
growPropertyStorageCapacity();
return offset;
}