void CommandLineParser::Process
	( 
		const StringStore& commandArgs 
	)
	{
		if ( commandArgs.empty() )
		{
			return;
		}

		commandLine_ = commandArgs[0];

		if ( commandArgs.size() > 1 )
		{
			StringStore::const_iterator current = commandArgs.begin();
			StringStore::const_iterator end		= commandArgs.end();
			while( current != end )
			{
				std::string param( *current );

				if ( helpSwitch == param || helpSwitchLong == param )
				{
					showHelp_ = true;
				}
				else if ( noHeaderSwitch == param || noHeaderSwitchLong == param )
				{
					showHeader_ = false;
				}
				else if ( listTestsSwitch == param || listTestsSwitchLong == param )
				{
					listTests_ = true;
				}
				else if ( listTestSetsSwitch == param || listTestSetsSwitchLong == param )
				{
					listTestSets_ = true;
				}
				else if ( ( testSwitch == param || testSwitchLong == param ) && GetNextParam( current, end, param ) )
				{
					tests_.push_back( param );
				}
				else if ( ( testSetSwitch == param || testSetSwitchLong == param ) && GetNextParam( current, end, param ) )
				{
					testSets_.push_back( param );
				}
				else if ( ( reportSwitch == param || reportSwitchLong == param ) && GetNextParam( current, end, param ) )
				{
					report_ = param;				
				}
				
				if ( current != end )
				{
					++current;
				}
			}
		}
	}
Beispiel #2
0
bool KVEngine::trySwapMaster(StringStore& newMaster, uint64_t version) {
    stdx::lock_guard<stdx::mutex> lock(_masterLock);
    invariant(!newMaster.hasBranch() && !_master.hasBranch());
    if (_masterVersion != version)
        return false;
    _master = newMaster;
    _masterVersion++;
    return true;
}
Beispiel #3
0
                uint32_t add(const char* s) {
                    auto f = m_index.find(s);
                    if (f != m_index.end()) {
                        return uint32_t(f->second);
                    }

                    const char* cs = m_strings.add(s);
                    m_index[cs] = ++m_size;

                    if (m_size > max_entries) {
                        throw osmium::pbf_error("string table has too many entries");
                    }

                    return m_size;
                }
Beispiel #4
0
    void update(const char* value, const Osmium::OSM::Object& object, StringStore& string_store) {
        key.count[object.type()]++;

        value_hash_map_t::iterator values_iterator(values_hash.find(value));
        if (values_iterator == values_hash.end()) {
            Counter counter;
            counter.count[object.type()] = 1;
            values_hash.insert(std::pair<const char*, Counter>(string_store.add(value), counter));
            values.count[object.type()]++;
        } else {
            values_iterator->second.count[object.type()]++;
            if (values_iterator->second.count[object.type()] == 1) {
                values.count[object.type()]++;
            }
        }

        user_hash[object.uid()]++;
    }
Beispiel #5
0
 StringStore::const_iterator end() const {
     return m_strings.end();
 }
Beispiel #6
0
 StringStore::const_iterator begin() const {
     return m_strings.begin();
 }
Beispiel #7
0
 void clear() {
     m_strings.clear();
     m_index.clear();
     m_size = 0;
     m_strings.add("");
 }
Beispiel #8
0
 explicit StringTable(size_t size = default_stringtable_chunk_size) :
     m_strings(size),
     m_index(),
     m_size(0) {
     m_strings.add("");
 }