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