We have a use-case for sending a dictionary back to C++. In order to then extract the values out of the CScriptDictionary, it's necessary to be able to access the type id of the values. Please consider something along these lines for inclusion in the dictionary add-on:

Index: scriptdictionary.cpp
===================================================================
--- scriptdictionary.cpp	(revision 1855)
+++ scriptdictionary.cpp	(working copy)
@@ -408,6 +408,32 @@
 	return array;
 }

+// Get a map of keys to their value type id
+std::map<std::string, int> CScriptDictionary::GetKeyToValueTypeIdMap() const
+{
+	std::map<std::string, int> keyToTypeId;
+
+	for ( map<std::string, valueStruct>::const_iterator iter = dict.begin();
+	      iter != dict.end();
+	      ++iter )
+	{
+		keyToTypeId[iter->first] = iter->second.typeId;
+	}
+
+	return keyToTypeId;
+}
+
+// Get the type id of a key's value
+int CScriptDictionary::GetTypeIdForKey(const std::string &key) const
+{
+	map<std::string, valueStruct>::const_iterator it = dict.find(key);
+
+	if( it != dict.end() )
+		return it->second.typeId;
+	else
+		return 0;
+}
+
 //--------------------------------------------------------------------------
 // Generic wrappers

Index: scriptdictionary.h
===================================================================
--- scriptdictionary.h	(revision 1855)
+++ scriptdictionary.h	(working copy)
@@ -72,6 +72,12 @@
 	// Get an array of all keys
 	CScriptArray *GetKeys() const;

+	// Get a map of keys to their value type id
+	std::map<std::string, int> GetKeyToValueTypeIdMap() const;
+
+	// Get the type id of a key's value
+	int GetTypeIdForKey(const std::string &key) const;
+
 	// Garbage collections behaviours
 	int GetRefCount();
 	void SetGCFlag();

Thank you very much.

Having GetKeyToValueTypeIdMap avoids an extra map lookup.

// variant one:
auto keysAndTypes = dictionary.GetKeyToValueTypeIdMap();
for ( keysAndTypes )
{
  based on the type, call the right overload of dictionary.Get()
}

// variant two:
for ( dictionary )
{
  call GetTypeIdForKey for this key
  with that type id, call the right Get()
}

With variant one, you go through the map once, and then have one further lookup per key.

With variant two, you go through the map once, but have two lookups per key. This is unnecessary.

We actually only use GetKeyToValueTypeIdMap(), but provided GetTypeIdKey() for convenience/completeness.

I didn't think you'd want to make valueStruct public, but something along these lines would be fine:

    // The structure for holding the values
    struct valueStruct
    {
        union
        {
            asINT64 valueInt;
            double  valueFlt;
            void   *valueObj;
        };
        int   typeId;
    };

    typedef std::map<std::string, valueStruct>  tDictContainer;

    tDictContainer::const_iterator GetContainerBegin() const { return dict.begin(); }
    tDictContainer::const_iterator GetContainerEnd() const { return dict.end(); }

protected:

    ...

Thanks for the suggestion. I tested this and it worked for my use-case:

Index: scriptdictionary.h
===================================================================
--- scriptdictionary.h	(revision 1855)
+++ scriptdictionary.h	(working copy)
@@ -105,6 +105,39 @@

 	// TODO: optimize: Use C++11 std::unordered_map instead
 	std::map<std::string, valueStruct> dict;
+public:
+    class CDictionaryIterator
+    {
+    public:
+        CDictionaryIterator(
+            const CScriptDictionary& _dict,
+            std::map<std::string, CScriptDictionary::valueStruct>::const_iterator _it)
+            : dict(_dict)
+            , it(_it)
+        {}
+
+        void operator++() { ++it; }
+
+        bool operator==(const CDictionaryIterator &other) const { return it == other.it; }
+        bool operator!=(const CDictionaryIterator &other) const { return it != other.it; }
+
+        const std::string &GetKey() const { return it->first; }
+        int GetTypeId() const             { return it->second.typeId; }
+        void *GetAddressOfValue() const   { return it->second.valueObj; }
+
+        bool GetValue(asINT64 &value) const { return dict.Get(GetKey(), value); }
+        bool GetValue(double &value) const  { return dict.Get(GetKey(), value); }
+        bool GetValue(void *value) const    { return dict.Get(GetKey(), value, GetTypeId()); }
+
+    protected:
+        CDictionaryIterator();
+
+        std::map<std::string, CScriptDictionary::valueStruct>::const_iterator it;
+        const CScriptDictionary& dict;
+    };
+
+    CDictionaryIterator begin() const { return CDictionaryIterator(*this, dict.begin()); }
+    CDictionaryIterator end() const   { return CDictionaryIterator(*this, dict.end()); }
 };

 // This function will determine the configuration of the engine

Thanks for this!