int all_tests(void)
{
_run(insert_item_test);
_run(remove_item_test);
return 0;
}
void RLRequest::run()
{
if(name=="multi"){
_run();
return;
}
if(name=="exec"||name=="discard"){
#ifdef DEBUG
printf("Subrequest Number in this Transaction:%ld\n",
connection->transaction->subrequest.size());
#endif
if(connection->transaction){
_run();
}else{
connection->write_error("ERR EXEC/DISCARD without MULTI");
}
return;
}
if(connection->transaction){
connection->transaction->subrequest.push_back(this);
connection->current_request=NULL;
connection->write_status("QUEUED");
}else{
_run();
}
}
int ihome_command_init(output_fun_t output)
{
#define _run(fun) do{ if(fun != 0) return -1; } while(0)
_run(command_init(&ihome_command_head));
command_set_output(ihome_command_head, output, NULL);
_run(ihome_command_install());
return 0;
#undef _run
}
int all_tests(void)
{
_run(move_south_test);
_run(move_east_test);
_run(move_west_test);
_run(move_north_test);
_run(move_northwest_test);
return 0;
}
static modulenode_t *_run(moduletree_t *modtree, modulenode_t *modnode)
{
int next = 1;
modulenode_t **child;
int i;
switch (modnode->type) {
case MNTYPE_HEAD:
case MNTYPE_MODULE:
module_process(modnode);
break;
case MNTYPE_FILTER:
filter_process(modnode);
break;
case MNTYPE_MERGER:
if (!allset(modnode)) {
next = 0;
break;
}
merge_process(modnode);
break;
}
if (next == 1) {
for (i = 0; i < modnode->childsize; ++i) {
_run(modtree, modnode->child[i]);
}
}
}
void TransientAreasSegmentationModuleImpl::run(InputArray inputToProcess, const int channelIndex)
{
cv::Mat inputToSegment=inputToProcess.getMat();
// preliminary basic error check
if ( (inputToSegment.rows*inputToSegment.cols) != (int)_inputToSegment.size())
{
std::stringstream errorMsg;
errorMsg<<"Input matrix size does not match instance buffers setup !"
<<"\n\t Input size is : "<<inputToSegment.rows*inputToSegment.cols
<<"\n\t v.s. internalBuffer size is : "<< _inputToSegment.size();
throw cv::Exception(-1, errorMsg.str().c_str(), "SegmentationModule::run", "SegmentationModule.cpp", 0);
}
if (channelIndex >= inputToSegment.channels())
{
std::stringstream errorMsg;
errorMsg<<"Cannot access channel index "<<channelIndex<<" on the input matrix with channels quantity = "<<inputToSegment.channels();
throw cv::Exception(-1, errorMsg.str().c_str(), "SegmentationModule::run", "SegmentationModule.cpp", 0);
}
// create a cv::Mat header for the input valarray
// convert to float AND fill the valarray buffer
typedef float T; // define here the target pixel format, here, float
const int dsttype = cv::DataType<T>::depth; // output buffer is float format
cv::Mat dst(inputToSegment.size(), dsttype, &_inputToSegment[0]);
inputToSegment.convertTo(dst, dsttype);
//cv::imshow("Mask",dst);
//cv::waitKey();
// call the low level method
_run(_inputToSegment, channelIndex);
}
trex_rpc_cmd_rc_e
TrexRpcCommand::run(const Json::Value ¶ms, Json::Value &result) {
trex_rpc_cmd_rc_e rc;
/* the internal run can throw a parser error / other error */
try {
/* verify API handler is correct (version mismatch) */
if ( (m_api_type != APIClass::API_CLASS_TYPE_NO_API) && !g_test_override_api ) {
verify_api_handler(params, result);
}
/* verify ownership */
if (m_needs_ownership && !g_test_override_ownership) {
verify_ownership(params, result);
}
check_param_count(params, m_param_count, result);
/* run the command itself*/
rc = _run(params, result);
} catch (TrexRpcCommandException &e) {
return e.get_rc();
}
return (rc);
}
//-----------------------------------------------------------------------
void UnicodeFileSystemArchive::FileFinder::run(const WString& _wpattern, bool _recursive, bool _dirs,
StringVector* _simpleList, FileInfoList* _detailList)
{
mRecursive = _recursive;
mDirs = _dirs;
mSimpleList = _simpleList;
mDetailList = _detailList;
// pattern can contain a directory name, separate it from mask
size_t pos1 = _wpattern.rfind ('/');
size_t pos2 = _wpattern.rfind ('\\');
if (pos1 == _wpattern.npos || ((pos2 != _wpattern.npos) && (pos1 < pos2)))
pos1 = pos2;
WString wdir, wmask;
if(pos1 == String::npos)
{
wmask = _wpattern;
}
else
{
wdir = _wpattern.substr(0, pos1 + 1);
wmask = _wpattern.substr(pos1 + 1);
}
if(wmask == L"*")
wmask.clear();
String mask = mArchive->toString(wmask);
String dir = mArchive->toString(wdir);
WString wFullDir = mArchive->getFullPath(wdir);
_run(dir, wFullDir);
}
w_rc_t rvp_t::run()
{
w_rc_t e = _run();
notify_partitions();
giveback();
return (e);
}
static void
_run (void (*hook) (const struct trie_node_s *), struct trie_node_s **p)
{
for (; *p ;++p) {
if ((*p)->u) hook (*p);
if ((*p)->next) _run (hook, (*p)->next);
}
}
bool greedy::run(Model& m,std::vector<Node*>& solution){
begin();
isSolved = _run(m,solution);
end();
return isSolved;
}
void modtree_run(moduletree_t *modtree)
{
modulenode_t head;
modulenode_t *tail;
_setheadnode(modtree, &head);
tail = _run(modtree, modtree->root);
_freeheadnode(&head);
modtree->out = tail->out;
}
virtual bool run(OperationContext* txn, const string& a, BSONObj& b, int e, string& errmsg, BSONObjBuilder& c, bool d) {
try {
rwlock_try_write lk(mutex);
return _run(txn, a,b,e,errmsg,c,d);
}
catch(rwlock_try_write::exception&) { }
errmsg = "a replSetReconfig is already in progress";
return false;
}
void AsyncTask::run()
{
_prerun();
log::messageln("AsyncTask::run %d - %s", getObjectID(), typeid(*this).name());
OX_ASSERT(_status == status_not_started);
_status = status_inprogress;
if (!syncEvent(runID))
_run();
}
void Transition::run(Flow* f, spScene current, spScene next, bool back)
{
_flow = f;
_current = current;
_next = next;
_done = false;
_attach(current, next, back);
_run(current, next, back);
}
void run() {
_run( 123, 456 );
_run( 0xdeadbeef, 0xcafecafe );
_run( 0, 0 );
_run( 99999999, 999 );
_run( 0xFFFFFFFF, 1 );
_run( 0xFFFFFFFF, 0 );
_run( 0xFFFFFFFF, 0xFFFFFFFF );
}
int _t_run(test_t tests[], int len) {
int i;
int ret;
for (i = 0; i < len; i++) {
if ((ret = _run(&tests[i])) != 0) {
return ret;
}
}
return 0;
}
static void *
_schedule(void *arg) {
struct scheduler *s = arg;
_set_scheduler(s);
for (;;) {
assert(_running_coroutine() == NULL);
struct coroutine *co = _next_coroutine(s);
assert(co->sched == s);
_run(co);
}
return NULL;
}
INT32 migExport::run( INT32 &total )
{
INT32 rc = SDB_OK ;
rc = _run( _pMigArg->pCSName, _pMigArg->pCLName, total ) ;
if ( rc )
{
goto error ;
}
done:
return rc ;
error:
goto done ;
}
Future<void> OplogApplier::startup() {
auto pf = makePromiseFuture<void>();
auto callback =
[ this, promise = pf.promise.share() ](const CallbackArgs& args) mutable noexcept {
invariant(args.status);
log() << "Starting oplog application";
_run(_oplogBuffer);
log() << "Finished oplog application";
promise.setWith([] {});
};
invariant(_executor->scheduleWork(callback).getStatus());
return std::move(pf.future);
}
void* /*NAME*/_proc(void * p)
{
// Get parameters from the main thread
struct /*NAME*/_struct params = *((struct /*NAME*/_struct *) p);
// Unblock the main thread
pthread_mutex_lock(params.lock);
pthread_cond_signal(params.cv);
pthread_mutex_unlock(params.lock);
// Run the function
///*NAME*/_run(params._instance, params.esums_device);
/*NAME*/_run(/*ACTUAL_PARAMS*/);
}
INT32 cPmdDaemon::run( INT32 argc, CHAR **argv, BOOLEAN asProc )
{
INT32 rc = SDB_OK ;
#if defined (_WINDOWS)
if ( asProc )
{
rc = _run( argc, argv ) ;
}
else
{
rc = pmdWinstartService( _procName, &cPmdDaemon::_run ) ;
}
#elif defined (_LINUX)
ossEnableNameChanges ( argc, argv ) ;
ossRenameProcess ( _procName ) ;
rc = _run( argc, argv ) ;
#endif
PD_RC_CHECK( rc, PDERROR, "Failed to start the service(rc=%d)", rc ) ;
done:
return rc;
error:
goto done;
}
void BrpcCtrlInterface::run()
{
if (! sipDispatcher) {
ERROR("SIP dispatcher hook not set.\n");
return;
}
if (! initCallbacks()) {
ERROR("failed to init BINRPC call back system\n");
return;
}
if(rpcCheck())
serResync();
_run();
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)regs->ecx, (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)regs->ecx, (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time(regs->ebx);
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)regs->edx);
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((void(*)(char*)) regs->ebx, (char*) regs->ecx, regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo(regs->ebx, (size_t)regs->ecx);
break;
}
}
trex_rpc_cmd_rc_e
TrexRpcCommand::run(const Json::Value ¶ms, Json::Value &result) {
trex_rpc_cmd_rc_e rc;
/* the internal run can throw a parser error / other error */
try {
check_param_count(params, m_param_count, result);
if (m_needs_ownership && !g_test_override_ownership) {
verify_ownership(params, result);
}
/* run the command itself*/
rc = _run(params, result);
} catch (TrexRpcCommandException &e) {
return e.get_rc();
}
return (rc);
}
void AsyncTask::_threadCB(const ThreadDispatcher::message& msg)
{
switch (msg.msgid)
{
case successID:
_complete();
break;
case errorID:
_error();
break;
case runID:
_run();
break;
case customID:
_custom(msg);
break;
default:
break;
}
if (msg.msgid != customID)
releaseRef();
}
pid_t Runnable::run(){
// esto se asegura que al crear un runnable se inicializan sus estructuras
/// podemos asumir que no existe un archivo con el nombre 'runnableTempLockFile' (sino cambiar, pq al final lo borro)
LockFile lock("runnableTempLockFile");
lock.tomarLock();
this->init();
lock.liberarLock();
unlink("runnableTempLockFile");
pid_t pid = fork();
if(pid == -1){
child = false;
perror("Runnable error: ");
}
// en el hijo corro la funcion _run y termino
if(pid == 0){
_run();
exit(0);
} else {
return pid;
}
// en el padre sigo como si nada
}
INT32 migExport::_run( const CHAR *pCSName, const CHAR *pCLName, INT32 &total )
{
INT32 rc = SDB_OK ;
const CHAR *pTemp = NULL ;
bson obj ;
bson_iterator it ;
bson_type type ;
bson_init( &obj ) ;
if ( ( pCSName == NULL && pCLName == NULL ) ||
( pCSName == NULL && pCLName != NULL ) )
{
//never cs cl
rc = _getCSList() ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get collection space list, rc = %d",
rc ) ;
goto error ;
}
while( TRUE )
{
rc = sdbNext( _gCSList, &obj ) ;
if ( rc )
{
if ( SDB_DMS_EOC != rc )
{
PD_LOG ( PDERROR, "Failed to get collection space list, rc = %d",
rc ) ;
goto error ;
}
else
{
rc = SDB_OK ;
goto done ;
}
}
type = bson_find( &it, &obj, "Name" ) ;
if ( type != BSON_STRING )
{
rc = SDB_SYS ;
PD_LOG ( PDERROR, "List collection space does not string, rc = %d",
rc ) ;
goto error ;
}
pTemp = bson_iterator_string( &it ) ;
rc = _run( pTemp, pCLName, total ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Faild to call _run, rc = %d", rc ) ;
goto error ;
}
}
}
else if ( pCSName != NULL && pCLName == NULL )
{
//cs
rc = _getCLList() ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get collection list, rc = %d",
rc ) ;
goto error ;
}
while ( TRUE )
{
rc = sdbNext( _gCLList, &obj ) ;
if ( rc )
{
if ( SDB_DMS_EOC != rc )
{
PD_LOG ( PDERROR, "Failed to get collection list, rc = %d",
rc ) ;
goto error ;
}
else
{
rc = SDB_OK ;
goto done ;
}
}
type = bson_find( &it, &obj, "Name" ) ;
if ( type != BSON_STRING )
{
rc = SDB_SYS ;
PD_LOG ( PDERROR, "List collection does not string, rc = %d",
rc ) ;
goto error ;
}
pTemp = bson_iterator_string( &it ) ;
rc = _run( pCSName, pTemp, total ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Faild to call _run, rc = %d", rc ) ;
goto error ;
}
}
}
else
{
//cs and cl
rc = _exportCL( pCSName, pCLName, total ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Faild to call _export, rc = %d", rc ) ;
goto error ;
}
}
done:
bson_destroy ( &obj ) ;
return rc ;
error:
goto done ;
}
//-----------------------------------------------------------------------
void UnicodeFileSystemArchive::FileFinder::_run(const String& _dir, const WString& _wFullDir)
{
wchar_t wFindPattern[MAX_PATH];
wcscpy(wFindPattern, _wFullDir.c_str());
wcscpy(&wFindPattern[_wFullDir.length()], L"*");
long lHandle;
struct _wfinddata_t wTagData;
lHandle = _wfindfirst(wFindPattern, &wTagData);
String tagDataName;
String dir2;
WString wFullDir2;
while(lHandle != -1)
{
bool isSubDir = ((wTagData.attrib & _A_SUBDIR) != 0);
bool isHidden = ((wTagData.attrib & _A_HIDDEN) != 0);
if((!mIgnoreHidden || !isHidden)
&& !isReservedDir(wTagData.name)
&& ((isSubDir == mDirs) || (isSubDir && mRecursive)))
{
tagDataName = mArchive->toString(wTagData.name);
if(isSubDir == mDirs
&& (mMask.empty() || StrUtil::match(tagDataName, mMask)))
{
if (mSimpleList)
{
mSimpleList->push_back(String());
String& back = mSimpleList->back();
back = _dir;
back += tagDataName;
}
else if (mDetailList)
{
FileInfo fi;
fi.archive = mArchive;
fi.filename = _dir;
fi.filename += tagDataName;
fi.basename = tagDataName;
fi.path = _dir;
fi.compressedSize = wTagData.size;
fi.uncompressedSize = wTagData.size;
mDetailList->push_back(fi);
}
}
if(isSubDir && mRecursive)
{
dir2 = _dir;
dir2 += tagDataName;
dir2 += '/';
wFullDir2 = _wFullDir;
wFullDir2 += wTagData.name;
wFullDir2 += '/';
_run(dir2, wFullDir2);
}
}
if(_wfindnext( lHandle, &wTagData ) == -1)
{
_findclose(lHandle);
lHandle = -1;
}
}
}
void
path_parser_foreach (struct path_parser_s *self,
void (*hook) (const struct trie_node_s *))
{
if (self->roots) _run (hook, self->roots);
}
