spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

d:\programme\mingw\bin\..\lib\gcc\mingw32\4.6.2\include\c++\backward\backward_warning.h|33|warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated. [-Wcpp]|
d:\programme\mingw\bin\..\lib\gcc\mingw32\4.6.2\include\c++\backward\hashtable.h||In member function '__gnu_cxx::hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::size_type __gnu_cxx::hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::_M_bkt_num_key(const key_type&, std::size_t) const [with _Val = std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterContainer*>, _Key = std::basic_string<char>, _HashFcn = __gnu_cxx::hash<std::basic_string<char> >, _ExtractKey = std::_Select1st<std::pair<const std::basic_string<char>, ParameterBlock::Generi|
d:\programme\mingw\bin\..\lib\gcc\mingw32\4.6.2\include\c++\backward\hashtable.h:584|55|instantiated from '__gnu_cxx::hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::size_type __gnu_cxx::hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::_M_bkt_num_key(const key_type&) const [with _Val = std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterContainer*>, _Key = std::basic_string<char>, _HashFcn = __gnu_cxx::hash<std::basic_string<char> >, _ExtractKey = std::_Select1st<std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterCont|
d:\programme\mingw\bin\..\lib\gcc\mingw32\4.6.2\include\c++\backward\hashtable.h:588|48|instantiated from '__gnu_cxx::hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::size_type __gnu_cxx::hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::_M_bkt_num(const value_type&) const [with _Val = std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterContainer*>, _Key = std::basic_string<char>, _HashFcn = __gnu_cxx::hash<std::basic_string<char> >, _ExtractKey = std::_Select1st<std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterContai|
d:\programme\mingw\bin\..\lib\gcc\mingw32\4.6.2\include\c++\backward\hashtable.h:670|56|instantiated from '__gnu_cxx::_Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>& __gnu_cxx::_Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>::operator++() [with _Val = std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterContainer*>, _Key = std::basic_string<char>, _HashFcn = __gnu_cxx::hash<std::basic_string<char> >, _ExtractKey = std::_Select1st<std::pair<const std::basic_string<char>, ParameterBlock::GenericParameterContain|
D:\Programme\Blocks 5\Source\parameterblock.h:37|130|instantiated from here|
d:\programme\mingw\bin\..\lib\gcc\mingw32\4.6.2\include\c++\backward\hashtable.h|592|error: no match for call to '(const hasher {aka const __gnu_cxx::hash<std::basic_string<char> >}) (const key_type&)'|
||=== Build finished: 1 errors, 1 warnings ===|

C-/C++-Quelltext

#ifdef __GNUC__
#include <ext/hash_map>
namespace stdext
{
    using namespace __gnu_cxx;
}
#else
#include <hash_map>
#endif

C-/C++-Quelltext

/*** Klasse für eine Parameter-Sammlung ***/

class ParameterBlock
{
public:
    ParameterBlock()
    {
    }

    ParameterBlock(const ParameterBlock& rhs)
    {
        // alle Parameter kopieren
        for(stdext::hash_map<std::string, GenericParameterContainer*>::const_iterator i = rhs.values.begin(); i != rhs.values.end(); ++i)
        {
            values[i->first] = i->second->copy();
        }
    }

    ~ParameterBlock()
    {
        clear();
    }

    ParameterBlock& operator = (const ParameterBlock& rhs)
    {
        clear();

        // alle Parameter kopieren
        for(stdext::hash_map<std::string, GenericParameterContainer*>::const_iterator i = rhs.values.begin(); i != rhs.values.end(); ++i)
        {
            values[i->first] = i->second->copy();
        }

        return *this;
    }

    template<typename T> void set(const std::string& key,
                                  const T& value)
    {
        stdext::hash_map<std::string, GenericParameterContainer*>::iterator i = values.find(key);
        if(i == values.end())
        {
            // Eintrag existiert noch nicht.
            values[key] = new ParameterContainer<T>(value);
        }
        else
        {
            // alten Eintrag löschen, dann überschreiben
            delete i->second;
            i->second = new ParameterContainer<T>(value);
        }
    }

    template<typename T> const T& get(const std::string& key) const
    {
        stdext::hash_map<std::string, GenericParameterContainer*>::const_iterator i = values.find(key);
        if(i == values.end())
        {
            // Eintrag existiert nicht!
            throw 0;
        }
        else
        {
            // versuchen, zu casten
            const GenericParameterContainer* p_container = i->second;
            const ParameterContainer<T>* p_spec = dynamic_cast<const ParameterContainer<T>*>(p_container);
            if(!p_spec)
            {
                // Falscher Typ!
                throw "Falscher Parametertyp!";
            }
            else
            {
                return p_spec->getValue();
            }
        }
    }

    bool has(const std::string& key) const
    {
        stdext::hash_map<std::string, GenericParameterContainer*>::const_iterator i = values.find(key);
        return i != values.end();
    }

    void clear()
    {
        // alle Parameter löschen
        for(stdext::hash_map<std::string, GenericParameterContainer*>::const_iterator i = values.begin(); i != values.end(); ++i)
        {
            delete i->second;
        }

        values.clear();
    }

private:
    class GenericParameterContainer
    {
    public:
        GenericParameterContainer()
        {
        }

        virtual ~GenericParameterContainer()
        {
        }

        virtual GenericParameterContainer* copy()
        {
            return 0;
        }
    };

    template<typename T> class ParameterContainer : public GenericParameterContainer
    {
    public:
        ParameterContainer(const T& value) : myValue(value)
        {
        }

        ~ParameterContainer()
        {
        }

        GenericParameterContainer* copy()
        {
            return new ParameterContainer<T>(myValue);
        }

        const T& getValue() const
        {
            return myValue;
        }

    private:
        const T myValue;
    };

    stdext::hash_map<std::string, GenericParameterContainer*> values;
};

C-/C++-Quelltext

#ifdef __GNUC__
#include <ext/hash_map>
namespace __gnu_cxx {
    template<>
    struct hash<std::string>
    {
        hash<char*> h;
        size_t operator()(const std::string &s) const
        {
            return h(s.c_str());
        };
    };
}
namespace stdext
{
    using namespace __gnu_cxx;
}
#else
#include <hash_map>
#endif