Beispiel #1
0
Rect packIntoPlace(std::list<Vec2>& Skyline, const Vec2& r, std::list<Vec2>::iterator place) {
	float x = 0;
	auto width = r.width();
	//Initialize x
	auto first = Skyline.begin();
	auto last = Skyline.end();
	while (first != last && first != place) {
		x += first->width();
		first++;
	}

	auto newHeight = place->height() + r.height();
	auto rectangle = newRect(Vec2(x, place->height()), r);

	while (place != last && width > 0) {
		if (width >= place->width()) {
			auto newPlace = Skyline.insert(std::next(place), Vec2(place->width(), newHeight));
			Skyline.erase(place);
			place = newPlace;
			width -= place->width();
		}
		else { //need to split skyline
			Skyline.insert(place, Vec2(width, newHeight));
			auto newPlace1 = Skyline.insert(std::next(place), Vec2(place->width() - width, place->height()));
			Skyline.erase(place);
			place = newPlace1;
			width = 0;
		}
		place++;
	}

	return rectangle;
}
Beispiel #2
0
static void getSourcesAndHeaders(const std::list<std::string> &paths,
								std::list<std::string> &headers,
								std::list<std::string> &sources)
{
	std::list<std::string> exts;
	std::list<std::string> aux;


	std::cout << "Obteniendo Headers\n";

	exts.push_back(".h");
	headers.clear();
	for(std::list<std::string>::const_iterator it = paths.begin(); it != paths.end(); ++it){
		assert(FileManager::getInstance()->getAllFiles(*it, aux, exts));

		headers.insert(headers.begin(), aux.begin(), aux.end());
	}


	std::cout << "Obteniendo Sources\n";

	exts.clear();
	aux.clear();
	exts.push_back(".cpp");
	sources.clear();
	for(std::list<std::string>::const_iterator it = paths.begin(); it != paths.end(); ++it){
		assert(FileManager::getInstance()->getAllFiles(*it, aux, exts));

		sources.insert(sources.begin(), aux.begin(), aux.end());
	}

}
void draw_previous_suggestions(std::vector<std::string> words, bool contextChange,
			       const int starty, int startx)
{
    static std::list< std::vector<std::string> > previousSuggestions;
    static std::vector< WINDOW* > windows;

    // clear out existing windows
    for (std::vector< WINDOW* >::iterator winit = windows.begin();
         winit != windows.end();
         winit++) {
        wclear(*winit);
        wrefresh(*winit);
        delwin(*winit);
    }
    windows.clear();

    if (contextChange) {
	// insert a context change marker in the list of previous
	// suggestions
	// 
	std::vector< std::string > marker;
	for (int i = 0; i < atoi(suggestions.c_str()); i++) {
	    marker.push_back("|");
	}
	previousSuggestions.insert(previousSuggestions.begin(), marker);
    }

    previousSuggestions.insert(previousSuggestions.begin(), words);

    for (std::list< std::vector<std::string> >::const_iterator listit = previousSuggestions.begin();
	 (listit != previousSuggestions.end() && startx < COLS); // don't draw window off the screen
	 listit++) {

	int height = listit->size() + 2;
	int width = getGreatestSuggestionLength(*listit) + 2;

	WINDOW* win = newwin(height, width, starty, startx);
	wclear(win);
	box(win, 0, 0);

	int line = 1;
	for (std::vector<std::string>::const_iterator strit = listit->begin();
	     strit != listit->end();
	     strit++) {
	    
	    mvwprintw(win, line, 1, strit->c_str());
	    line++;
	}

	wrefresh(win);
        windows.push_back(win);
	startx += width + 2;
    }
}
Beispiel #4
0
// заключить fig-объекты в составной объект.
void fig_make_comp(std::list<fig_object> & objects){
  if ((objects.size()<1) || (objects.begin()->size()<1)) return;
  iRect r = fig_range(objects);

  fig_object o;
  o.type=6;
  o.push_back(r.TLC());
  o.push_back(r.BRC());
  objects.insert(objects.begin(), o);
  o.type = -6;
  objects.insert(objects.end(), o);
}
 void insert(OnlineFileRequest* request) {
     if (request->resource.priority == Resource::Priority::Regular) {
         firstLowPriorityRequest = queue.insert(firstLowPriorityRequest, request);
         firstLowPriorityRequest++;
     }
     else {
         if (firstLowPriorityRequest == queue.end()) {
             firstLowPriorityRequest = queue.insert(queue.end(), request);
         }
         else {
             queue.insert(queue.end(), request);
         }
     }
 }
void VoronoiSeedsGenerator::insertIntoList(std::list<Seed>& list, Seed& seed)
{
    /*
     * If the list is empty, just pushing back the new seed.
     * Otherwise, we have to determine the position to insert the seed to.
     *  In order to do so, we simply iterate over the seeds, comparing the
     *  distance to center of the one to insert with the latter's ones.
     *  The last comparison needs extra care, since we may have to push
     *  back the seed to insert if its distance to center is greater than
     *  the one of the list's last seed.
     */
    if (list.empty()) {
        list.push_back(seed);
    } else {
        auto current = list.begin();
        auto last = list.end();
        float distance = DIST_TO_CENTER(seed);
        while ((current != last) && (distance > DIST_TO_CENTER(*current))) {
            current++;   
        }
		if (current != last) {
			list.insert(current, seed);
		} else {
			list.push_back(seed);
        }
    }
}
Beispiel #7
0
 DataStatus DataPointGFAL::List(std::list<FileInfo>& files, DataPointInfoType verb) {
   // Open the directory
   struct dirent *d;
   DIR *dir;    
   {
     GFALEnvLocker gfal_lock(usercfg, lfc_host);
     dir = gfal_opendir(GFALUtils::GFALURL(url).c_str());
   }
   if (!dir) {
     logger.msg(VERBOSE, "gfal_opendir failed: %s", StrError(gfal_posix_code_error()));
     int error_no = GFALUtils::HandleGFALError(logger);
     return DataStatus(DataStatus::ListError, error_no);
   }
   
   // Loop over the content of the directory
   while ((d = gfal_readdir (dir))) {
     // Create a new FileInfo object and add it to the list of files
     std::list<FileInfo>::iterator f = files.insert(files.end(), FileInfo(d->d_name));
     // If information about times, type or access was also requested, do a stat
     if (verb & (INFO_TYPE_TIMES | INFO_TYPE_ACCESS | INFO_TYPE_TYPE)) {
       URL child_url = URL(url.plainstr() + '/' + d->d_name);
       logger.msg(DEBUG, "List will stat the URL %s", child_url.plainstr());
       do_stat(child_url, *f);
     }
   }
   
   // Then close the dir
   if (gfal_closedir (dir) < 0) {
     logger.msg(WARNING, "gfal_closedir failed: %s", StrError(gfal_posix_code_error()));
     int error_no = GFALUtils::HandleGFALError(logger);
     return DataStatus(DataStatus::ListError, error_no);
   }
   
   return DataStatus::Success;
 }
Beispiel #8
0
	/*
	 * Adds the given item to the cache and opens it.
	 * Returns the key.
	 */
	LRUKey add_open(T *data_ptr) {
		std::unique_lock<SpinLock> lock(slock);

		typename std::list<LRUPair<T>>::iterator it;
		LRUPair<T> data_pair;

		LRUKey key;
		do {
			key = next_key++;
		} while ((bool)(map.count(key)) || key == 0);

		byte_count += data_ptr->bytes();

		// Remove last element(s) if necessary to make room
		while (byte_count >= max_bytes) {
			if (!erase_last())
				break;
		}

		// Add the new data
		data_pair.key = key;
		data_pair.data_ptr = data_ptr;
		data_pair.active_readers = 1;
		it = elements.begin();
		it = elements.insert(it, data_pair);

		// Log it in the map
		map[key] = it;

		return key;
	}
Beispiel #9
0
void heuristic_search(const cholmod_sparse* const NNE,
                      std::list<int>& ordering,
                      std::list<int>& MIS) {

  std::list<int> tempMIS;

  size_t to_check = static_cast<size_t>(std::sqrt(static_cast<long double>(NNE->ncol))) + 10000;
  if (to_check > NNE->ncol) {
    to_check = NNE->ncol;
  }

  // 1,2,3,4,5
  // 2,1,3,4,5
  // 1,3,2,4,5
  // 3,2,4,1,5
  // 2,4,1,5,3
  // etc...

  std::list<int>::iterator insert_position = ordering.begin();
  for (size_t i = 0; i < to_check; ++i) {
    ++insert_position;
    ordering.insert(insert_position, ordering.front());
    ordering.pop_front();

    findMIS_in_sp_order(NNE, ordering, tempMIS);

    if (tempMIS.size() > MIS.size()) {
      MIS.swap(tempMIS);
    }
    tempMIS.clear();
  }
}
Beispiel #10
0
void addToList( container &c ) {
	c.time = c.fixed_time;
	c.time += time_passed;
	if( time_passed > c.time ) {
		// reset time_passed
		for( auto &e : time_list ) {
			e.time -= time_passed;
		}
		time_passed = 0;
	}

	if( time_list.size() > 0 ) {
		// find place to insert
		bool found = false;
		for( auto it = time_list.begin(); it != time_list.end(); it++ ) {
			if( it->time > c.time ) {
				time_list.insert( it, c );
				found = true;
				break;
			}
		}
		if( !found )
			time_list.push_back( c );
	} else {
		time_list.push_front( c );
	}
}
    static void reorderList(GraphNodeIndex id_suc, DistanceType newdist,
                            std::list<std::pair<GraphNodeIndex, DistanceType>>& nodeSet) {
        typedef std::pair<GraphNodeIndex, DistanceType> DijkstraElement;
        typename std::list<DijkstraElement>::iterator it;

        // Searching for the node "id_suc" in the list
        for (it = nodeSet.begin(); it != nodeSet.end(); it++) {
            if (it->first == id_suc) {
                break;
            }
        }

        // 'it' is in the right place...
        if (it != nodeSet.end()) {
            nodeSet.erase(it);
        }

        // Searching for the new position of "id_suc"
        for (it = nodeSet.begin(); (it != nodeSet.end()) && (it->second < newdist);
                it++) {
            // do nothing
        }

        nodeSet.insert(it, DijkstraElement(id_suc, newdist));
    }
Beispiel #12
0
CVdMdlIfs* CNotFactory::create_model( char* name, char* in_cir_name )
{
  std::list<CNot*>::iterator inot_mdl;

  if( strcmp( pNotModelName, name )!= 0 )
  {
    // TODO: Error message - unsupported model
    return 0;
  }

  for( inot_mdl=not_mdls.begin(); 
    inot_mdl!=not_mdls.end(); inot_mdl++ )
  {
    if((*inot_mdl)->name.compare( in_cir_name )== 0 )
    {
      // TODO: Error msg - Already exists
      return 0;
    }
  }

  CNot* pNot  = 0;
  pNot        = new CNot();
  pNot->name  = in_cir_name;
  pNot->msgI  = pMsgI;

  msg_info( "Subckt[%p] Model[%s] was created", 
    pNot, name );

  not_mdls.insert( not_mdls.end(), pNot );

  return pNot;
}
Beispiel #13
0
void sleep(uint32 seconds) {
	IBMRAS_DEBUG(fine,"in thread.cpp->sleep");
	/* each sleep has its own mutex and condvar - the condvar will either
		be triggered by condBroadcast or it will timeout.*/
	pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
	pthread_cond_t c = PTHREAD_COND_INITIALIZER;

	IBMRAS_DEBUG(debug,"Updating condvar map");
	// lock the condvar map for update
	pthread_mutex_lock(&condMapMux);
	std::list<pthread_cond_t>::iterator it = condMap.insert(condMap.end(),c);
	pthread_mutex_unlock(&condMapMux);
	pthread_mutex_lock(&m);

	struct timespec t;
	clock_gettime(CLOCK_REALTIME, &t);
	t.tv_sec += seconds;		/* configure the sleep interval */
	IBMRAS_DEBUG_1(finest,"Sleeping for %d seconds", seconds);
	pthread_cond_timedwait(&c, &m, &t);
	IBMRAS_DEBUG(finest,"Woke up");
	pthread_mutex_unlock(&m);
	
	pthread_mutex_lock(&condMapMux);
	condMap.erase(it);
	pthread_mutex_unlock(&condMapMux);
}
Beispiel #14
0
void                   ModuleManager::getSortedList(zAPI::IModule::Hook hook, zAPI::IModule::Event event,
                                                    std::list<zAPI::IModuleInfo*>& nList)
{
    std::list<RefCounter<zAPI::IModuleInfo*>*>::iterator  it = this->_modules.back().ptr.hooks[hook].begin();
    std::list<RefCounter<zAPI::IModuleInfo*>*>::iterator  ite = this->_modules.back().ptr.hooks[hook].end();
    for (; it != ite; ++it)
    {
        int prio = (*it)->ptr->getInstance()->getPriority(event);
        std::list<zAPI::IModuleInfo*>::iterator  nIt = nList.begin();
        std::list<zAPI::IModuleInfo*>::iterator  nIte = nList.end();
        bool    inserted = false;

        if (nIt == nIte)
            nList.push_back((*it)->ptr);
        else
        {
            for (; nIt != nIte; ++nIt)
            {
                int nPrio = (*nIt)->getInstance()->getPriority(event);
                if (prio < nPrio)
                {
                    nList.insert(nIt, (*it)->ptr);
                    inserted = true;
                    break;
                }
            }
            if (!inserted)
                nList.push_back((*it)->ptr);
        }
    }
}
//Вспомогательная функция формирования текста статьи из Gumbo-дерева
void makeText(GumboNode *a_entry, std::list<std::u32string> &a_lines)
{
	assert(a_entry != nullptr);
	std::list<std::u32string> l_lines;
	Utility::Gumbo::traverse(a_entry, [&](GumboNode *a)->bool
	{
		if (a->type == GUMBO_NODE_ELEMENT && (a->v.element.tag == GUMBO_TAG_P ||
			a->v.element.tag == GUMBO_TAG_H1 || a->v.element.tag == GUMBO_TAG_H2 ||
			a->v.element.tag == GUMBO_TAG_H3 || a->v.element.tag == GUMBO_TAG_H4))
		{
			l_lines.push_back(std::u32string());
			l_lines.push_back(std::u32string());
		}
		if (a->type != GUMBO_NODE_TEXT)
			return false;
		if (a->parent->v.element.tag != GUMBO_TAG_SCRIPT &&
			a->parent->v.element.tag != GUMBO_TAG_STYLE && a->parent->v.element.tag != GUMBO_TAG_TEXTAREA)
		{
			const std::u32string l_utf32text(Encoding::utf8to32(a->v.text.text));
			Text::format(l_lines, l_utf32text, 80);
		}
		if (a->parent->v.element.tag == GUMBO_TAG_A &&
			a->index_within_parent + 1 == a->parent->v.element.children.length)
		{
			GumboAttribute *const l_href = ::gumbo_get_attribute(&a->parent->v.element.attributes, "href");
			if (l_href != nullptr)
			{
				const std::string l_asText(std::string(" [") + l_href->value + "]");
				Text::format(l_lines, Encoding::utf8to32(l_asText), 80);
			}
		}
		return false;
	});
	a_lines.insert(a_lines.end(), l_lines.begin(), l_lines.end());
}
boost::shared_ptr<Shape> CompOperator::apply(boost::shared_ptr<Shape>& shape, const Grammar& grammar, std::list<boost::shared_ptr<Shape> >& stack) {
	std::vector<boost::shared_ptr<Shape> > shapes;
	
	shape->comp(name_map, shapes);
	stack.insert(stack.end(), shapes.begin(), shapes.end());

	return boost::shared_ptr<Shape>();
}
Beispiel #17
0
    /// Free the pointer and its memory to the list of free subblocks.
    void free_subblock(uint8_t* ptr__, size_t size__)
    {
        /* offset from the beginning of the memory buffer */
        size_t offset = static_cast<size_t>(ptr__ - buffer_.get());
        auto check_free_subblocks = [&]()
        {
#ifndef NDEBUG
            if (free_subblocks_.size() <= 1) {
                return;
            }
            auto it = free_subblocks_.begin();
            auto it1 = it;
            it1++;
            for (; it1 != free_subblocks_.end(); it1++) {
                /* if offse + size of the previous free block is larger than the offset of next block
                   this is an error */
                if (it->first + it->second > it1->first) {
                    throw std::runtime_error("wrong order of free memory blocks");
                }
            }
#endif
        };

        for (auto it = free_subblocks_.begin(); it != free_subblocks_.end(); it++) {
            /* check if we can attach released subblock before this subblock */
            if (it->first == offset + size__) {
                it->first = offset;
                it->second += size__;
                check_free_subblocks();
                return;
            }
            /* check if we can attach released subblock after this subblock */
            if (it->first + it->second == offset) {
                it->second += size__;
                /* now check if we can attach this subblock to the top of the next one */
                auto it1 = it;
                it1++;
                if (it1 != free_subblocks_.end()) {
                    if (it->first + it->second == it1->first) {
                        /* merge second block into first and erase it */
                        it->second += it1->second;
                        free_subblocks_.erase(it1);
                    }
                }
                check_free_subblocks();
                return;
            }
            /* finally, check if the released subblock is before this subblock, but not touching it */
            if (offset + size__ < it->first) {
                free_subblocks_.insert(it, std::make_pair(offset, size__));
                check_free_subblocks();
                return;
            }
        }
        /* otherwise this is the tail subblock */
        free_subblocks_.push_back(std::make_pair(offset, size__));
        check_free_subblocks();
    }
Beispiel #18
0
void RDirNode::getFilesRecursive(std::list<RFile*>& files) const {

    //add this dirs files
    files.insert(files.begin(), this->files.begin(), this->files.end());

    for(std::list<RDirNode*>::const_iterator it = children.begin(); it != children.end(); it++) {
        (*it)->getFilesRecursive(files);
    }
}
void ShapesScenePrivate::insertNode(const NodePtr &node, int index)
{
    auto it = m_nodes.begin();
    while (index != 0) {
        --index;
        ++it;
    }
    m_nodes.insert(it, node);
}
Beispiel #20
0
	void addGroup (const gchar *name, const gchar *icon_path,
	               const gchar *nick, const gchar *sort_key)
	{
		// calculate position
		int pos;
		{
			std::list <std::string>::iterator it;
			for (it = sort_keys.begin(), pos = 0; it != sort_keys.end(); it++, pos++)
				if (strcmp (it->c_str(), sort_key) >= 0)
					break;
			sort_keys.insert (it, sort_key);
		}

		// label widget
		GtkWidget *tab_label, *image, *label;

		GdkPixbuf *icon = NULL;
		if (icon_path) {
			GError *error = 0;
			std::string path = ICONS + std::string (icon_path) + ".png";
			icon = gdk_pixbuf_new_from_file (path.c_str(), &error);
			if (!icon)
				g_warning ("Could not load icon: %s.\nReason: %s", icon_path, error->message);
		}

		tab_label = gtk_hbox_new (FALSE, 0);
		label = gtk_label_new (name);
		if (icon)
			image = gtk_image_new_from_pixbuf (icon);

		if (icon)
			gtk_box_pack_start (GTK_BOX (tab_label), image, FALSE, FALSE, 0);
		gtk_box_pack_start (GTK_BOX (tab_label), label, TRUE, TRUE, icon ? 6 : 0);

		// page widget
		GtkListStore *store = gtk_list_store_new (3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
		m_stores [nick] = store;

		GtkWidget *icons_view;
		icons_view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store));
		gtk_icon_view_set_text_column   (GTK_ICON_VIEW (icons_view), 0);
		gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icons_view), 1);
		g_signal_connect(G_OBJECT (icons_view), "item-activated",
		                 G_CALLBACK (executeCommand), this);

		GtkWidget *page;
		page = gtk_scrolled_window_new (NULL, NULL);
		gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (page),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
		gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (page), GTK_SHADOW_IN);
		gtk_container_add (GTK_CONTAINER (page), icons_view);

		// add those to the notebook
		gtk_widget_show_all (tab_label);
		gtk_notebook_insert_page_menu (GTK_NOTEBOOK (m_widget), page, tab_label, NULL, pos);
	}
Beispiel #21
0
void log_request(const std::list< boost::asio::const_buffer >& d, size_t sz,
        std::list< std::string >& session_extracts,
        std::list< boost::asio::const_buffer >& session_log,
        time_t session_time)
{
    session_extracts.push_back(str( boost::format(">> %2% [%1%]:") % sz % (time(0) - session_time)));
    const std::string& s = session_extracts.back();
    session_log.push_back( boost::asio::const_buffer(s.c_str(), s.size()) );
    session_log.insert(session_log.end(), d.begin(), d.end());
}
Beispiel #22
0
void CCallback::OnMIDI(tuchar ucStatus, tuchar ucDB1, tuchar ucDB2)
{
//	WindowPtr pFront = FrontWindow();
//	WindowPtr pThisWindow = gpNexsynWindow;

	//if(window != FrontWindow())
//		SelectWindow(gpNexsynWindow);
//		BeginUpdate(window);
//		SetPortWindowPort(window);
//		EndUpdate(window);

	CAutoLock Lock(mMutexAudio);
	


	// Timestamp the MIDI
	tuint32 uiTimeStamp = 0;
	if (mpAudioDevice) {
		uiTimeStamp = mpAudioDevice->GetTimeStamp();

		// Just to be on the safe side
		if (uiTimeStamp >= mpAudioDevice->GetBufferSize()) {
			uiTimeStamp = mpAudioDevice->GetBufferSize();
		}
	}

	// Create MIDI Event
	kspi::SMIDIEvent Event;
	Event.iTimeStamp = uiTimeStamp;
	Event.pcData[0] = ucStatus;
	Event.pcData[1] = ucDB1;
	Event.pcData[2] = ucDB2;
	Event.pcData[3] = 0;

	// The event is ready, but the timestamp may be off.
	// This is because there's an interval from the time the audio engine resets its "start-of-buffer-time" to the time the processing is actually started.
	// If a MIDI event occurs in this interval it will receive a very low timestamp (typically 0 I believe) because the audio engine believes it belongs to the next buffer
	// The most important thing is to avoid hanging notes, so what we do is to detect the case where hanging notes would occur, i.e. when a note-off would occur before a note-on
	// So, this means that if the current queue is empty we will accept the jitter, but if the queue is not empty we should be able to detect the hanging-notes case by comparing the timestamp of our last event in the buffer.
	// If the current timestamp is less than the timestamp of the last event we know this has occured, and hanging notes is a possibility.
	// What we do then is to give it the timestamp of the last event.
	// A better approach would be to keep a seperate event list for the next buffer. But at least we don't get hanging notes.
	std::list<kspi::SMIDIEvent>::iterator it = mMIDIEvents.end();
	it--;
	if (it != mMIDIEvents.end()) {
		tuint32 uiTimeStampEvent = it->iTimeStamp;
		if (Event.iTimeStamp < uiTimeStampEvent) {
			Event.iTimeStamp = uiTimeStampEvent;
		}
	}
	// Put it in MIDI queue
	mMIDIEvents.insert(mMIDIEvents.end(), Event);
	
}
Beispiel #23
0
 void SwaptionHelper::addTimesTo(std::list<Time>& times) const {
     calculate();
     Swaption::arguments args;
     swaption_->setupArguments(&args);
     std::vector<Time> swaptionTimes =
         DiscretizedSwaption(args,
                             termStructure_->referenceDate(),
                             termStructure_->dayCounter()).mandatoryTimes();
     times.insert(times.end(),
                  swaptionTimes.begin(), swaptionTimes.end());
 }
Beispiel #24
0
void LoggerEngine::get_messages (std::list<MessageEntry>& messages)
{
    if (log_updater == nullptr) return;

    log_updater->mutex.lock();
    std::list<LogEntry>::iterator it;
    for (it = log_updater->log_list.begin(); it != log_updater->log_list.end(); it++)
    {
        messages.insert(messages.end(), it->entry_list.begin(), it->entry_list.end());
    }
    log_updater->mutex.unlock();
}
	void Identifier::algorithm_nearestFit(std::list<Frame> & frames)
	{
		Frame * current = &frames.front();
		Frame * previous = &(*(++frames.begin()));
		
		static std::list<std::list<Error>> errorMapping;
		static std::vector<std::list<std::list<Error>::iterator>> errorMapIterators;
		errorMapping.clear();
		errorMapIterators.clear();

		float distanceError, areaError, error;
		std::list<Error>::iterator errorMapIteratorIterator;
		std::list<std::list<Error>>::iterator errorMapIterator;
		int pIndex;
		for(std::vector<Object>::iterator c = current->objects.begin(); c != current->objects.end(); c++)
		{
			errorMapIterator = errorMapping.insert(errorMapping.end(), std::list<Error>());
			errorMapIterators.push_back(std::list<std::list<Error>::iterator>());
			pIndex = 0;
			for(std::vector<Object>::iterator p = previous->objects.begin(); p != previous->objects.end(); p++)
			{
				distanceError = std::pow(c->x - p->x - p->dx, 2) + std::pow(c->y - p->y - p->dy, 2);
				error = distanceError;

				errorMapIteratorIterator = errorMapping.back().insert(errorMapping.back().end(),Error(&(*p), &(*c), pIndex, error));
				errorMapIterators[pIndex].push_back(errorMapIteratorIterator);
				pIndex++;
			}
			errorMapping.back().sort();
		}

		for(int i = 0; i < std::min(current->objects.size(), previous->objects.size()); i++)
		{
			errorMapping.sort();
			errorMapping.front().front().current->id = errorMapping.front().front().previous->id;
			errorMapping.front().front().current->model = errorMapping.front().front().previous->model;
			errorMapping.front().front().current->isDecided = true;
			
			while(it != errorMapIterator->end())
				.erase(it)
			
		}

		for(std::vector<Object>::iterator c = current->objects.begin(); c != current->objects.end(); c++)
		{
			if(!c->isDecided)
				c->id = newID();
		}

		

	}
Beispiel #26
0
 void merge(const binomial_heap& heap)
 {
     auto it1 = root_list.begin();
     auto it2 = heap.root_list.begin();
     
     while (it2 != heap.root_list.end()) //merge
     {
         if ((*it1)->get_size() >= (*it2)->get_size())
         {
             root_list.insert(it1, *it2);
             ++it2;
         }
         ++it1;
     }
     
     auto it = root_list.begin();
     
     while ((it != root_list.end()) && (++it != root_list.end()))
     {
         --it;
         if ((*it)->get_size() == (*(++it))->get_size())
         {
             typename std::list<binomial_tree<T>*>::iterator add;
             if (++it != root_list.end())
             {
                 --it;
                 if ((*it)-> get_size() == (*(++it))->get_size())
                 {
                     add = it;
                 }
                 else
                 {
                     add = --it;
                 }
             }
             else
             {
                 add = --it;
             }
             --it;
             *it = (*it)->merge(**add);
             auto copy = it;
             ++it;
             root_list.erase(it);
             it = copy;
         }
         else
         {
             ++it;
         }
     }
 }
Beispiel #27
0
// copylist
// copia una lista de Ini::IdList a una. 
// El tipo de la lista destino se especifica como Template
template <class T> static copylist( const Ini::IdList &l, std::list<T> &lista2 )
{   
    std::list<T>::const_iterator cursor ;

    lista2.insert (lista2.end(), l.begin(), l.end());
    
    // descomentar para ver el resultado
    //for( cursor = lista2.begin() ; cursor != lista2.end() ; cursor ++ )
    //{
    //  cout << '[' << (*cursor) << ']' << endl ;
    //}
    
}
Beispiel #28
0
 void add(T a)
 {
     if (root_list.size() != 0)
     {
         binomial_heap<T> new_heap(a);
         this->merge(new_heap);
     }
     else
     {
         binomial_tree<T>* tree = new binomial_tree<T>(a);
         root_list.insert(root_list.begin(), tree);
     }
 }
// ------------------------------------------------------------------------------------------------
// Updates the node graph - removes all nodes which have the "remove" flag set and the 
// "don't remove" flag not set. Nodes with meshes are never deleted.
bool UpdateNodeGraph(aiNode* node,std::list<aiNode*>& childsOfParent,bool root)
{
	bool b = false;

	std::list<aiNode*> mine;
	for (unsigned int i = 0; i < node->mNumChildren;++i)
	{
		if(UpdateNodeGraph(node->mChildren[i],mine,false))
			b = true;
	}

	// somewhat tricky ... mNumMeshes must be originally 0 and MSB2 may not be set,
	// so we can do a simple comparison against MSB here
	if (!root && AI_RC_UINT_MSB == node->mNumMeshes )
	{
		// this node needs to be removed
		if(node->mNumChildren)
		{
			childsOfParent.insert(childsOfParent.end(),mine.begin(),mine.end());

			// set all children to NULL to make sure they are not deleted when we delete ourself
			for (unsigned int i = 0; i < node->mNumChildren;++i)
				node->mChildren[i] = NULL;
		}
		b = true;
		delete node;
	}
	else
	{
		AI_RC_UNMASK(node->mNumMeshes);
		childsOfParent.push_back(node);

		if (b)
		{
			// reallocate the array of our children here
			node->mNumChildren = (unsigned int)mine.size();
			aiNode** const children = new aiNode*[mine.size()];
			aiNode** ptr = children;

			for (std::list<aiNode*>::iterator it = mine.begin(), end = mine.end();
				 it != end; ++it)
			{
				*ptr++ = *it;
			}
			delete[] node->mChildren;
			node->mChildren = children;
			return false;
		}
	}
	return b;
}
Beispiel #30
0
struct SersiProg* execute(const wchar_t* name, const wchar_t* progname, const wchar_t* progparam, const wchar_t* dirparam, bool autoRestart, bool dailyRestart)
{
	wchar_t* l_progparam = (wchar_t*)progparam;
	wchar_t* l_dirparam = (wchar_t*)dirparam;

	if( l_progparam == NULL || l_progparam[0] == L'\0' )
		l_progparam = NULL;

	if( l_dirparam == NULL || l_dirparam[0] == L'\0' )
		l_dirparam = NULL;

	if( !check_config )
	{
		SHELLEXECUTEINFOW* shi;
		shi = (SHELLEXECUTEINFOW*)malloc(sizeof(SHELLEXECUTEINFOW));

		ZeroMemory(shi, sizeof(SHELLEXECUTEINFOW));
		
		shi->cbSize = sizeof(SHELLEXECUTEINFOW);
		shi->fMask = SEE_MASK_NOCLOSEPROCESS;
		shi->hwnd = 0;

		shi->lpVerb = L"open";
		shi->lpFile = progname;
		shi->lpParameters = l_progparam;
		shi->lpDirectory = l_dirparam;
		shi->nShow = 0;
		
		ShellExecuteEx( shi );

		SersiProg* p = (SersiProg*)malloc(sizeof(SersiProg));
		p->name = _wcsdup(name);
		p->process = shi;
		p->autoRestart = autoRestart;
		p->dailyRestart = dailyRestart;

		plist.insert( plist.end(), p );

		return p;
	}
	else
	{
#ifdef WINDOWMODE
		insertItem(name, progname, l_dirparam, l_progparam, autoRestart, dailyRestart);
#else
		wprintf(L"Application %s\nOpen: %s\nParam: %s\nDir: %s\nAuto Restart: %s\nDailyRestart: %s\n\n", 
				name, progname, progparam, dirparam, autoRestart?L"yes":L"no", dailyRestart?L"yes":L"no");
#endif
		return NULL;
	}
}