Beispiel #1
0
void *runner(void *f)
{
    string tmp = "", content = *(string *)f;            //將傳過來的指標轉成string

    for (int i = 0; i < content.length()+1; ++i) {
        if(content[i]=='\'' && tmp!="" &&((content[i+1]>='a' && content[i+1]<='z') || (content[i+1]>='A' && content[i+1]<='Z')) )   // 單引號的前後為英文單字的
        {
            tmp += content[i];
            continue;
        }

        if(content[i]>='a' && content[i] <='z') 
            tmp += content[i];
        else if(content[i] >='A' && content[i] <= 'Z')
            tmp += tolower(content[i]);
        else if(tmp != "")
        {
            pthread_mutex_lock(&mutex);         //鎖

            /* critical section */
            iter = m.find(tmp);                 //搜尋
            if(iter != m.end())
                iter->second++;                 //資料重複,所以將次數+1
            else
                m.insert(map_type::value_type(tmp,1));          //插入資料

            pthread_mutex_unlock(&mutex);       //解鎖
            tmp = "";
        }
    }

    pthread_exit(0);                            //結束thread
}
void SiblingCoupling::operator()
  (const MeshBase::const_element_iterator & range_begin,
   const MeshBase::const_element_iterator & range_end,
   processor_id_type p,
   map_type & coupled_elements)
{
  LOG_SCOPE("operator()", "SiblingCoupling");

  for (const auto & elem : as_range(range_begin, range_end))
    {
      std::vector<const Elem *> active_siblings;

      const Elem * parent = elem->parent();
      if (!parent)
        continue;

#ifdef LIBMESH_ENABLE_AMR
      parent->active_family_tree(active_siblings);
#endif

      for (const Elem * sibling : active_siblings)
        if (sibling->processor_id() != p)
          coupled_elements.insert
            (std::make_pair(sibling, _dof_coupling));
    }
}
Beispiel #3
0
void probe (map_type& testMap, std::string name, auto keys, auto values, size_t toFind)
{
    // map_type
    const int width (15);
    const int precision (6);
    std::cout << std::setw (width) << keys.size () << " : " << std::setw (width) << name << " : " << std::flush;
    high_resolution_clock::time_point startTime = high_resolution_clock::now ();
    auto itValues = begin (values);
    for_each (begin (keys), end (keys), [&testMap, &itValues](size_t key)
              {
                  testMap.insert (std::make_pair (key, (*itValues++)));
              });

    high_resolution_clock::time_point findTime = high_resolution_clock::now ();
    size_t currFind = 0;
    for (auto k : keys)
    {
        if (currFind >= toFind)
            break;

        bool exists = testMap.find (k) != testMap.end ();
        if (exists)
            ++currFind;
    }
    high_resolution_clock::time_point endTime   = high_resolution_clock::now ();
    duration<double> time_span_insert = duration_cast<duration<double>> (findTime-startTime);
    duration<double> time_span_find = duration_cast<duration<double>> (endTime-findTime);
    std::cout << "time insert = " << std::fixed << std::setprecision (precision) << time_span_insert.count () << "  time find = " << std::setprecision (precision) << time_span_find.count () << std::setw (width) << "   found = " << std::setw (width) << currFind << std::endl;
}
inline std::error_category const & to_std_category( boost::system::error_category const & cat )
{
    if( cat == boost::system::system_category() )
    {
        static const std_category system_instance( &cat, 0x1F4D7 );
        return system_instance;
    }
    else if( cat == boost::system::generic_category() )
    {
        static const std_category generic_instance( &cat, 0x1F4D3 );
        return generic_instance;
    }
    else
    {
        typedef std::map< boost::system::error_category const *, std::unique_ptr<std_category>, cat_ptr_less > map_type;

        static map_type map_;
        static std::mutex map_mx_;

        std::lock_guard<std::mutex> guard( map_mx_ );

        map_type::iterator i = map_.find( &cat );

        if( i == map_.end() )
        {
            std::unique_ptr<std_category> p( new std_category( &cat, 0 ) );

            std::pair<map_type::iterator, bool> r = map_.insert( map_type::value_type( &cat, std::move( p ) ) );

            i = r.first;
        }

        return *i->second;
    }
}
 KOKKOS_INLINE_FUNCTION
 void operator()(uint32_t i, value_type & v) const
 {
   const uint32_t key = Near ? i/collisions : i%(inserts/collisions);
   typename map_type::insert_result result = map.insert(key,i);
   v.failed_count += !result.failed() ? 0 : 1;
   v.max_list = result.list_position() < v.max_list ? v.max_list : result.list_position();
 }
Beispiel #6
0
static bool parseUrlEncodedParams(char const *str,map_type &params)
{
	// Parse a string in format key1=value1&key2=value2&...
	// where keys and values are url-encoded using %XX escapes.
	// For delimiting key=value pairs, either '&' or ';' may be used.
	// If the same key appears multiple times, only the last one is
	// stored in the map.

	ASSERT( str );

	while( *str ) {
		while( *str == ';' || *str == '&' ) {
			str++;
		}
		if( !*str ) {
			break;
		}

		std::pair<std::string,std::string> keyval;
		size_t len = strcspn(str,"=&;");

		if( !len ) {
			return false;
		}
		if( !urlDecode(str,len,keyval.first) ) {
			return false;
		}

		str += len;

		if( *str == '=' ) {
			str++;

			len = strcspn(str,"&;");

			if( !urlDecode(str,len,keyval.second) ) {
				return false;
			}

			str += len;
		}

		// insert_result is a pair with an iterator pointing to an
		// existing conflicting member and a bool indicating success
		std::pair<typename map_type::iterator,bool> insert_result =
			params.insert(keyval);

		if( !insert_result.second ) {
			// key already in params
			ASSERT( insert_result.first->first == keyval.first );
			insert_result.first->second = keyval.second;
		}
	}
	return true;
}
Beispiel #7
0
 static void set(map_type & x, const key_type & v, mapped_type & m)
 {
    if (x.count(v) == 0)
    {
       x.insert(std::make_pair(v, m));
    }
    else
    {
       PyErr_SetString(PyExc_IndexError, "Value already set");
       boost::python::throw_error_already_set();
    }
 }
Beispiel #8
0
 inline OccupationInfo& find_or_insert(Point const& point, Point& mapped_point)
 {
     typename map_type::iterator it = map.find(point);
     if (it == boost::end(map))
     {
         std::pair<typename map_type::iterator, bool> pair 
                     = map.insert(std::make_pair(point, OccupationInfo()));
         it = pair.first;
     }
     mapped_point = it->first;
     return it->second;
 }
Beispiel #9
0
inline class_id class_id_map::get_local(type_id const& type)
{
    std::pair<map_type::iterator, bool> result = m_classes.insert(
        std::make_pair(type, 0));

    if (result.second)
        result.first->second = m_local_id++;

    assert(m_local_id >= local_id_base);

    return result.first->second;
}
Beispiel #10
0
LUABIND_API class_id allocate_class_id(type_id const& cls)
{
    typedef std::map<type_id, class_id> map_type;

    static map_type registered;
    static class_id id = 0;

    std::pair<map_type::iterator, bool> inserted = registered.insert(
        std::make_pair(cls, id));

    if (inserted.second)
        ++id;

    return inserted.first->second;
}
Beispiel #11
0
size_t listen(dht::DhtRunner& node, std::string chain, map_type& map)
{
    std::future<size_t> token = node.listen(chain,
        [&map](const std::vector<std::shared_ptr<dht::Value>>& values)
        {
            // For every value found...
            for (const auto& value : values)
            {
                // Unpack then register and display it, if it's a new value.
                std::string content = value->unpack<std::string>();
                if(!map.count(content))
                {
                    map.insert(std::make_pair(content, get_timestamp()));
                    disp(content);
                }
            }

            // Continue lookup until no values are left.
            return true;
        });

    if(token.wait_for(std::chrono::seconds(1)) != std::future_status::ready)
    {
        verbose("Warning: Could not create a listener since 1000ms.");
        verbose("         Trying again for 30s...");

        if(token.wait_for(std::chrono::seconds(30))
            != std::future_status::ready)
            verbose("Error: Failure.");
        else
            verbose("         Done.");
    }

    auto v = token.get();
    verbose("Starting listening to "
        + chain
        + " with token "
        + std::to_string(v) + ".");
    return v;
}
Beispiel #12
0
inline void class_id_map::put(class_id id, type_id const& type)
{
    assert(id < local_id_base);

    std::pair<map_type::iterator, bool> result = m_classes.insert(
        std::make_pair(type, 0));

    assert(
        result.second
        || result.first->second == id
        || result.first->second >= local_id_base
    );

    if (!result.second && result.first->second >= local_id_base)
    {
        --m_local_id;
    }

    result.first->second = id;

    assert(m_local_id >= local_id_base);
}
inline operation operation_sequence::new_operation(int id, int error_code)
{
    using namespace std;
    if ( error_code < 0 || 
         (error_code > BOOST_IOSTREAMS_TEST_MAX_OPERATION_ERROR &&
             error_code != INT_MAX) )
    {
        throw runtime_error( string("The error code ") + 
                             lexical_cast<string>(error_code) +
                             " is out of range" );
    }
    if (last_executed_ != INT_MIN)
        throw runtime_error( "Operations in progress; call reset() "
                             "before creating more operations" );
    map_type::const_iterator it = operations_.find(id);
    if (it != operations_.end())
        throw runtime_error( string("The operation ") + 
                             lexical_cast<string>(id) +
                             " already exists" );
    operation op(*this, id, error_code);
    operations_.insert(make_pair(id, ptr_type(op.pimpl_)));
    return op;
}
Beispiel #14
0
 bool register_parser(osmium::io::file_format format, create_parser_type create_function) {
     if (! m_callbacks.insert(map_type::value_type(format, create_function)).second) {
         return false;
     }
     return true;
 }
 KOKKOS_INLINE_FUNCTION
 void operator()(size_type i) const
 {
   if ( m_src.valid_at(i) )
     m_dst.insert(m_src.key_at(i), m_src.value_at(i));
 }
Beispiel #16
0
    short AddType(const char* componentName){
          ComponentFactoryFuncPtr function = &createType<Type>;
        m_Map.insert(std::make_pair(componentName, function));

    return 0;
    };
 KOKKOS_INLINE_FUNCTION
 void operator()(typename device_type::size_type i) const
 {
   m_map.insert(i%(m_num_insert/m_num_duplicates), uint32_t(i));
 }
Beispiel #18
0
 static void
 do_(map_type& m, int key) {
     m.insert(std::make_pair(key, std::unique_ptr<base>{new T}));
     filler<Ts...>::do_(m, key + 1);
 }
Beispiel #19
0
        inline bool add_factory(message::factory &&factory)
        {
            lock guard(m);

            return factories.insert(map_type::entry(factory.get_type(), factory.move())) != factories.end();
        }
 KOKKOS_INLINE_FUNCTION
 void operator()(uint32_t i, value_type & failed_count) const
 {
   const uint32_t key = Near ? i/collisions : i%(inserts/collisions);
   if (map.insert(key,i).failed()) ++failed_count;
 }
Beispiel #21
0
 //! computing (phi composition this)
 Pass& composition_left(const Pass& phi) {
     pa.insert(phi.pa.begin(), phi.pa.end());
     return *this;
 }
Beispiel #22
0
void DefaultCoupling::operator()
  (const MeshBase::const_element_iterator & range_begin,
   const MeshBase::const_element_iterator & range_end,
   processor_id_type p,
   map_type & coupled_elements)
{
  LOG_SCOPE("operator()", "DefaultCoupling");

#ifdef LIBMESH_ENABLE_PERIODIC
  bool check_periodic_bcs =
    (_periodic_bcs && !_periodic_bcs->empty());

  UniquePtr<PointLocatorBase> point_locator;
  if (check_periodic_bcs)
    {
      libmesh_assert(_mesh);
      point_locator = _mesh->sub_point_locator();
    }
#endif

  if (!this->_n_levels)
    {
      for (MeshBase::const_element_iterator elem_it = range_begin;
           elem_it != range_end; ++elem_it)
        {
          const Elem * const elem = *elem_it;

          if (elem->processor_id() != p)
            coupled_elements.insert (std::make_pair(elem,_dof_coupling));
        }
      return;
    }

  typedef LIBMESH_BEST_UNORDERED_SET<const Elem*> set_type;
  set_type next_elements_to_check(range_begin, range_end);
  set_type elements_to_check;
  set_type elements_checked;

  for (unsigned int i=0; i != this->_n_levels; ++i)
    {
      elements_to_check.swap(next_elements_to_check);
      next_elements_to_check.clear();
      elements_checked.insert(elements_to_check.begin(), elements_to_check.end());

      for (set_type::const_iterator elem_it  = elements_to_check.begin(),
                                    elem_end = elements_to_check.end();
           elem_it != elem_end; ++elem_it)
        {
          std::vector<const Elem *> active_neighbors;

          const Elem * const elem = *elem_it;

          if (elem->processor_id() != p)
            coupled_elements.insert (std::make_pair(elem,_dof_coupling));

          for (unsigned int s=0; s<elem->n_sides(); s++)
            {
              const Elem *neigh = elem->neighbor_ptr(s);

              // If we have a neighbor here
              if (neigh)
                {
                  // Mesh ghosting might ask us about what we want to
                  // distribute along with non-local elements, and those
                  // non-local elements might have remote neighbors, and
                  // if they do then we can't say anything about them.
                  if (neigh == remote_elem)
                    continue;
                }
#ifdef LIBMESH_ENABLE_PERIODIC
              // We might still have a periodic neighbor here
              else if (check_periodic_bcs)
                {
                  libmesh_assert(_mesh);

                  neigh = elem->topological_neighbor
                    (s, *_mesh, *point_locator, _periodic_bcs);
                }
#endif

              // With no regular *or* periodic neighbors we have nothing
              // to do.
              if (!neigh)
                continue;

              // With any kind of neighbor, we need to couple to all the
              // active descendants on our side.
#ifdef LIBMESH_ENABLE_AMR
              if (neigh == elem->neighbor_ptr(s))
                neigh->active_family_tree_by_neighbor(active_neighbors,elem);
#  ifdef LIBMESH_ENABLE_PERIODIC
              else
                neigh->active_family_tree_by_topological_neighbor
                  (active_neighbors,elem,*_mesh,*point_locator,_periodic_bcs);
#  endif
#else
              active_neighbors.clear();
              active_neighbors.push_back(neigh);
#endif

              for (std::size_t a=0; a != active_neighbors.size(); ++a)
                {
                  const Elem * neighbor = active_neighbors[a];

                  if (!elements_checked.count(neighbor))
                    next_elements_to_check.insert(neighbor);

                  if (neighbor->processor_id() != p)
                    coupled_elements.insert
                      (std::make_pair(neighbor, _dof_coupling));
                }
            }
        }
    }
}
Beispiel #23
0
 bool Emplace(const std::string& key, ElementType&& value)
 {
     return m_value->insert(std::make_pair(AUTOJSONCXX_MOVE(key), AUTOJSONCXX_MOVE(value))).second;
 }
Beispiel #24
0
 bool insert(void* obj, long key)    {
   std::pair<map_type::iterator,bool> p =
     m.insert(map_type::value_type(key,obj));
   return p.second;
 }
Beispiel #25
0
 bool Emplace(const std::string& key, const ElementType& value)
 {
     return m_value->insert(std::make_pair(key, value)).second;
 }
Beispiel #26
0
void insert(map_type &m, 
	    const set_type& s, const pair_type& r) {
  pair<set_type, pair_type> p1 = make_pair(s, r);
  m.insert(p1);
}
void PointNeighborCoupling::operator()
  (const MeshBase::const_element_iterator & range_begin,
   const MeshBase::const_element_iterator & range_end,
   processor_id_type p,
   map_type & coupled_elements)
{
  LOG_SCOPE("operator()", "PointNeighborCoupling");

#ifdef LIBMESH_ENABLE_PERIODIC
  bool check_periodic_bcs =
    (_periodic_bcs && !_periodic_bcs->empty());
  UniquePtr<PointLocatorBase> point_locator;
  if (check_periodic_bcs)
    {
      libmesh_assert(_mesh);
      point_locator = _mesh->sub_point_locator();
    }
#endif

  if (!this->_n_levels)
    {
      for (MeshBase::const_element_iterator elem_it = range_begin;
           elem_it != range_end; ++elem_it)
        {
          const Elem * const elem = *elem_it;

          if (elem->processor_id() != p)
            coupled_elements.insert (std::make_pair(elem,_dof_coupling));
        }
      return;
    }

  typedef LIBMESH_BEST_UNORDERED_SET<const Elem*> set_type;
  set_type next_elements_to_check(range_begin, range_end);
  set_type elements_to_check;
  set_type elements_checked;

  for (unsigned int i=0; i != this->_n_levels; ++i)
    {
      elements_to_check.swap(next_elements_to_check);
      next_elements_to_check.clear();
      elements_checked.insert(elements_to_check.begin(), elements_to_check.end());

      for (set_type::const_iterator elem_it  = elements_to_check.begin(),
                                    elem_end = elements_to_check.end();
           elem_it != elem_end; ++elem_it)
        {
          std::set<const Elem *> point_neighbors;

          const Elem * const elem = *elem_it;

          if (elem->processor_id() != p)
            coupled_elements.insert (std::make_pair(elem,_dof_coupling));

#ifdef LIBMESH_ENABLE_PERIODIC
          // We might have a periodic neighbor here
          if (check_periodic_bcs)
            {
              libmesh_not_implemented();
            }
          else
#endif
            {
              elem->find_point_neighbors(point_neighbors);
            }

          for (std::set<const Elem *>::const_iterator
                 it = point_neighbors.begin(),
                 end_it = point_neighbors.end();
               it != end_it; ++it)
            {
              const Elem * neighbor = *it;

              if (!elements_checked.count(neighbor))
                next_elements_to_check.insert(neighbor);

              if (neighbor->processor_id() != p)
                coupled_elements.insert
                  (std::make_pair(neighbor, _dof_coupling));
            }
        }
    }
}