void Aggregate::splitter() try {

    // Check if any of the Chunk is splittable
    while (!isComplete() && !hasFailed()) {
        RemoteData::Partial p = isSplittable();
        if(p == RemoteData::Partial::no)
            return;
        else if(p==RemoteData::Partial::yes)
            break;
        boost::this_thread::sleep(boost::posix_time::millisec(100));
    }

    // Loop while a bottleneck exists
    while (!isComplete() && !hasFailed()) {
        // Get the bottle neck and split
        if(activeChunks() < m_chunks && isSplitReady() ) {
            // NOTE: Removing this showed the synronization bug
            std::vector<Chunk*>::size_type bneck = bottleNeck();
            split(bneck);
            // Just sleep for a while
            boost::this_thread::sleep(boost::posix_time::millisec(1000));
        }
        boost::this_thread::sleep(boost::posix_time::millisec(100));
    }

} catch (ex::aggregator::NoBottleneck e) {
    // This isn't a bad thing, just signifies
    // that no further segmentation can occur.
    // It helps to get outside both of splitting
    // loops.
}
예제 #2
0
/**
*Receive messages from server about file locks status
*/
int handleLocks(int *socket,char *curr_file)
{
    char *buffer = malloc(32);
    memset(buffer,0,32);
    int read_size = 0,total_read = 0;
    while((read_size = recv(*socket , buffer+total_read, 32 , 0)) > 0) //Receive a message,of at least 32 bytes,from client 
    {
        total_read += read_size;
        if(isComplete(buffer,total_read))
            break;
    }
    if(checkRecvErrors(&read_size))
    {
        if(strcmp(buffer,"ok") == 0)    //acquired locked for file
        {
            printf("Acquired lock for file %s.\n",curr_file);
            free(buffer);
            return 1;
        }
        else if(strcmp(buffer,"locked") == 0)   //file is already locked by another client
        {
            while(1)
            {
                printf("File %s is locked.Waiting for unlock message..\n",curr_file);
                memset(buffer,0,32);
                total_read = 0;
                //client will block until server sends an unlock message
                while((read_size = recv(*socket , buffer+total_read, 32 , 0)) > 0) //Receive a message,of at least 32 bytes,from client 
                {
                    total_read += read_size;
                    if(isComplete(buffer,total_read))
                        break;
                }
                if(checkRecvErrors(&read_size))
                {
                    if(strcmp(buffer,"ok") == 0)
                    {
                        printf("File %s is now unlocked.\n",curr_file);
                        free(buffer);
                        return 1;
                    }
                }
            }
        }
        else if(strcmp(buffer,"unlocked") == 0) //timeout occurred,server will unlock the file
        {
            printf("WARNING!Server will unlock file %s.Maybe the file is too big or the connection too slow.Sync has stopped.\n",curr_file);
        }
    }
    free(buffer);
    return 0;
}
예제 #3
0
/////////////////////////////////////////////////////////////////////////////////
// Adds a NAT Port Mapping
// Params:
//		UPNPNAT_MAPPING *mapping  ->  Port Mapping Data
//			If mapping->externalPort is 0, then
//			mapping->externalPort gets the value of mapping->internalPort
//		bool tryRandom:
//			If If mapping->externalPort is in use, tries to find a free
//			random external port.
//
// Return:
//		UNAT_OK:
//			Successfull.
//		UNAT_EXTERNAL_PORT_IN_USE:
//			Error, you are trying to add a port mapping with an external port
//			in use.
//		UNAT_NOT_IN_LAN:
//			Error, you aren't in a LAN -> no router or firewall
//		UNAT_ERROR:
//			Error, use GetLastError() to get an error description.
/////////////////////////////////////////////////////////////////////////////////
MyUPnP::UPNPNAT_RETURN MyUPnP::AddNATPortMapping(UPNPNAT_MAPPING *mapping, bool tryRandom)
{
	CString	ProtoStr, Proto;

	if(!IsLANIP(GetLocalIP())){
		SetLastError(GetResString(IDS_UPNPSTATUS_NOTINLAN)); //zz_fly :: localize output
		return UNAT_NOT_IN_LAN;
	}
	
	if (!isComplete()) {
		Search();
		if (!isComplete()) {
			SetLastError(GetResString(IDS_UPNPSTATUS_ERROR)); //zz_fly :: localize output
			return UNAT_ERROR;
		}
	}

	if (mapping->protocol == UNAT_TCP){
		Proto = _T("TCP");
		ProtoStr = _T("TCP");
	}
	else {
		Proto = _T("UDP");
		ProtoStr = _T("UDP");
	}

	if(mapping->externalPort == 0)
		mapping->externalPort = mapping->internalPort;

	//WORD rndPort = mapping->externalPort;
	for (int retries = 200; retries>0; retries--) {
		CString Desc;
		Desc.Format(_T("eMule (%s) [%s: %u]"), mapping->description, ProtoStr, mapping->externalPort);

		if (addPortmap(mapping->externalPort, mapping->internalPort, GetLocalIPStr(), Desc, Proto)) {
			m_Mappings.AddTail(*mapping);
			SetLastError(GetResString(IDS_UPNPSTATUS_OK)); //zz_fly :: localize output
			return UNAT_OK;
		}

		if (!tryRandom) {
			SetLastError(GetResString(IDS_UPNPSTATUS_PORTINUSE)); //zz_fly :: localize output
			return UNAT_EXTERNAL_PORT_IN_USE;
		}

		mapping->externalPort = (WORD)(2049 + (65535 - 2049) * rand() / (RAND_MAX + 1));
	}

	SetLastError(GetResString(IDS_UPNPSTATUS_PORTINUSE2)); //zz_fly :: localize output
	return UNAT_EXTERNAL_PORT_IN_USE;
}
예제 #4
0
bool MyUPnP::GetDescription()
{
	if(!Valid())return false;
	CString post, host, addr;
	int port = 0;
	addr = NGetAddressFromUrl(m_description, post, host, port);
	if(addr.IsEmpty())return false;
	CString request = CString(_T("GET ")) + post + _T(" HTTP/1.1\r\nHOST: ") + host + _T("\r\nACCEPT-LANGUAGE: en\r\n\r\n");
	CString response;
	if (!SOAP_action(addr, (uint16)port, request, response)) return false;
	CString result;
	if (!parseHTTPResponse(response, result)) return false;

	m_friendlyname = getProperty(result, _T("friendlyName"));
	m_modelname = getProperty(result, _T("modelName"));
	m_baseurl = getProperty(result, _T("URLBase"));
	if(m_baseurl.IsEmpty())m_baseurl = CString(_T("http://")) + host + _T("/");
	if(m_baseurl[m_baseurl.GetLength() - 1]!='/')m_baseurl += _T("/");
	
	CString serviceType = _T("<serviceType>") + m_name + _T("</serviceType>");
	int pos = result.Find(serviceType);
	if (pos >= 0) {
		result.Delete(0, pos + serviceType.GetLength());
		pos = result.Find(_T("</service>"));
		if (pos >= 0) {
			result = result.Mid(0, pos);
			m_controlurl = getProperty(result, _T("controlURL"));
			if (!m_controlurl.IsEmpty() && m_controlurl[0] == '/') {
				m_controlurl = m_baseurl + m_controlurl.Mid(1);
			}
		}
	}

	return isComplete();
}
예제 #5
0
DWORD WINAPI AsyncSocket::recvHandler(void *_sock) {
#else
void *AsyncSocket::recvHandler(void *_sock) {
#endif
   static Buffer b;
   unsigned char buf[2048];  //read a large chunk, we'll be notified if there is more
   AsyncSocket *sock = (AsyncSocket*)_sock;

   while (sock->conn != INVALID_SOCKET) {
      int len = sock->recv(buf, sizeof(buf));
      if (len <= 0) {
#ifdef _WIN32
         //timeouts are okay
         if (WSAGetLastError() == WSAETIMEDOUT) {
            continue;
         }
#else
         //timeouts are okay
         if (errno == EAGAIN || errno == EWOULDBLOCK) {
            continue;
         }
#endif
//       assumption is that socket is borked and next send will fail also
//       maybe should close socket here at a minimum.
//       in any case thread is exiting
         break;
      }
      if (sock->d) {
         b.write(buf, len);   //append new data into static buffer
         while (isComplete(b)) {
            Buffer *data = new Buffer(b.get_buf() + sizeof(int), requiredSize(b) - sizeof(int));
            sock->drt->queueBuffer(data);
            shift(b);  //shift any remaining portions of the buffer to the front
         }
      }
   }
   return 0;
}

int send_all(Buffer &b) {
   if (comm) {
      return comm->sendAll(b);
   }
   return 0;
}

int send_data(Buffer &b) {
   if (comm) {
      return comm->send(b);
   }
   else {
      if (changeCache != NULL) {
//         msg("writing to change cache\n");
         changeCache->writeInt(b.size() + sizeof(int));
         *changeCache << b;
         return b.size();
      }
   }
   return 0;
}
예제 #6
0
bool Plan::tryRemoveContextAndCancelIfLast(Context& context)
{
    LockHolder locker(m_lock);

    if (!ASSERT_DISABLED) {
        // We allow the first completion task to not have a Context.
        for (unsigned i = 1; i < m_completionTasks.size(); ++i)
            ASSERT(m_completionTasks[i].first);
    }

    bool removedAnyTasks = false;
    m_completionTasks.removeAllMatching([&] (const std::pair<Context*, CompletionTask>& pair) {
        bool shouldRemove = pair.first == &context;
        removedAnyTasks |= shouldRemove;
        return shouldRemove;
    });

    if (!removedAnyTasks)
        return false;

    if (isComplete()) {
        // We trivially cancel anything that's completed.
        return true;
    }

    // FIXME: Make 0 index not so magical: https://bugs.webkit.org/show_bug.cgi?id=171395
    if (m_completionTasks.isEmpty() || (m_completionTasks.size() == 1 && !m_completionTasks[0].first)) {
        fail(locker, "WebAssembly Plan was cancelled. If you see this error message please file a bug at bugs.webkit.org!"_s);
        return true;
    }

    return false;
}
예제 #7
0
void CallTargetFinder<dsa>::print(llvm::raw_ostream &O, const Module *M) const
{
  O << "[* = incomplete] CS: func list\n";
  for (std::map<CallSite, std::vector<const Function*> >::const_iterator ii =
       IndMap.begin(),
         ee = IndMap.end(); ii != ee; ++ii) {

    if (ii->first.getCalledFunction())  //only print indirect
      continue;
    if(isa<Function>(ii->first.getCalledValue()->stripPointerCasts()))
      continue;
      if (!isComplete(ii->first)) {
        O << "* ";
        CallSite cs = ii->first;
        cs.getInstruction()->dump();
        O << cs.getInstruction()->getParent()->getParent()->getName().str() << " "
          << cs.getInstruction()->getName().str() << " ";
      }
      O << ii->first.getInstruction() << ":";
      for (std::vector<const Function*>::const_iterator i = ii->second.begin(),
             e = ii->second.end(); i != e; ++i) {
        O << " " << (*i)->getName().str();
      }
      O << "\n";
  }
}
예제 #8
0
void Plan::waitForCompletion()
{
    LockHolder locker(m_lock);
    if (!isComplete()) {
        m_completed.wait(m_lock);
    }
}
예제 #9
0
int main(int argc, char** argv) {

	FILE* fproblem = fopen(argv[1], "r");
	FILE* fsolution = fopen(argv[2], "r");

	if(fproblem == 0 || fsolution == 0) {
		printf("Error opening file\n");
		exit(1);
	}
	
	problem* prob = loadProblem(fproblem, fsolution);

	int* options = malloc(prob->size * sizeof(int));

	// Fill out the numbers which must appear in each house for this size
	for (int i = 1; i <= prob->size; ++i) {
		options[i - 1] = i;
	}

	if (!isValidSolution(prob, sqrt(prob->size), options)) errInvalidSol();
	else if (isComplete(prob)) printf("SOLVED\n");
	else printf("INCOMPLETE\n");
	
	freeProblem(prob);
}
 int countNodes(TreeNode* root) {
     int tmp = isComplete(root);
     if (tmp != -1) return tmp;
     int l = countNodes(root->left);
     int r = countNodes(root->right);
     return 1 + l + r;
 }
예제 #11
0
float64_t
PulseClusterer::getNominalFreq(int idx)
{
	if (!isComplete() || (idx < 0 || idx > (int) clusterList.size()))
		Fatal(666);
	return clusterList[idx]->sig.path.rfFreq;
}
예제 #12
0
bool WriteMail::sendStage()
{
    if (!isComplete()) {
        // The user must either complete the message, save as draft or explicitly cancel
        return false;
    }

    if (buildMail(true)) {
        if (largeAttachments()) {
            // Ensure this is intentional
            if (QMessageBox::question(qApp->activeWindow(),
                                      tr("Large attachments"),
                                      tr("The message has large attachments. Send now?"),
                                      QMessageBox::Yes | QMessageBox::No) == QMessageBox::No) {
                draft();
                QMessageBox::warning(qApp->activeWindow(),
                                     tr("Message saved"),
                                     tr("The message has been saved in the Drafts folder"),
                                     QMessageBox::Ok);
                return true;
            }
        }

        emit enqueueMail(mail);
    } else {
        qMailLog(Messaging) << "Unable to build mail for transmission!";
    }

    // Prevent double deletion of composer textedit that leads to crash on exit
    reset();
    close();

    return true;
}
예제 #13
0
	void setValue( const PropertyAccessor & pa, const Variant & data )
	{
		Key key;
		if (!createKey( pa, key ))
		{
			pa.setValue( data );
			return;
		}

		std::unique_ptr< ReflectedPropertyCommandArgument > args( new ReflectedPropertyCommandArgument );
		args->setContextId( key.first );
		args->setPath( key.second.c_str() );
		args->setValue( data );
		
		// Access is only on the main thread
		assert( std::this_thread::get_id() == commandManager_.ownerThreadId() );

		const auto commandId = getClassIdentifier< SetReflectedPropertyCommand >();
		const auto pArgsDefinition =
			pa.getDefinitionManager()->getDefinition< ReflectedPropertyCommandArgument >();
		ObjectHandle commandArgs( std::move( args ), pArgsDefinition );
		auto command = commandManager_.queueCommand( commandId, commandArgs );

		// Queuing may cause it to execute straight away
		// Based on the thread affinity of SetReflectedPropertyCommand
		if (!command->isComplete())
		{
			commands_.emplace( std::pair< Key, CommandInstancePtr >( key, command ) );
		}
	}
예제 #14
0
int recvRequests(int *socket,char **buffer,int *length)
{
	int read_size=0,total_read=0;
	while((read_size = recv(*socket , *buffer+total_read, *length/2 , 0)) > 0) //Receive a message,of at least buffer/2 bytes,from client 
	{
		total_read += read_size;
		if(total_read + (*length/2) > *length) //if next read will (probably) cause an overflow,we should double our buffer's size
		{
			*length *=2;
			char *tmp_ptr = realloc(*buffer, *length);
			if(tmp_ptr == NULL) //cannot realloc memory
			{
				fprintf(stderr,"realloc failed to allocate %d bytes of memory.Server will exit\n",*length);
                free(buffer);
				return 0;
			}
            memset(tmp_ptr+total_read,0,*length-total_read);
			*buffer = tmp_ptr;
		}
		if(isComplete(*buffer,total_read))
			break;
	}
    if(checkRecvErrors(&read_size))
    {
        if(*buffer[0] == 0)  //First char of buffer is NULL,that means all files are up to date (server only sent EOT char)
        {
            printf("All files are up to date\n");
        }
        return 1;
    }
    return 0;
}
 void encodeTail(std::string& encoding, const std::string& word) const {
     for (auto i = 1u; i < word.length(); i++) {
         if (!isComplete(encoding)) {
             encodeLetter(encoding, word[i], word[i - 1]);
         }
     }
 }
예제 #16
0
void DHAnimationInfo::update(float delta, float alpha) {
    if (m_alpha != alpha) {
        m_alpha = alpha;
        m_owner->setDirty(true);
    }
    
    if (isComplete()) {
        m_frameTime += delta;
        return;
    }
    if (delta == 0) {
        return;
    }
    
    m_owner->setDirty(true);
    
    if (delta < 0) {
        if (!m_inFadeOut) {
            m_data->applyEventsTo(m_owner, m_frameTime, delta);
        }
        m_frameTime += delta;
        
        if (m_frameTime <= 0) {
            if (m_loop < 0) {
                m_frameTime = getDuration() + fmodf(m_frameTime, getDuration());
            } else if(m_loop > 1) {
                m_loop--;
                m_frameTime = getDuration() + fmodf(m_frameTime, getDuration());
            } else {
                m_loop = 0;
                m_frameTime = 0;
            }
            if (!m_inFadeOut && m_loop) {
                m_data->applyEventsToBackward(m_owner, m_frameTime, getDuration());
                m_data->applyEventsToFirstFrame(m_frameTime, m_owner);
            }
        }
    }
    else {
        if (!m_inFadeOut) {
            m_data->applyEventsTo(m_owner, m_frameTime, delta);
        }
        m_frameTime += delta;
        
        if (m_frameTime >= getDuration()) {
            if (m_loop < 0) {
                m_frameTime = fmodf(m_frameTime, getDuration());
            } else if(m_loop > 1) {
                m_loop--;
                m_frameTime = fmodf(m_frameTime, getDuration());
            } else {
                m_loop = 0;
            }
            if (!m_inFadeOut && m_loop) {
                m_data->applyEventsToFirstFrame(0.f, m_owner);
                m_data->applyEventsTo(m_owner, 0.f, m_frameTime);
            }
        }
    }
}
예제 #17
0
float DHAnimationInfo::getNextFrameTime(float delta) {
    float duration = getDuration();
    if (isComplete()) {
        return duration;
    }
    
    float frameTime = m_frameTime;
    if (delta < 0) {
        frameTime += delta;
        
        if (frameTime <= 0) {
            if (m_loop < 0) {
                frameTime = duration + fmodf(frameTime, duration);
            } else if(m_loop > 1) {
                frameTime = duration + fmodf(frameTime, duration);
            } else {
                frameTime = 0;
            }
        }
    }
    else {
        frameTime += delta;
        
        if (frameTime >= duration) {
            if (m_loop < 0) {
                frameTime = fmodf(frameTime, duration);
            } else if(m_loop > 1) {
                frameTime = fmodf(frameTime, duration);
            } else {
                frameTime = duration;
            }
        }
    }
    return frameTime;
}
예제 #18
0
//-------------------------
// cluster access
//-------------------------
int
PulseClusterer::getCount()
{
	if (!isComplete())
		Fatal(666);
	return clusterList.size();
}
예제 #19
0
struct grid resolvGrid(struct grid Grid){
	applyRules(&Grid);
	if(isComplete(Grid)){
		return Grid;
	}
	else if(!isValid(Grid)){	
		Grid.line = -1;
		return Grid;
	}
	else{
		struct grid g=copy(Grid);
		if(fixUncertainty(&g, 1)){
			g = resolvGrid(g);
			if(g.line != -1){
				return g;
			}
			else{
				g=copy(Grid);
				fixUncertainty(&g, 0);
				g = resolvGrid(g);
				return g;
			}
		}
		else{
			Grid.line = -1;
			return Grid;
		}
	}
}
예제 #20
0
int 
EigenValue::verifyResults()
{
    cl_uint offset = 0;
    if(verify)
    {
        cl_uint eigenIntervalsSizeBytes = (2*length) * sizeof(cl_float);
        for(int i=0 ; i < 2; ++i)
        {
            verificationEigenIntervals[i] = (cl_float *) malloc(eigenIntervalsSizeBytes);

            if(verificationEigenIntervals[i] == NULL)
            {
                sampleCommon->error("Failed to allocate host memory. (verificationEigenIntervals)");
                return SDK_FAILURE;
            }
        }

        cl_float lowerLimit;
        cl_float upperLimit;
        computeGerschgorinInterval(&lowerLimit, &upperLimit, diagonal, offDiagonal, length);

        verificationIn = 0;
        verificationEigenIntervals[verificationIn][0]= lowerLimit;
        verificationEigenIntervals[verificationIn][1]= upperLimit;

        for(cl_int i=2 ; i < 2*length ; i++)
        {
            verificationEigenIntervals[verificationIn][i] = upperLimit;
        }


        int refTimer = sampleCommon->createTimer();
        sampleCommon->resetTimer(refTimer);
        sampleCommon->startTimer(refTimer);

        while(isComplete(verificationEigenIntervals[verificationIn]))
        {
            offset = eigenValueCPUReference(diagonal,offDiagonal, length, verificationEigenIntervals[verificationIn],
                                            verificationEigenIntervals[1-verificationIn]);
            verificationIn = 1 - verificationIn;
        }

        sampleCommon->stopTimer(refTimer);
        referenceKernelTime = sampleCommon->readTimer(refTimer);
        
        if(sampleCommon->compare(eigenIntervals[in], verificationEigenIntervals[verificationIn], 2*length))
        {
            std::cout<<"Passed!\n" << std::endl;
            return SDK_SUCCESS;
        }
        else
        {
            std::cout<<"Failed\n" << std::endl;
            return SDK_FAILURE;
        }
    }
    return SDK_SUCCESS;
}
예제 #21
0
void Plan::addCompletionTask(Context* context, CompletionTask&& task)
{
    LockHolder locker(m_lock);
    if (!isComplete())
        m_completionTasks.append(std::make_pair(context, WTFMove(task)));
    else
        task->run(*this);
}
예제 #22
0
bool MyUPnP::Search(int version)
{
	if (isSearched) return isComplete();

	isSearched = true;

	return InternalSearch(version);
}
예제 #23
0
void SshIncomingPacket::consumeData(QByteArray &newData)
{
#ifdef CREATOR_SSH_DEBUG
    qDebug("%s: current data size = %d, new data size = %d",
        Q_FUNC_INFO, m_data.size(), newData.size());
#endif

    if (isComplete() || newData.isEmpty())
        return;

    /*
     * Until we have reached the minimum packet size, we cannot decrypt the
     * length field.
     */
    const quint32 minSize = minPacketSize();
    if (currentDataSize() < minSize) {
        const int bytesToTake
            = qMin<quint32>(minSize - currentDataSize(), newData.size());
        moveFirstBytes(m_data, newData, bytesToTake);
#ifdef CREATOR_SSH_DEBUG
        qDebug("Took %d bytes from new data", bytesToTake);
#endif
        if (currentDataSize() < minSize)
            return;
    }

    if (4 + length() + macLength() < currentDataSize())
        throw SSH_SERVER_EXCEPTION(SSH_DISCONNECT_PROTOCOL_ERROR, "Server sent invalid packet.");

    const int bytesToTake
        = qMin<quint32>(length() + 4 + macLength() - currentDataSize(),
              newData.size());
    moveFirstBytes(m_data, newData, bytesToTake);
#ifdef CREATOR_SSH_DEBUG
    qDebug("Took %d bytes from new data", bytesToTake);
#endif
    if (isComplete()) {
#ifdef CREATOR_SSH_DEBUG
        qDebug("Message complete. Overall size: %u, payload size: %u",
            m_data.size(), m_length - paddingLength() - 1);
#endif
        decrypt();
        ++m_serverSeqNr;
    }
}
예제 #24
0
void Plan::runCompletionTasks(const AbstractLocker&)
{
    ASSERT(isComplete() && !hasWork());

    for (auto& task : m_completionTasks)
        task.second->run(*this);
    m_completionTasks.clear();
    m_completed.notifyAll();
}
예제 #25
0
파일: s1.cpp 프로젝트: lzl124631x/code
 string shortestCompletingWord(string licensePlate, vector<string>& words) {
     auto cnt = count(licensePlate);
     string ans;
     for (string &w : words) {
         if (!isComplete(w, cnt)) continue;
         if (ans.empty() || w.size() < ans.size()) ans = w;
     }
     return ans;
 }
예제 #26
0
void DataDownloader::complete(QNetworkReply* reply)
{
	m_Data = reply->readAll();
	reply->deleteLater();

	if (!m_Data.isEmpty()) {
		emit isComplete();
	}
}
예제 #27
0
void MF_Message::addChunk(MF_ChunkInfo *c){
	chkList.push_back(c);
	mCount++;
	if(isComplete()){
		MF_Log::mf_log(MF_DEBUG, "MF_Message:addChunk chunk complete, ordering and creating vector of data");
		sortList();
		createData();
	}
}
예제 #28
0
void AccountPage::checkPathNames()
{
    bool was = complete;
    complete = isComplete();
    // let's not casually overwrite a valuable key
    enableMakeKey();
    if ( was != complete )
	emit completeChanged();
}
bool KeyMap::probeKeyMap(const InputDeviceIdentifier& deviceIdentifier,
        const String8& keyMapName) {
    if (!haveKeyLayout()) {
        loadKeyLayout(deviceIdentifier, keyMapName);
    }
    if (!haveKeyCharacterMap()) {
        loadKeyCharacterMap(deviceIdentifier, keyMapName);
    }
    return isComplete();
}
예제 #30
0
QVariant Algorithm_Impl::toVariant() const {
    QVariantMap map = AnalysisObject_Impl::toVariant().toMap();

    map["complete"] = isComplete();
    map["failed"] = failed();
    map["iter"] = iter();
    map["options"] = options().toVariant();

    return QVariant(map);
}