static bool compare(map_type const & MA, map_type const & MB)
			{
				std::vector < std::pair<std::string,std::string> > SA, SB;
				for ( typename map_type::const_iterator ita = MA.begin(); ita != MA.end(); ++ita )
					SA.push_back(std::pair<std::string,std::string>(ita->first,ita->second));
				for ( typename map_type::const_iterator ita = MB.begin(); ita != MB.end(); ++ita )
					SB.push_back(std::pair<std::string,std::string>(ita->first,ita->second));
				std::sort(SA.begin(),SA.end());
				std::sort(SB.begin(),SB.end());
				
				uint64_t ia = 0, ib = 0;
				
				for ( ; ia != SA.size() && ib != SB.size() ; ++ia, ++ib )
					if ( SA[ia] != SB[ib] )
					{
						#if 0
						std::cerr << printPair(SA[ia]) << " != " << printPair(SB[ib]) << std::endl;
						
						for ( uint64_t i = 0; i < SA.size(); ++i )
							std::cerr << SA[i].first << ";";
						std::cerr << MA.size();
						std::cerr << std::endl;
						for ( uint64_t i = 0; i < SB.size(); ++i )
							std::cerr << SB[i].first << ";";
						std::cerr << MB.size();
						std::cerr << std::endl;
						#endif
						
						return SA[ia] < SB[ib];
					}

				return ia < ib;
			}
int main(int argc, const char** argv)
{
   std::string text;
   for(int i = 1; i < argc; ++i)
   {
      cout << "Processing file " << argv[i] << endl;
      std::ifstream fs(argv[i]);
      load_file(text, fs);
      fs.close();
      // construct our iterators:
      boost::sregex_iterator m1(text.begin(), text.end(), expression);
      boost::sregex_iterator m2;
      std::for_each(m1, m2, &regex_callback);
      // copy results:
      cout << class_index.size() << " matches found" << endl;
      map_type::iterator c, d;
      c = class_index.begin();
      d = class_index.end();
      while(c != d)
      {
         cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
         ++c;
      }
      class_index.erase(class_index.begin(), class_index.end());
   }
   return 0;
}
Esempio n. 3
0
static void find_unreachable_objects_impl(map_type const & m, map2_type & m2)
{
    // scan objects for shared_ptr members, compute internal counts

    {
        std::cout << "... " << m.size() << " objects in m.\n";

        for(map_type::const_iterator i = m.begin(); i != m.end(); ++i)
        {
            abt_boost::detail::sp_counted_base const * p = static_cast<abt_boost::detail::sp_counted_base const *>(i->first);

            BOOST_ASSERT(p->use_count() != 0); // there should be no inactive counts in the map

            m2[ i->first ];

            scan_and_count(i->second.first, i->second.second, m, m2);
        }

        std::cout << "... " << m2.size() << " objects in m2.\n";
    }

    // mark reachable objects

    {
        open_type open;

        for(map2_type::iterator i = m2.begin(); i != m2.end(); ++i)
        {
            abt_boost::detail::sp_counted_base const * p = static_cast<abt_boost::detail::sp_counted_base const *>(i->first);
            if(p->use_count() != i->second) open.push_back(p);
        }

        std::cout << "... " << open.size() << " objects in open.\n";

        for(open_type::iterator j = open.begin(); j != open.end(); ++j)
        {
            m2.erase(*j);
        }

        while(!open.empty())
        {
            void const * p = open.front();
            open.pop_front();

            map_type::const_iterator i = m.find(p);
            BOOST_ASSERT(i != m.end());

            scan_and_mark(i->second.first, i->second.second, m2, open);
        }
    }

    // m2 now contains the unreachable objects
}
Esempio n. 4
0
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;
    }
}
Esempio n. 5
0
        inline const message::factory *get_factory(message_type type) const
        {
            lock guard(m);

            auto it = factories.find(type);
            return (it == factories.end()) ? nullptr : it->value;
        }
Esempio n. 6
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
}
Esempio n. 7
0
 //! conversion to clause
 clause_type clause() const {
     clause_type C;
     const iterator pa_end = pa.end();
     for (iterator i = pa.begin(); i != pa_end; ++i)
         C.ls.insert(literal_type(i->first, i->second));
     return C;
 }
Esempio n. 8
0
 /** Compute the sum of all the elements
  * Implements compensated summation
  */
 double sum() {
     double s=0.;
     for (map_type::iterator it=map.begin(),itend=map.end();it!=itend;++it) {
         s += it->second;
     }
     return s;
 }
Esempio n. 9
0
inline class_id class_id_map::get(type_id const& type) const
{
    map_type::const_iterator i = m_classes.find(type);
    if (i == m_classes.end() || i->second >= local_id_base)
        return unknown_class;
    return i->second;
}
Esempio n. 10
0
Dispatch::Handler Dispatch::code2handler( Message::type_t type )
{
	typedef std::map<Message::type_t, Handler> map_type;
	static map_type handlers;
	if ( handlers.empty() ) {
		using namespace MessageTypes;
		handlers[ NameQuery ] = &Dispatch::namequery_handler;
		handlers[ NameReply ] = &Dispatch::namereply_handler;
		handlers[ Opponentname ] = &Dispatch::opponentname_handler;
		handlers[ Receive ] = &Dispatch::receive_handler;
		handlers[ Invalidmove ] = &Dispatch::invalidmove_handler;
		handlers[ Inform ] = &Dispatch::inform_handler;
		handlers[ Status ] = &Dispatch::status_handler;
		handlers[ Points ] = &Dispatch::points_handler;
		handlers[ PlayQuery ] = &Dispatch::playquery_handler;
		handlers[ PlayReply ] = &Dispatch::playreply_handler;
		handlers[ Give3Query ] = &Dispatch::give3query_handler;
		handlers[ Terminate ] = &Dispatch::terminate_handler;
		//	handlers[Reset] = &Dispatch::reset_handler;
		handlers[ Give3Reply ] = &Dispatch::give3reply_handler;
		handlers[ PlayReply ] = &Dispatch::playreply_handler;

	}
	map_type::iterator resp = handlers.find( type );
	if ( resp == handlers.end() ) {
		LOG_PLACE() << "No handler for " << type << ".\n";
		return &Dispatch::error_handler;
	}
	return resp->second;
}
Esempio n. 11
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;
}
Esempio n. 12
0
 void print() const{
     enterExclusive();
     map_type::const_iterator iter = _item_map.begin();
     for(; iter != _item_map.end(); ++iter){
         iter->second->print();
     }
     leaveExclusive();
 }
Esempio n. 13
0
 /** Compute the max of the element values
  * This operation returns the first element if the vector is empty.
  */
 mwIndex max_index() {
     mwIndex index=0;
     double maxval=std::numeric_limits<double>::min();
     for (map_type::iterator it=map.begin(),itend=map.end();it!=itend;++it) {
         if (it->second>maxval) { maxval = it->second; index = it->first; }
     }
     return index;
 }
Esempio n. 14
0
 void flush(){
     enterExclusive();
     map_type::iterator iter = _item_map.begin();
     for(; iter != _item_map.end(); ++iter){
         iter->second->flush();
     }
     leaveExclusive();
 }
Esempio n. 15
0
 /** Get an element and provide a default value when it doesn't exist
  * This command does not insert the element into the vector
  */
 double get(mwIndex index, double default_value=0.0) {
     map_type::iterator it = map.find(index);
     if (it == map.end()) {
         return default_value;
     } else {
         return it->second;
     }
 }
Esempio n. 16
0
 static size_type alphabet_size_and_map(const reference_type rac, size_type n, map_type& map, inv_map_type& inv_map, value_type& first_symbol) {
     if (n > 0)
         first_symbol = rac[0];
     map.clear();
     inv_map.clear();
     size_type alphabet_size = 0;
     for (size_type i=0; i<n; ++i) {
         if (map.find(rac[i]) == map.end()) {
             map[rac[i]]    = 1;
         }
     }
     for (typename map_type::iterator it = map.begin(); it != map.end(); ++it) { // this preserves the order
         it->second = alphabet_size;
         inv_map[alphabet_size] = it->first;
         ++alphabet_size;
     }
     return alphabet_size;
 }
Esempio n. 17
0
 static void del(map_type& cont, const key_type& key)
 {
     if ( cont.find(key) != cont.end() ) {
         cont.erase(key);
     }
     else {
         KeyError();
     }
 }
Esempio n. 18
0
void
mapper::_free_map(map_type &m) {
    map_type::iterator i = m.begin();
    for (; i != m.end(); i++) {
        if (i->first)  free((void *)i->first);
        if (i->second) free((void *)i->second);
    }
    m.clear();
}
Esempio n. 19
0
inline void operation_sequence::remove_operation(int id)
{
    using namespace std;
    map_type::iterator it = operations_.find(id);
    if (it == operations_.end())
        throw runtime_error( string("No such operation: ") + 
                             lexical_cast<string>(id) );
    operations_.erase(it);
}
Esempio n. 20
0
                std::unique_ptr<osmium::io::detail::OutputFormat> create_output(const osmium::io::File& file, data_queue_type& output_queue) {
                    file.check();

                    auto it = m_callbacks.find(file.format());
                    if (it != m_callbacks.end()) {
                        return std::unique_ptr<osmium::io::detail::OutputFormat>((it->second)(file, output_queue));
                    }

                    throw std::runtime_error(std::string("Support for output format '") + as_string(file.format()) + "' not compiled into this binary.");
                }
Esempio n. 21
0
                std::unique_ptr<osmium::io::detail::InputFormat> create_input(const osmium::io::File& file, osmium::osm_entity_bits::type read_which_entities, osmium::thread::Queue<std::string>& input_queue) {
                    file.check();

                    auto it = m_callbacks.find(file.format());
                    if (it != m_callbacks.end()) {
                        return std::unique_ptr<osmium::io::detail::InputFormat>((it->second)(file, read_which_entities, input_queue));
                    }

                    throw std::runtime_error(std::string("Support for input format '") + as_string(file.format()) + "' not compiled into this binary.");
                }
Esempio n. 22
0
		void remove(hash_type hash, wchar_t c)
		{
			auto it = map.find(c);
			if(it == map.end())
				return;

			auto &container = it->second;
			auto iter = std::find_if(container.begin(), container.end(), [&hash](container_type::value_type &v){return std::get<0>(v) == hash;});
			if(iter != container.end())
				container.erase(iter);
		}
Esempio n. 23
0
 create_parser_type get_creator_function(const osmium::io::File& file) {
     auto it = m_callbacks.find(file.format());
     if (it == m_callbacks.end()) {
         throw unsupported_file_format_error(
                 std::string("Can not open file '") +
                 file.filename() +
                 "' with type '" +
                 as_string(file.format()) +
                 "'. No support for reading this format in this program.");
     }
     return it->second;
 }
Esempio n. 24
0
		void remove_handler_helper(hash_type hash, unsigned id, Integers... ids)
		{
			auto it = map.find(id);
			if(it == map.end())
				return;

			auto &container = it->second;
			auto iter = std::find_if(container.begin(), container.end(), [&hash](container_type::value_type &v){return std::get<0>(v) == hash;});
			if(iter != container.end())
				container.erase(iter);

			remove_handler_helper(hash, ids...);
		}
Esempio n. 25
0
                std::unique_ptr<osmium::io::detail::OutputFormat> create_output(const osmium::io::File& file, future_string_queue_type& output_queue) {
                    auto it = m_callbacks.find(file.format());
                    if (it != m_callbacks.end()) {
                        return std::unique_ptr<osmium::io::detail::OutputFormat>((it->second)(file, output_queue));
                    }

                    throw unsupported_file_format_error(
                                std::string("Can not open file '") +
                                file.filename() +
                                "' with type '" +
                                as_string(file.format()) +
                                "'. No support for writing this format in this program.");
                }
Esempio n. 26
0
int main(int argc, const char** argv)
{
   std::string text;
   for(int i = 1; i < argc; ++i)
   {
      cout << "Processing file " << argv[i] << endl;
      std::ifstream fs(argv[i]);
      load_file(text, fs);
      fs.close();
      IndexClasses(text);
      cout << class_index.size() << " matches found" << endl;
      map_type::iterator c, d;
      c = class_index.begin();
      d = class_index.end();
      while(c != d)
      {
         cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
         ++c;
      }
      class_index.erase(class_index.begin(), class_index.end());
   }
   return 0;
}
Esempio n. 27
0
inline void dictionary::replace(std::string& key)
{
    using namespace std;
    string copy(key);
    tolower(copy);
    map_type::iterator it = map_.find(key);
    if (it == map_.end())
        return;
    string& value = it->second;
    if (!value.empty() && !key.empty() && std::isupper((unsigned char) key[0]))
        value[0] = std::toupper((unsigned char) value[0]);
    key = value;
    return;
}
Esempio n. 28
0
		bool WindowProc(Derived &, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, LRESULT &lresult)
		{
			if(msg == WM_TIMER){
				auto it = map.find(static_cast<id_type>(wParam));
				if(it != map.end()){
					auto &container = it->second;
					for(auto &tuple: container){
						std::get<1>(tuple)(static_cast<id_type>(wParam));
					}
				}
				static_cast<Derived*>(this)->on_timer(static_cast<id_type>(wParam));
			}

			return true;
		}
Esempio n. 29
0
static std::string urlEncodeParams(map_type const &params)
{
	std::string result;

	typename map_type::const_iterator it;
	for(it=params.begin(); it!=params.end(); it++) {
		if( result.size() ) {
			result += "&";
		}
		urlEncode(it->first.c_str(),result);
		if( !it->second.empty() ) {
			result += "=";
			urlEncode(it->second.c_str(),result);
		}
	}

	return result;
}
label_type most_common(const gather_type& total) {
    typedef gather_type::map_type map_type;
    const map_type m = total.get();

    label_type best_label = 0;
    size_t best_freq = 0;

    for (map_type::const_iterator it = m.begin(); it != m.end(); it++) {
        label_type label = it->first;
        size_t freq = it->second;

        if (freq > best_freq || (freq == best_freq && label < best_label)) {
            best_label = label;
            best_freq = freq;
        }
    }

    return best_label;
}