C++ HashTable::begin方法代码示例

const filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::
pyrolysisModelType&
filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::
pyrModel() const
{
    HashTable<const pyrolysisModelType*> models =
        db().time().lookupClass<pyrolysisModelType>();

    forAllConstIter(HashTable<const pyrolysisModelType*>, models, iter)
    {
        if (iter()->regionMesh().name() == pyrolysisRegionName_)
        {
            return *iter();
        }
    }

    FatalErrorIn
    (
        "const filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::"
        "pyrolysisModelType& "
        "filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::"
        "pyrModel() const"
    )
        << "Unable to locate pyrolysis region " << pyrolysisRegionName_
        << abort(FatalError);

    return **models.begin();
}

void Foam::distributedTriSurfaceMesh::distributeFields
(
    const mapDistribute& map
)
{
    typedef DimensionedField<Type, triSurfaceGeoMesh> DimensionedSurfField;

    HashTable<DimensionedSurfField*> fields
    (
        objectRegistry::lookupClass<DimensionedSurfField>()
    );

    for
    (
        typename HashTable<DimensionedSurfField*>::iterator fieldIter =
            fields.begin();
        fieldIter != fields.end();
        ++fieldIter
    )
    {
        DimensionedSurfField& field = *fieldIter();

        label oldSize = field.size();

        map.distribute(field);

        if (debug)
        {
            Info<< "Mapped " << field.typeName << ' ' << field.name()
                << " from size " << oldSize << " to size " << field.size()
                << endl;
        }
    }
}

bool StaticHashTableBuilder::generateHashCode (FILE * out, const std::string& typeName) {
	if (mHashes.empty()) return false;
	int mod = calcBestModulus();
	HashTable table;
	calcHashTable(mod, &table);

	// Lookup structure
	fprintf (out, "\t// hash table lookup structure\n");
	fprintf (out, "\tconst int hashTable[] = {0");
	{
		int current     = table[0].size() + 1; // + null element
		int nullElement = table[0].size();
		for (int i = 1; i < mod; i++) {
			if (table[i].empty()){
				fprintf (out, ", %d", nullElement); // just point to null element
			} else {
				fprintf (out, ", %d", current);     // full entry.
				current+=table[i].size() + 1;
			}
		}
		fprintf (out, "};\n");
	}

	// Table
	fprintf (out, "\t// hash table\n");
	fprintf (out, "\tstruct HashEntry { const char * name; %s value; };\n", typeName.c_str());
	fprintf (out, "\tconst HashEntry entries[] = {\n");
	bool firstOutElement = true;
	bool firstInElement  = true;
	for (HashTable::const_iterator i = table.begin(); i != table.end(); i++){
		if (!firstInElement && i->empty()) continue;
		for (std::vector<StaticHashTableBuilder::KeyValue>::const_iterator j = i->begin(); j != i->end(); j++){
			fprintf (out, "\t\t");
			if (!firstOutElement) { fprintf (out, ","); }
			firstOutElement = false;
			fprintf (out, "{\"%s\", %s}\n", j->first.c_str(), j->second.c_str());
		}
		fprintf (out, "\t\t");
		if (!firstOutElement) { fprintf (out, ","); }
		firstOutElement = false;
		fprintf (out, "{0, %s()}\n", typeName.c_str());
		firstInElement = false;
	}
	fprintf (out, "\t};\n");

	// Lookup function
	fprintf (out, "\t// lookup\n");
	fprintf (out, "\t%s value;\n", typeName.c_str());
	fprintf (out, "\tbool foundKey = false;\n");
	fprintf (out, "\tint hashCode = sf::hash ((unsigned char*) key) %% %d;\n", mod);
	fprintf (out, "\tconst HashEntry * entry = entries + hashTable[hashCode];\n");
	fprintf (out, "\twhile (entry->name != 0){\n");
	fprintf (out, "\t\tif(strcmp (entry->name, key) == 0) {value = entry->value; foundKey = true; break; }\n");
	fprintf (out, "\t\tentry++;\n");
	fprintf (out, "\t}\n");
	return true;
}

void free_hashtab(HashTable &hashtab) {
    llist* temp;
    for ( auto it = hashtab.begin(); it != hashtab.end(); ++it ) {
        while(it->second!=NULL) {
            temp=it->second;
            it->second = it->second->next;
            delete temp;
        }
    }
}

void collisionTest() {
    printf("test collision add/remove\n");
    
    HashTable<int,collisionHash,intEqual> collisiontable;
    for(int i=0;i<100;i++) {
	collisiontable.add(i);
    }
    for(int i=0;i<100;i+=2) {
	collisiontable.remove(i);
	size_t count = 0;
	for (HashTable<int,collisionHash,intEqual>::iterator i = collisiontable.begin();
	     i != collisiontable.end();i++) {
	    count++;
	}
	INVARIANT(count == collisiontable.size(),
		  boost::format("?! %d %d") % count % collisiontable.size());
    }

    // multiple adds of the same key are *supposed* to add multiple times.
    collisiontable.clear();
    SINVARIANT(collisiontable.size() == 0);
    for(int i=0;i<100;i++) {
	collisiontable.add(i);
	collisiontable.add(i);
    }
    SINVARIANT(collisiontable.size() == 200);

    // remove the keys (each twice)
    for(int i=0;i<100;i++) {
	collisiontable.remove(i, true);
	collisiontable.remove(i, true);
    }
    SINVARIANT(collisiontable.size() == 0);

    // an efficient way to do add/replace
    collisiontable.clear();
    SINVARIANT(collisiontable.size() == 0);
    for(int i=0;i<100;i++) {
	bool replaced;
	collisiontable.addOrReplace(i, replaced);
	SINVARIANT(replaced == false);
	collisiontable.addOrReplace(i, replaced);
	SINVARIANT(replaced == true);
    }
    SINVARIANT(collisiontable.size() == 100);

    // remove, add, remove the keys
    for(int i=0;i<100;i++) {
	collisiontable.remove(i, true);
	collisiontable.add(i);
	collisiontable.remove(i);
    }
    SINVARIANT(collisiontable.size() == 0);
}

void print_hashtab(const HashTable &hashtab) {
    llist* temp;
    for ( auto it = hashtab.begin(); it != hashtab.end(); ++it ) {
        std::cout << it->first << ":";
        temp=it->second;
        while(temp!=NULL) {
            std::cout <<"--> [ " << temp->readid << "," << temp->pos <<" ] " ;
            temp=temp->next;
        }
        std::cout << "\n";
    }
}

int main()
{
	string s;
	HashTable ht;
	HashTable::iterator it = ht.begin();
	ht.Add("pumpururum");
	ht.Add("12345");
	ht.Add("80931283");
	ht.Add("uieiuf");
	cout << ht.Size() << endl;
	system("pause");
	return 0;
}

static bool dumpEngineDocs( const char *outputFile )
{
   // Create the output stream.
   FileStream stream;
   if ( !stream.open( outputFile, Torque::FS::File::Write ) )
   {
      Con::errorf( "dumpEngineDocs - Failed to open output file." );
      return false;
   }

   // First dump all global ConsoleDoc fragments.
   
   for( ConsoleDocFragment* fragment = ConsoleDocFragment::smFirst; fragment != NULL; fragment = fragment->mNext )
      if( !fragment->mClass )
         dumpFragment( stream, fragment );
   
   // Clear the doc groups before continuing,
   smDocGroups.clear();
   
   // Dump enumeration types.
   dumpEnums( stream );
   
   // Dump all global variables.
   dumpVariables( stream );

   // Now dump the global functions.
   Namespace *g = Namespace::find( NULL );
   while( g ) 
   {
      dumpNamespaceEntries( stream, g );
      
      // Dump callbacks.
      dumpGroupStart( stream, "Callbacks" );
      dumpNamespaceEntries( stream, g, true );
      dumpGroupEnd( stream );

      g = g->mParent;
   }

   // Now dump all the classes.
   dumpClasses( stream );

   // Dump pre-declarations for any groups we encountered
   // so that we don't have to explicitly define them.
   HashTable<String,U32>::Iterator iter = smDocGroups.begin();
   for ( ; iter != smDocGroups.end(); iter++ )
      stream.writeText( String::ToString( "/*! @addtogroup %s */\r\n\r\n", iter->key.c_str() ) );

   return true;
}

int main()
{
    HashTable mHash; // C++ hash table
    mHash["Mike C"] = 1234;
    mHash["Charlie M"] = 5678;
    
    mHash.insert(make_pair("peter q", 3456));

    cout << "Hash Table size: " << mHash.size() << endl;

    for(HashTable::iterator hIter= mHash.begin(); hIter != mHash.end(); ++hIter)
    {
	cout << hIter->first << " : " << hIter->second << endl;
    }

    return 0;
}

static const char* test_iterator()
{
    HashTable<int, int> tmp;
    size_t cnt = 0;

    for (HashTable<int, int>::iterator it = tmp.begin();
         it != tmp.end(); ++it)
    {
        ++cnt;
    }
    KJSD_CUNIT_ASSERT(cnt == 0);

    cnt = 0;
    for (HashTable<int, int>::iterator it = htv_->begin();
         it != htv_->end(); ++it)
    {
        ++cnt;
    }
    KJSD_CUNIT_ASSERT(cnt == NUM_OF_TESTELEMENT);

    cnt = 0;
    for (HashTable<string, int>::iterator it = htc_->begin();
         it != htc_->end(); ++it)
    {
        ++cnt;
    }
    KJSD_CUNIT_ASSERT(cnt == NUM_OF_TESTELEMENT);

    cnt = 0;
    for (HashTable<const char*, int>::iterator it = htp_->begin();
         it != htp_->end(); ++it)
    {
        ++cnt;
    }
    KJSD_CUNIT_ASSERT(cnt == NUM_OF_TESTELEMENT);

    HashTable<int, int>::iterator it = htv_->begin();
    int v = (*(it++)).second;
    KJSD_CUNIT_ASSERT(v != (*it).second);

    v = (*(++it)).second;
    KJSD_CUNIT_ASSERT(v == (*it).second);
    return 0;
}

void printFreq(WorkerThread* threads, int cpus, float totalCount) {
    HashTable<KEY_SIZE> sum;
    for (int i=0; i<cpus; i++) {
        merge_table(sum, *((HashTable<KEY_SIZE>*)threads[i].hashByLength(KEY_SIZE)));
    }

    typedef std::pair< Key<KEY_SIZE>, uint32_t > hash_pair_t;
    std::vector<hash_pair_t> list(sum.begin(), sum.end());
    std::sort(list.begin(), list.end(), greater_second<hash_pair_t>());

    for (typename std::vector<hash_pair_t>::iterator it = list.begin(); it < list.end(); ++it) {
        char key[KEY_SIZE+1];
        for (int i=0; i<KEY_SIZE; i++) key[i] = toupper((*it).first.key[i]);
        key[KEY_SIZE] = 0;
        printf("%s %.3f\n", key, (float)((*it).second) * 100.0f / totalCount);
    }
    printf("\n");

}

 virtual void printResult() {
     printf("Begin-%s\n",__PRETTY_FUNCTION__);
     vector<hteData *> vals;
     for (HashTable<hteData, hteHash, hteEqual>::iterator i = stats_table.begin();
         i != stats_table.end();++i) {
         vals.push_back(&(*i));
     }
     sort(vals.begin(),vals.end(),sortByType());
     for (vector<hteData *>::iterator i = vals.begin();
         i != vals.end();++i) {
         hteData *j = *i;
         printf("%10s %ld ents, %.2f MB total size, %.2f kB avg size, %.0f max bytes\n",
                j->type.c_str(),
                j->file_size->count(),
                j->file_size->total() / (1024*1024.0),
                j->file_size->mean() / (1024.0),
                j->file_size->max());
     }
     printf("End-%s\n",__PRETTY_FUNCTION__);
 }

	HashTable(const HashTable& hash_table) : hasher(), n(0), table(*(new table_type(hash_table.Size())))
	{
		for (hash_iterator_type it = hash_table.begin(); it != hash_table.end(); ++it)
			Add(*it);
	}

void merge_table(HashTable<KEY_SIZE>& dest, HashTable<KEY_SIZE>& src) {
    for (typename HashTable<KEY_SIZE>::iterator it = src.begin(); it != src.end(); ++it) {
        dest[(*it).first] += (*it).second;
    }
}

void character_histogram()
{
	HashTable<char, long long> ht;
	std::ifstream input("/home/jacob/Documents/Eclipse Workspace/C++/GenericDataStructures/test_files/PG-MobyDick.txt");
	char c;
	if(input.is_open())
	{
		while(input.get(c))
		{
			if(ht.contains(c))
			{
				ht[c]+=1;
			}
			else
			{
				ht[c] = 1;
			}
		}
	}
	ht.remove('c');
	HashTable<char, long long>::iterator it = *ht.begin();
	while(it.pos() < it.end())
	{
		//std::cout<<"'"<< it.key()<<"'" << "=>"<< it.value() << std::endl;
		it++;
	}
	it--;
	while(it.pos() >= it.begin())
	{
		//std::cout<<"'"<< it.key()<<"'" << "=>"<< it.value() << std::endl;
		it--;
	}

	MinHeap<huff_node*> heap1;
	HashTable<char, long long>::iterator it2 = *ht.begin();
	while(it2.pos() < it2.end())
	{
		huff_node * node = new huff_node;
		node->c = it2.key();
		node->freq = it2.value();
		node->is_leaf = true;
		heap1.insert(node);
		it2++;
	}

	while(heap1.size() > 2)
	{
		huff_node *left = heap1.remove_min(), *right = heap1.remove_min(), *new_node= new huff_node;
		new_node->is_leaf = false;
		new_node->freq = left->freq + right->freq;
		new_node->left = left;
		new_node->right = right;
		heap1.insert(new_node);
	}
	huff_node *left = heap1.remove_min(), *right = heap1.remove_min(), *root= new huff_node;
	root->is_leaf = false;
	root->freq = left->freq + right->freq;
	root->left = left;
	root->right = right;
	//HashTable<char, long long>::iterator it3 = *ht.begin();
	//root is a huffman tree, could be traversed to create a compression algorithm
}