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; }