Ptr DropOjama::update() { ++count; if (r.done()) { Field& f = param->field; for (auto& v : drop) std::fill(v.begin(), v.end(), false); for (int j = 1; j < f.width() - 1; j++) { for (int i = f.height() - 2; i > 0; i--) { if (f(j, i).color == Puyo::E && f(j, i - 1).color != Puyo::E) { while (i > 0) { drop[i][j] = true; std::swap(f(j, i), f(j, i - 1)); i--; } r.start(); break; } } } if (r.done()) { return std::make_shared<Wait>(param); } } r.update(); return getPtr(); }
ReallocBufferPtr ObjectPool::getReallocBufferPtr() { ReallocBufferPtr rbPtr; ReallocBuffer * pt = NULL; getPtr(pt, rbPtr, mRbPool, mRbPoolMutex, &ObjectPool::putReallocBuffer); return rbPtr; }
extern "C" JNIEXPORT jint JNICALL Java_io_lowla_lowladb_LDBWriteResult_getDocumentCount(JNIEnv *env, jobject jThis) { CLowlaDBWriteResult::ptr &wr = getPtr(env, jThis); return wr->documentCount(); }
MemOstreamPtr ObjectPool::getMemOstreamPtr() { MemOstreamPtr osPtr; MemOstream * pt = NULL; getPtr(pt, osPtr, mOsPool, mOsPoolMutex, &ObjectPool::putMemOstream); return osPtr; }
bufsize_t LdConfigDirWrapper::getSize() { if (getPtr() == NULL) return 0; bufsize_t totalSize = getLdConfigDirSize(); if (this->isW81()) totalSize += this->getW81partSize(); return totalSize; }
void Settings::restore(Settings* originalSettings) { Globals::get().invalidateCallSites(); Settings*& p = getPtr(); delete p; p = originalSettings; }
extern "C" JNIEXPORT jlong JNICALL Java_io_lowla_lowladb_LDBObjectBuilder_finishBson(JNIEnv *env, jobject jThis) { CLowlaDBBson::ptr &ptr = getPtr(env, jThis); ptr->finish(); // We return a new smartpointer to the same Bson object so that the LDBObject can own its own smartpointer. CLowlaDBBson::ptr *answer = new CLowlaDBBson::ptr(ptr); return (jlong)answer; }
void BaseClient::_test(int id) { ByteArray req; MAKEREQBEGIN("test"); ADDPARAM("id", id); MAKEREQEND(req); request(req, boost::bind(&BaseClient::_onTest, getPtr(), _1, _2), NET_CMD_RPC, COMPRESS_DOUBLE_ZLIB); }
SecureBinaryData SecureBinaryData::operator+(SecureBinaryData & sbd2) const { SecureBinaryData out(getSize() + sbd2.getSize()); memcpy(out.getPtr(), getPtr(), getSize()); memcpy(out.getPtr()+getSize(), sbd2.getPtr(), sbd2.getSize()); out.lockData(); return out; }
// moves over the data into pixels, sets teh plane pointers into this pixels vector and sets the strides for the planes void YUV420PGrabber::assignFrame(size_t id, std::vector<uint8_t>& pixels, uint8_t* planes[], uint32_t* strides) { pixels.assign(getPtr(), getPtr() + getNumBytes()); YUV420PSize size = getSize(id); planes[0] = &pixels[size.y_offset]; planes[1] = &pixels[size.u_offset]; planes[2] = &pixels[size.v_offset]; strides[0] = size.y_stride; strides[1] = size.u_stride; strides[2] = size.v_stride; }
void Settings::reset() { Globals::get().invalidateCallSites(); Settings*& p = getPtr(); delete p; p = new Settings(); }
MWWorld::Ptr MWWorld::Cells::getPtr (const std::string& name) { // First check the cache for (std::vector<std::pair<std::string, CellStore *> >::iterator iter (mIdCache.begin()); iter!=mIdCache.end(); ++iter) if (iter->first==name && iter->second) { Ptr ptr = getPtr (name, *iter->second); if (!ptr.isEmpty()) return ptr; } // Then check cells that are already listed // Search in reverse, this is a workaround for an ambiguous chargen_plank reference in the vanilla game. // there is one at -22,16 and one at -2,-9, the latter should be used. for (std::map<std::pair<int, int>, CellStore>::reverse_iterator iter = mExteriors.rbegin(); iter!=mExteriors.rend(); ++iter) { Ptr ptr = getPtrAndCache (name, iter->second); if (!ptr.isEmpty()) return ptr; } for (std::map<std::string, CellStore>::iterator iter = mInteriors.begin(); iter!=mInteriors.end(); ++iter) { Ptr ptr = getPtrAndCache (name, iter->second); if (!ptr.isEmpty()) return ptr; } // Now try the other cells const MWWorld::Store<ESM::Cell> &cells = mStore.get<ESM::Cell>(); MWWorld::Store<ESM::Cell>::iterator iter; for (iter = cells.extBegin(); iter != cells.extEnd(); ++iter) { CellStore *cellStore = getCellStore (&(*iter)); Ptr ptr = getPtrAndCache (name, *cellStore); if (!ptr.isEmpty()) return ptr; } for (iter = cells.intBegin(); iter != cells.intEnd(); ++iter) { CellStore *cellStore = getCellStore (&(*iter)); Ptr ptr = getPtrAndCache (name, *cellStore); if (!ptr.isEmpty()) return ptr; } // giving up return Ptr(); }
MWWorld::Ptr MWWorld::Cells::getPtr (const std::string& name) { // First check cells that are already listed for (std::map<std::string, Ptr::CellStore>::iterator iter = mInteriors.begin(); iter!=mInteriors.end(); ++iter) { Ptr ptr = getPtr (name, iter->second); if (!ptr.isEmpty()) return ptr; } for (std::map<std::pair<int, int>, Ptr::CellStore>::iterator iter = mExteriors.begin(); iter!=mExteriors.end(); ++iter) { Ptr ptr = getPtr (name, iter->second); if (!ptr.isEmpty()) return ptr; } // Now try the other cells for (ESMS::CellList::IntCells::const_iterator iter = mStore.cells.intCells.begin(); iter!=mStore.cells.intCells.end(); ++iter) { Ptr::CellStore *cellStore = getCellStore (iter->second); Ptr ptr = getPtr (name, *cellStore); if (!ptr.isEmpty()) return ptr; } for (ESMS::CellList::ExtCells::const_iterator iter = mStore.cells.extCells.begin(); iter!=mStore.cells.extCells.end(); ++iter) { Ptr::CellStore *cellStore = getCellStore (iter->second); Ptr ptr = getPtr (name, *cellStore); if (!ptr.isEmpty()) return ptr; } // giving up return Ptr(); }
T* getPtr(const std::string& key) const { auto iter = m_map.find( key ); if (iter == m_map.end()) throw std::invalid_argument("Key not found:" + key); else { size_t index = iter->second; return getPtr(index); } }
extern "C" JNIEXPORT jobject JNICALL Java_io_lowla_lowladb_LDBObjectBuilder_appendBool(JNIEnv *env, jobject jThis, jstring str, jboolean value) { CLowlaDBBson::ptr &ptr = getPtr(env, jThis); const char *szUtf = env->GetStringUTFChars(str, NULL); ptr->appendBool(szUtf, value); env->ReleaseStringUTFChars(str, szUtf); return jThis; }
extern "C" JNIEXPORT jobject JNICALL Java_io_lowla_lowladb_LDBObjectBuilder_startArray(JNIEnv *env, jobject jThis, jstring str) { CLowlaDBBson::ptr &ptr = getPtr(env, jThis); const char *szUtf = env->GetStringUTFChars(str, NULL); ptr->startArray(szUtf); env->ReleaseStringUTFChars(str, szUtf); return jThis; }
ImagePtr ImageManager::create(const std::string& name, IResourceLoader* loader){ if (exists(name)) { FL_WARN(_log, LMsg("ImageManager::create(std::string, IResourceLoader* loader) - ") << "Resource name " << name << " was previously created. Returning original Image..."); return getPtr(name); } Image* ptr = RenderBackend::instance()->createImage(name, loader); return add(ptr); }
template <class T, typename S> T* ArrayBase<T,S>::add(const T* ptr, S size) { S oldSize = getSize(); resize(oldSize + size); T* slot = getPtr(oldSize); if (ptr) copy(slot, ptr, size); return slot; }
void BaseClient::_stat(vector<DataEventRaw>& UpdateEvents, vector<DataEventRaw>& CreditEvents) { ByteArray req; MAKEREQBEGIN("stat"); ADDPARAM("UploadEvents", UpdateEvents); ADDPARAM("CreditEvents", CreditEvents); MAKEREQEND(req); request(req, boost::bind(&BaseClient::_onStat, getPtr(), _1, _2), NET_CMD_RPC, COMPRESS_DOUBLE_ZLIB); }
int BinaryNode::getAsString(QoreString &str, int foff, ExceptionSink *xsink) const { if (foff == FMT_YAML_SHORT) { QoreString bstr(this, -1); str.sprintf("!!binary %s", bstr.getBuffer()); } else str.sprintf("binary object %p ("QSD" byte%s)", getPtr(), size(), size() == 1 ? "" : "s"); return 0; }
Settings* Settings::saveAndReset() { Globals::get().invalidateCallSites(); Settings*& p = getPtr(); Settings* originalSettings = p; p = new Settings(); return originalSettings; }
MWWorld::Ptr MWWorld::Cells::getPtr (const std::string& name) { // First check the cache for (std::vector<std::pair<std::string, Ptr::CellStore *> >::iterator iter (mIdCache.begin()); iter!=mIdCache.end(); ++iter) if (iter->first==name && iter->second) { Ptr ptr = getPtr (name, *iter->second); if (!ptr.isEmpty()) return ptr; } // Then check cells that are already listed for (std::map<std::pair<int, int>, Ptr::CellStore>::iterator iter = mExteriors.begin(); iter!=mExteriors.end(); ++iter) { Ptr ptr = getPtrAndCache (name, iter->second); if (!ptr.isEmpty()) return ptr; } for (std::map<std::string, Ptr::CellStore>::iterator iter = mInteriors.begin(); iter!=mInteriors.end(); ++iter) { Ptr ptr = getPtrAndCache (name, iter->second); if (!ptr.isEmpty()) return ptr; } // Now try the other cells const MWWorld::Store<ESM::Cell> &cells = mStore.get<ESM::Cell>(); MWWorld::Store<ESM::Cell>::iterator iter; for (iter = cells.extBegin(); iter != cells.extEnd(); ++iter) { Ptr::CellStore *cellStore = getCellStore (&(*iter)); Ptr ptr = getPtrAndCache (name, *cellStore); if (!ptr.isEmpty()) return ptr; } for (iter = cells.intBegin(); iter != cells.intEnd(); ++iter) { Ptr::CellStore *cellStore = getCellStore (&(*iter)); Ptr ptr = getPtrAndCache (name, *cellStore); if (!ptr.isEmpty()) return ptr; } // giving up return Ptr(); }
LUX_INLINE operator T*(){ #ifdef _DEBUG T* ptr; booln res = getSafe(&ptr); LUX_ASSERT(res); return ptr; #else return getPtr(); #endif }
Tx TxRef::getCopy(void) const { assert(isInitialized_); Tx returnTx; returnTx.unserialize(getPtr()); returnTx.thisHash_ = thisHash_; returnTx.nBytes_ = nBytes_; returnTx.headerRefPtr_ = headerPtr_; return returnTx; }
bool QSpotifySearch::event(QEvent *e) { if (e->type() == QEvent::User) { auto ev = static_cast<SearchResultEvent*>(e); if (ev) { if (auto search = ev->getSearch()) { g_mutex.lock(); bool is_current = (m_sp_search == search); g_mutex.unlock(); if (sp_search_error(search) == SP_ERROR_OK && is_current) { if(ev->getPtr()) { switch(ev->getPtr()->mType) { case Albums: populateAlbums(search); break; case Artists: populateArtists(search); break; case Playlists: populatePlaylists(search); break; case Tracks: populateTracks(search); break; default: populateResults(search); break; } } else populateResults(search); } clearSearch(search); } } setBusy(false); emit resultsChanged(); e->accept(); return true; } return QObject::event(e); }
void serialize(void *data, ValueP val) { Value *valP = val.get(); if (PointerValue *ptrVal = dynamic_cast<PointerValue *>(valP)) { void **pdata = static_cast<void **>(data); ValueP target = ptrVal->getTarget(); if (target.get() == NULL) { *pdata = NULL; } else { *pdata = getPtr(target); } } else if (CharValue *charVal = dynamic_cast<CharValue *>(valP)) { char *pdata = static_cast<char *>(data); *pdata = charVal->getConcreteValueChar(); } else if (IntValue *intVal = dynamic_cast<IntValue *>(valP)) { char *pdata = static_cast<char *>(data); *pdata = intVal->getConcreteValueInt(); } // TODO: other primtypes else if (BaseCompoundValue *compVal = dynamic_cast<BaseCompoundValue *>(valP)) { struct SerializeField : FieldVisitor { RoseFFI *ffi; void *data; SerializeField(RoseFFI *ffi, void *data) : ffi(ffi), data(data) {} void operator()(long offset, ValueP prim) { if (offset >= 0) { void *dataOfs = static_cast<void *>(static_cast<char *>(data) + offset); ffi->serialize(dataOfs, prim); } } }; SerializeField sf(this, data); compVal->forEachPrim(sf); } else { throw InterpError(string("Unable to serialize a ") + typeid(*valP).name()); } }
//-------------------------------------------------------------------------- static bool find_impdir(area_t *impdir) { impdir->startEA = impdir->endEA = 0; uint32 ea32 = uint32(an_imported_func); for ( ea_t pos = curmod.startEA; pos <= curmod.endEA && (pos = bin_search(pos, curmod.endEA, (uchar *)&ea32, NULL, 4, BIN_SEARCH_FORWARD, BIN_SEARCH_NOBREAK|BIN_SEARCH_CASE)) != BADADDR; pos += sizeof(DWORD) ) { // skip unaligned matches if ( (pos & 3) != 0 ) continue; // cool, we found a pointer to an imported function // now try to determine the impdir bounds ea_t bounds[2] = {pos, pos}; for ( int k=0; k < 2; k++ ) { ea_t ea = pos; while ( true ) { if ( k == 1 ) ea += ptrSz; else ea -= ptrSz; ea_t func = is_9x ? win9x_find_thunk(ea) : getPtr(ea); if ( func == 0 ) continue; if ( !isEnabled(func) ) break; if ( curmod.contains(func) ) break; module_info_t mi; if ( !find_module(func, &mi) ) break; bounds[k] = ea; } } bounds[1] += ptrSz; asize_t bsize = bounds[1] - bounds[0]; if ( bsize > impdir->size() ) *impdir = area_t(bounds[0], bounds[1]); } return impdir->startEA != 0; }
void Function1(void) { static unsigned flag; static int *p = 0; if (!flag) { flag = 1; p = getPtr(); } int m = *p; // no-warning: p is never null. m++; Function2(); }
void BitcoinNetAddr::deserialize(BinaryRefReader brr) { if (brr.getSize() != NETADDR_NOTIME) throw BitcoinMessageDeserError("invalid netaddr size"); services_ = brr.get_uint64_t(); auto ipv6bdr = brr.get_BinaryDataRef(16); memcpy(&ipV6_, ipv6bdr.getPtr(), 16); port_ = brr.get_uint16_t(); }
void call(void (*fnPtr)(), const vector<ValueP> &args) { void **argPtrs = new void*[args.size()]; for (size_t i = 0; i < args.size(); ++i) { argPtrs[i] = getPtr(args[i]); } char dummy[256]; // TODO: get return value (from here?) ffi_call(&cif, fnPtr, dummy, argPtrs); delete[] argPtrs; }