C++ array_t::end方法代码示例

	void find_item(std::size_t& lenmax, const array_t::value_type& from, const array_t::value_type& to, array_t& path = array_t(), visited_t& visited = visited_t())
	{
		if (path.size() > lenmax)
			return;

		path.push_back(from);
		if (from->word_id == to->word_id)
		{
			lenmax = path.size() - 2;
			dump(path);
			return;
		}

		visited.insert(std::make_pair(from->word_id, 1));

		for (auto& s : from->similar) {

			auto hit = visited.find(s->word_id);
			if (hit != visited.end() && hit->second > 12535000) {
				hit_reached++;
				continue;
			}

			if (hit != visited.end())
				hit->second++;

			// исключить зацикливание
			if (std::find(path.begin(), path.end(), s) != path.end())
				continue;

			array_t another;
			another = path;
			find_item(lenmax, s, to, another, visited);
		}
	}

	void find_path(const std::string& from, const std::string& to)
	{
		auto first = std::find_if(words.begin(), words.end(), [&from](const std::shared_ptr<Item>& item)->bool { return dict[item->word_id] == from; });
		if (first == words.end()) {
			std::cout << "missing " << from << std::endl;
			return;
		}

		auto second = std::find_if(words.begin(), words.end(), [&to](const std::shared_ptr<Item>& item)->bool { return dict[item->word_id] == to; });
		if (second == words.end()){
			std::cout << "missing " << to << std::endl;
			return;
		}


		auto l = *first;
		auto r = *second;

		visited_t visited;
		array_t path;
		std::size_t lenmax = 11;
		find_item(lenmax, l, r, path, visited);

		std::cout << "hit_reached " << hit_reached << std::endl;
	}

amqp_field_value_t TableValueImpl::generate_field_value::operator()(const array_t &value) const
{
  amqp_field_value_t v;
  v.kind = AMQP_FIELD_KIND_ARRAY;
  v.value.array.num_entries = value.size();
  v.value.array.entries = (amqp_field_value_t*)amqp_pool_alloc(&pool,
                                                               sizeof(amqp_field_value_t)*value.size());
  if (NULL == v.value.array.entries)
  {
    throw std::bad_alloc();
  }
  
  amqp_field_value_t *output_iterator = v.value.array.entries;
  for (array_t::const_iterator it = value.begin();
       it != value.end(); ++it, ++output_iterator)
  {
    *output_iterator = boost::apply_visitor(generate_field_value(pool),
                                            it->m_impl->m_value);
  }
  return v;
}

static popup_t::menu_item_set_t array_to_menu_item_set(const array_t& value)
{
    popup_t::menu_item_set_t set;

    for (array_t::const_iterator iter(value.begin()), last(value.end());
         iter != last; ++iter)
    {
        if (iter->type_info() != typeid(dictionary_t))
            continue;

        const dictionary_t&          cur_new_item(iter->cast<dictionary_t>());
        dictionary_t::const_iterator name_iter(cur_new_item.find(key_name));
        dictionary_t::const_iterator value_iter(cur_new_item.find(key_value));

        if (name_iter == cur_new_item.end() ||
            name_iter->second.type_info() != typeid(std::string) ||
            value_iter == cur_new_item.end())
            continue;

        set.push_back(popup_t::menu_item_t(name_iter->second.cast<std::string>(), value_iter->second));
    }

    return set;
} 

	void Phy2dWorld::sortActors(array_t<Phy2dActor*> &actors)
	{
		// sort actors by layer
		std::sort(actors.begin(), actors.end(), lessActorLayer);
	}

 iterator       end()         { return buf_.end();   }

 bool operator==(const chunk_base<Type>& compare) const
 {
     return std::equal(begin(), end(), compare.begin());
 }

 /** Fill this chunk with zeroes/air. */
 void clear(value_type v = 0)
 {
     std::fill(begin(), end(), v);
     is_dirty = true;
 }