void SshRemoteProcessRunner::runInTerminal(const QByteArray &command,
const SshPseudoTerminal &terminal, const SshConnectionParameters &sshParams)
{
d->m_terminal = terminal;
d->m_runInTerminal = true;
runInternal(command, sshParams);
}
template <class SshConnection> void MaemoSshThread<SshConnection>::run()
{
if (m_stopRequested)
return;
if (!runInternal())
m_error = m_connection->error();
}
bool ZLOptionsDialog::run() {
selectTab(ZLResourceKey(TabOption.value()));
bool code = runInternal();
if (code) {
accept();
}
TabOption.setValue(selectedTabKey());
return code;
}
//-----------------------------------------------------------------------------
bool CNewFileSelector::run (CBaseObject* delegate)
{
if (delegate == 0)
{
#if DEBUG
DebugPrint ("You need to specify a delegate in CNewFileSelector::run (CBaseObject* delegate, void* parentWindow)\n");
#endif
return false;
}
return runInternal (delegate);
}
vector<cpx> cl_fft<cpx>::run(const vector<cpx> &input)
{
cl_event upload_unmap_evt, start_evt, download_map_evt, *kernel_evts = new cl_event[launches.size()];
cl_int err;
// Upload
cl_float2 *input_buffer = (cl_float2*)clEnqueueMapBuffer(command_queue,
v_samples,
CL_TRUE,
CL_MAP_WRITE,
0,
samplesMemSize,
0,
NULL,
NULL,
&err);
CL_CHECK_ERR("clEnqueueMapBuffer", err);
for (int i = 0; i < samplesPerRun; i++)
{
input_buffer[i].x = real(input[i]);
input_buffer[i].y = imag(input[i]);
}
CL_CHECK_ERR("clEnqueueUnmapMemObject", clEnqueueUnmapMemObject(command_queue, v_samples, input_buffer, 0, NULL, &upload_unmap_evt));
// Calcola la FFT
cl_mem v_out = runInternal(v_samples, &start_evt, kernel_evts);
// Download
vector<cpx> result(samplesPerRun);
cl_float2 *output_buffer = (cl_float2*)clEnqueueMapBuffer(command_queue,
v_out,
CL_TRUE,
CL_MAP_READ,
0,
tmpMemSize,
1,
&kernel_evts[launches.size() - 1],
&download_map_evt,
&err);
CL_CHECK_ERR("clEnqueueMapBuffer", err);
for (int i = 0; i < samplesPerRun; i++)
result[i] = cpx(output_buffer[i].x, output_buffer[i].y);
CL_CHECK_ERR("clEnqueueUnmapMemObject", clEnqueueUnmapMemObject(command_queue, v_out, output_buffer, 0, NULL, NULL));
printStatsAndReleaseEvents(upload_unmap_evt, start_evt, kernel_evts, download_map_evt);
delete[] kernel_evts;
return result;
}
void Test::run(TestResult &result) {
try {
runInternal();
} catch (TestFailException *e) {
result.addFailure(Failure(*e, name_));
} catch (std::exception &e) {
std::stringstream ss;
ss << "unexpected exception " << e.what();
result.addFailure(Failure(ss.str(), name_));
} catch (...) {
result.addFailure(Failure("unknown exception", name_));
}
}
void Operation::add() {
backup();
runInternal();
if ( addInternal() ) {
list.push(this);
createParamUi();
button=new RadioButton(names[type],tips[type],historyCbk,this);
button->setGroup(0);
history->addWidget(button);
button->select();
currentOp=this;
} else delete this;
}
bool ZLDesktopOpenFileDialog::run() {
if (myXOption.value() != INVALID_VALUE &&
myYOption.value() != INVALID_VALUE) {
setPosition(myXOption.value(), myYOption.value());
}
if (myWidthOption.value() != INVALID_VALUE &&
myHeightOption.value() != INVALID_VALUE) {
setSize(myWidthOption.value(), myHeightOption.value());
}
bool result = runInternal();
myWidthOption.setValue(width());
myHeightOption.setValue(height());
myXOption.setValue(x());
myYOption.setValue(y());
return result;
}
bool run(const string& dbname, BSONObj& cmdObj, int, string& errmsg,
BSONObjBuilder& result, bool fromRepl) {
string ns = dbname + "." + cmdObj.firstElement().valuestrsafe();
const NamespaceDetails* nsd = nsdetails(ns.c_str());
if (!cmdLine.quiet) {
tlog() << "CMD: indexStats " << ns << endl;
}
if (!nsd) {
errmsg = "ns not found";
return false;
}
IndexStatsParams params;
// { index: _index_name }
BSONElement indexName = cmdObj["index"];
if (!indexName.ok() || indexName.type() != String) {
errmsg = "an index name is required, use {index: \"indexname\"}";
return false;
}
params.indexName = indexName.String();
BSONElement expandNodes = cmdObj["expandNodes"];
if (expandNodes.ok()) {
if (expandNodes.type() != mongo::Array) {
errmsg = "expandNodes must be an array of numbers";
return false;
}
vector<BSONElement> arr = expandNodes.Array();
for (vector<BSONElement>::const_iterator it = arr.begin(); it != arr.end(); ++it) {
if (!it->isNumber()) {
errmsg = "expandNodes must be an array of numbers";
return false;
}
params.expandNodes.push_back(int(it->Number()));
}
}
BSONObjBuilder resultBuilder;
if (!runInternal(nsd, params, errmsg, resultBuilder))
return false;
result.appendElements(resultBuilder.obj());
return true;
}
int LDExporter::runInternal(void)
{
char *outputType = stringForKey("OutputType", NULL, false);
int retValue;
LDExporter *pExporter = NULL;
if (outputType == NULL)
{
outputType = stringForKey("OT", "POV", false);
}
if (strcasecmp(outputType, "POV") == 0)
{
pExporter = new LDPovExporter;
}
retValue = runInternal(pExporter);
delete[] outputType;
TCObject::release(pExporter);
return retValue;
}
void run(){
int m;
int intersize = sizeof(inter)/sizeof(char *);
int in;
in = 0;
if(par[0] == NULL){
printf("No command entered");
}
for(m = 0; m < intersize; m++){
if(strcmp(par[0], inter[m]) == 0){
in = 1;
runInternal(m);
}
}
if(in == 0) executeCMD();
memset(par,0,sizeof(par));
}
void irrgamePlayerStub::run(irrgameApp* application)
{
//TODO: run app in other thread
//start events handler
UserEventsHandler->startEventProcess();
io::IReadFile* file =
io::SharedFileSystem::getInstance().createReadFile(
"/Users/gregorytkach/workspace/irrgame_sdk/src/vendors/libpng/pngtest.png");
video::IImage* img = video::IImage::createImage(file);
video::ITexture* t =
new video::COpenGLTexture(img,
"/Users/gregorytkach/workspace/irrgame_sdk/src/vendors/libpng/pngbar.png",
0, VideoDriver);
while (runInternal())
{
utils::ITimer::tick();
events::SharedEventScheduler::getInstance().proceedNextRealTimeEvent();
VideoDriver->beginScene();
VideoDriver->draw2DImage(t, vector2di(50, 50),
recti(50, 50, 150, 150));
//scenemanager->drawAll();
VideoDriver->endScene();
}
//stop events handler
UserEventsHandler->stopEventProcess();
}
cl_mem cl_fft<T>::run(const cl_mem input, cl_event *out_finishEvent)
{
cl_event start_evt, *kernel_evts = new cl_event[launches.size()];
cl_mem v_out = runInternal(input, &start_evt, kernel_evts);
if (out_finishEvent)
{
*out_finishEvent = kernel_evts[launches.size() - 1];
CL_CHECK_ERR("clRetainEvent", clRetainEvent(*out_finishEvent));
}
#if 0
printStatsAndReleaseEvents(0, start_evt, kernel_evts, 0);
#else
CL_CHECK_ERR("clReleaseEvent", clRetainEvent(start_evt));
for (unsigned int i = 0; i < launches.size(); i++)
CL_CHECK_ERR("clReleaseEvent", clReleaseEvent(kernel_evts[i]));
#endif
delete[] kernel_evts;
return v_out;
}
void Operation::run() {
runInternal();
}
