enum as key in a std::map

Hi there,

I wish to have an Images singleton object in my program which stores
all my image objects. I then wish to access a particular image via a
unique identifier. To do this, I have created an enum which is equal
in length with the number of images stored in the singleton. I then
use a std::map to store the images with the enum used as the key.

Currently an image contains two strings: a name (used by the image
player) and a file name. An Image object is passed to an ImagePlayer
object elsewhere in my code.

The code I have come up with allows me to check that I am using all
the enum values and that I don't use the same name for an Image more
than once. However, the enum is of course hard coded. Therefore I
can't reuse this code in my other projects which use a different set
of Images, without rewriting the enum.

Have you any ideas how I should solve this problem? Should I give up
on using the enum?

Thanks very much for your help,

Magnus

// Images.h
#pragma once

#include <map>
#include "Image.h"

#define IMAGE_IDS {MOVIE_1, MOVIE_2, MOVIE_3, OLD_MOVIE_1,
OLD_MOVIE_2, SHORT_CLIP}

enum ImageId IMAGE_IDS;

class Images : public std::map<const ImageId, const Image>
{
public:
    static Images& Instance();
    void LoadIntoImagePlayer() const;

private:
    const bool AreAllImageIdsInUse() const;
    const bool AreAllImageNamesUnique() const;
};

// Images.cpp
#include "StdAfx.h"
#include <assert.h>
#include <vector>
#include <set>
#include "Images.h"

Images& Images::Instance()
{
    static Images images;
    return images;
}

const bool Images::AreAllImageIdsInUse() const
{
    // make sure that we're using all our enums
    const ImageId imageIds[] = IMAGE_IDS;
    return this->size()==sizeof(imageIds)/sizeof(ImageId);
}

const bool Images::AreAllImageNamesUnique() const
{
    // ensure that all the images have a unique name
    std::vector<const Image> images;
    std::map<const ImageId, const Image>::const_iterator i=this->begin();
    for(;i!=this->end();++i)
        images.push_back(i->second);
    std::set<const Image> uniqueImageNames(images.begin(),images.end());
    return this->size()==uniqueImageNames.size();
}

void Images::LoadIntoImagePlayer() const
{
    assert(AreAllImageIdsInUse());
    assert(AreAllImageNamesUnique());

    //...
}

// Image.h
#pragma once

#include <string>

class Image
{
public:
    Image();
    Image(const std::string& name, const std::string& fileName);
    Image& operator=(const Image&);
    const bool operator==(const Image&) const;
    const bool operator<(const Image&) const;
    const std::string Name() const;
    const std::string FileName() const;

private:
    std::string m_name;
    std::string m_fileName;
};

// Image.cpp
#include "StdAfx.h"
#include "Image.h"

Image::Image()
    :m_name(""), m_fileName("")
{
}

Image::Image(const std::string& name, const std::string& fileName)
    :m_name(name), m_fileName(fileName)
{
}

Image& Image::operator=(const Image& image)
{
    if (this != &image)
     {
        m_name = image.m_name;
        m_fileName = image.m_fileName;
     }
     return *this;
}

const bool Image::operator==(const Image& image) const
{
    return m_name==image.m_name;
}

const bool Image::operator<(const Image& image) const
{
     return m_name<image.m_name;
}

const std::string Image::Name() const
{
    return m_name;
}

const std::string Image::FileName() const
{
    return m_fileName;
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]