shattered_ogrerb 0.5.0.1

data/vendor/ogrerb/build/ois/extconf.rb

@@ -0,0 +1,48 @@
+require 'mkmf'
+require '../../platform'
+
+def append_cpp_flags(flags)
+  flags = [flags] unless flags.is_a?(Array)
+  with_cppflags("#{$CPPFLAGS} #{flags.join(' ')}") { true }
+end
+
+def append_ld_flags(flags)
+  flags = [flags] unless flags.is_a?(Array)
+  with_ldflags("#{$LDFLAGS} #{flags.join(' ')}") { true }
+end
+
+#OIS SDK
+append_cpp_flags "-I\"../../src_headers/OIS\""
+append_cpp_flags "-I\"../../src_headers/wrappers\""
+#The root directory - for included 'build/ois/' headers.
+append_cpp_flags "-I\"../../\""
+	
+if Platform.linux?
+	# A few extra includes
+	append_cpp_flags %w(-Wall)
+	
+	includes, lib_args = pkg_config("OIS")
+	append_cpp_flags(includes) 
+	append_ld_flags(lib_args)
+	#$libs = append_library($libs, "OIS")
+	
+elsif Platform.windows?
+	#Various windows definitions
+	append_cpp_flags "/EHsc /MD /TP /c"
+	# Erase extra nasty flags, don't know where they are coming from
+	$CFLAGS = ""
+	#Platform SDK
+	append_cpp_flags "-I\"#{ENV["MSSdk"]}\""
+	#Visual Studio SDK
+	append_cpp_flags "-I\"#{ENV["VCInstallDir"]}/include\""
+
+	#Ogre libs
+	append_ld_flags "-MD -MT"
+	append_ld_flags "-link"
+	
+	append_ld_flags "-libpath:\"#{ENV["OGRE_HOME"]}/lib\""
+	append_ld_flags "OIS.lib"
+	
+end
+
+create_makefile('ruby_ois')

data/vendor/ogrerb/doc_src/ogre.rb

@@ -0,0 +1,152 @@
+#
+# = Naming Conventions
+#
+# Ogre.rb is using the <tt>--autorename</tt> flag available in SWIG-Ruby. This automatically
+# renames constants, methods, and attributes to follow the Ruby Way. Mainly, this means that
+# method names are the same as Ogre's, but follow this style:
+#
+#   ClassName.method_name(param1, param2, ...)
+#   var.method_name?   # for methods who return boolean results
+#
+# Because there are setter methods in Ogre that can take multiple parameters 
+# (e.g. SceneManager::setSkyBox), we've decided to not turn set/get methods into the typical 
+# attr_accessor names of Ruby. So, this method would be used in Ogre.rb as such:
+# 
+#   scene_manager.set_sky_box(true, "CloudySky")
+#
+# I will try to document every method rename that differs from straight undercasing of Ogre method names,
+# though please post a patch if I missed one.
+#
+module Ogre
+	# This class is here to define a few things that were difficult / not
+	# working correctly just through SWIG. These methods are defined so as not to be any different
+	# from calling the constants straight from Ogre (Vector3.ZERO).
+	#
+	# See OgreVector3.i for an example, but basically we need to define these manually
+	# because Ruby always passes references, which causes annoying problems such as:
+	# 
+	#   vec1 = Ogre::Vector3.ZERO
+	#   vec1.x = 10 
+	#   vec2 = Ogre::Vector3.ZERO
+	#   vec2.x        #=> 10 (when it should be 0)
+	#  
+	# Current classes with constants redefined as methods in lib/constants.rb: 
+	#
+	#   Vector3
+	#
+	module Constants
+	end
+	
+	class FrameEvent
+		# Function wrapper for the timeSinceLastFrame variable
+		def time_since_last_frame
+		end
+
+		# Function wrapper for the timeSinceLastEvent variable
+		def time_since_last_event
+		end
+	end
+
+  # As it stands, all classes with internal Listener classes (aka Resource) have been neutered to not
+  # allow access to these inner classes. As Ruby is perfectly fine with inner classes, this may need
+  # to be a change to the ruby SWIG driver. So for now, these classes and the related functions
+  # are unavailable through Ogre.rb.
+  class Listeners
+  end
+
+  # MovableObject is used extensively in Ogre, but very rarely is an instance of the class created through
+  # the typical "new MovableObject();" syntax. Given this, there is no immedate way of knowing what subclass
+  # of MovableObject was actually created, in say, Ogre::SceneManager::createMovableObject:
+  #
+	#	  virtual MovableObject* createMovableObject(const String& name, const String& typeName, const NameValuePairList* params = 0);
+  #
+  # Left alone, every call to this function will return a MovableObject instance instead of the appropriate
+  # subclass, completely destroying expected type information. Thankfully Ogre makes this very easy to 
+  # solve: getMovableType. Every MovableObject has this method which returns the string representation
+  # of the class name it is. Using this string, we can find out what class was actually created and have
+  # SWIG generate the appropriate class type. Thus, we can do the following:
+  #
+  #   trail = scene_manager.create_movable_object("RibbonTrail1", "RibbonTrail", {"numberOfChains" => "2", "maxElements" => "80"}) 
+  #   trail.set_material_name("LightRibbonTrail")
+  #   trail.set_trail_length(400)
+  #
+  # As <tt>trail</tt> is a <tt>#<Ogre::RibbonTrail:0xb6edf718></tt>.
+  #
+  class MovableObject
+  end
+
+  # Any method call that takes an Ogre::NameValuePairList argument should be given a normal Ruby
+  # hash of "key" => "value". Example usage is found in the sample lighting.rb.
+  #
+  # Ogre's SceneManager::createMovableObject is defined as:
+  #
+	#	  virtual MovableObject* createMovableObject(const String& name, const String& typeName, const NameValuePairList* params = 0);
+  #
+  # and can be used in Ogre.rb as:
+  #
+  #   trail = scene_manager.create_movable_object("RibbonTrail1", "RibbonTrail", {"numberOfChains" => "2", "maxElements" => "80"}) 
+  #
+  class NameValuePairList
+  end
+
+	class RenderWindow
+		# Renamed: isClosed
+		def closed?
+		end
+	end
+
+	class Singleton
+		# Renamed: getSingleton
+		def self.instance
+		end
+	end
+
+	class SceneManager
+		# Renamed: getRootSceneNode
+		def root_scene_node
+		end
+	end
+
+  class TextureManager
+    # There is currently an issue with create_manual in that if you try to use the 
+    # method version that does not include the depth parameter (such as in Ogre's 
+    # RenderToTexture demo), SWIG still chooses this
+    # one, sending in the render_type parameter as the pixel_format. If you run into an unexpected
+    # assert failure in PixelFormat, make sure that you're method call
+    # signature matches this method's parameter list.
+    #
+    # num_mip_maps can be -1 to use the system's default number of mip maps
+    #
+    # depth must be >= 1 or the method will never return
+    #
+    # Ogre's docs for this class are here: http://www.ogre3d.org/docs/api/html/classOgre_1_1TextureManager.html
+    def create_manual(name, group_name, tex_type, width, height, depth, num_mip_maps, pixel_format, render_type, manual_loader = nil)
+    end
+  end
+
+	# There is a problem, possibly unsolvable, with trying to send Ruby subclasses of C++ classes
+	# back into C++ methods. This came up in situations like registering a custom FrameListener. 
+	# It basically doesn't work, and ends up causing all sorts of issues from random SegFaults at
+	# runtime to ObjectPreviouslyDeleted errors at the method's invocation. To get around this 
+	# problem, these proxy classes have been defined. They are simple C++ subclasses that take
+	# care of whatever registering needs to happen inside of their constructor. 
+	#
+	# Also please note: <b>This Proxies namespace does not exist in Ogre.rb</b>. The classes are grouped
+	# this way for documentation purposes.
+	module Proxies
+		# FrameListenerProxy constructor takes the Root object, with which it registers itself as a system
+		# frame listener.
+		class FrameListenerProxy
+			def initialize(root)
+			end
+		end
+
+		# This proxy isn't quite done yet, as it's registering command, 
+		# WindowEventUtilities::addWindowEventListener, takes both the Listener and a RenderWindow. 
+		# It's the RenderWindow that is causing problems but I think this one is easily solvable.
+		class WindowEventListenerProxy
+			def initialize(render_window)
+			end
+		end
+	end
+end

data/vendor/ogrerb/doc_src/ois.rb

@@ -0,0 +1,67 @@
+# OIS has been completely wrapped into Ruby. Any of OIS's classes documented here are to describe
+# special cases or functionality changes required to make this work for Ruby.
+module OIS
+
+	class InputManager
+		# As with Ogre::MovableObject and Ogre::Resource, the usage of <tt>create_input_object</tt> will automatically
+		# return the proper type of OIS::Object whether it be a Mouse, Keyboard, or JoyStick.
+		#
+		# See Ogre::ApplicationFrameListener for an example of where this is used.
+		def create_input_object(obj_type, is_buffered)
+		end
+
+		# See OIS::ParamList
+		def create_input_system(param_list)
+		end
+	end
+
+	class Keyboard
+		# Renamed: isKeyDown
+		def key_down?(key)
+		end
+	end
+
+	class Mouse
+		# Renamed: getMouseState
+		def mouse_state
+		end
+	end
+
+	class MouseState
+		# Renamed: buttonDown
+		def button_down?(button)
+		end
+	end
+
+	# Any OIS function that uses a ParamList as a parameter type will now require a simple Ruby
+	# hash construct. For example, <tt>InputManager.createInputSystem</tt> is now used as such:
+	#
+	#   windowHnd = @window.get_custom_attribute_unsigned_long("WINDOW")
+	#   InputManager.create_input_system( { "WINDOW" => "#{windowHnd}" } )
+	#
+	# With <tt>create_input_system</tt>, the version that simply takes a size_t has been disabled because it
+	# was causing problems.
+	class ParamList
+	end
+
+	# See Ogre::Proxies for an explaination of the existance of these classes. See src_headers/wrappers/OISProxies.h.
+	#
+	# Also please note: <b>This Proxies namespace does not exist in Ogre.rb</b>. The classes are grouped this way
+	# for documentation purposes.
+	module Proxies
+		class KeyListenerProxy
+			def initialize(keyboard)
+			end
+		end
+
+		class MouseListenerProxy
+			def initialize(mouse)
+			end
+		end
+
+		class JoyStickListenerProxy
+			def initialize(joy_stick)
+			end
+		end
+	end
+end

data/vendor/ogrerb/lib/constants.rb

@@ -0,0 +1,35 @@
+module Ogre
+	class Vector3
+		def self.ZERO
+			Vector3.new(0, 0, 0)
+		end
+
+		def self.UNIT_X
+			Vector3.new(1, 0, 0)
+		end
+
+		def self.UNIT_Y
+			Vector3.new(0, 1, 0)
+		end
+
+		def self.UNIT_Z
+			Vector3.new(0, 0, 1)
+		end
+
+		def self.NEGATIVE_UNIT_X
+			Vector3.new(-1, 0, 0)
+		end
+
+		def self.NEGATIVE_UNIT_Y
+			Vector3.new(0, -1, 0)
+		end
+
+		def self.NEGATIVE_UNIT_Z
+			Vector3.new(0, 0, -1)
+		end
+
+		def self.UNIT_SCALE
+			Vector3.new(1, 1, 1)
+		end
+	end
+end

data/vendor/ogrerb/navi/Navi.i

@@ -0,0 +1,5 @@
+%{
+  #include "Navi.h"
+%}
+
+%include "Navi.h"

data/vendor/ogrerb/navi/NaviData.i

@@ -0,0 +1,18 @@
+%{
+  #include "NaviData.h"
+%}
+
+// TODO: These ignores do not seem to work.  They do not stop the extend from working, though
+%ignore NaviLibrary::NaviData::get(std::string paramName, float &paramValOut, bool caseSensitive);
+%ignore NaviLibrary::NaviData::get(std::string paramName, int &paramValOut, bool caseSensitive);
+%ignore NaviLibrary::NaviData::get(std::string paramName, std::string &paramValOut, bool caseSensitive);
+
+%include "NaviData.h"
+
+%extend NaviLibrary::NaviData {
+	std::string get(std::string paramName, bool caseSensitive=false) {
+		std::string retv;
+		$self->get(paramName, retv, caseSensitive);
+		return retv;
+	}
+}

data/vendor/ogrerb/navi/NaviManager.i

@@ -0,0 +1,5 @@
+%{
+  #include "NaviManager.h"
+%}
+
+%include "NaviManager.h"

data/vendor/ogrerb/navi/NaviProxies.i

@@ -0,0 +1,7 @@
+%{
+	#include "NaviProxies.h"
+%}
+
+%director NaviLibrary::NaviEventListenerProxy;
+
+%include "NaviProxies.h"

data/vendor/ogrerb/navi/navi_rb.i

@@ -0,0 +1,53 @@
+/*
+ * Navi.rb main interface file
+ */
+
+%module(directors="1") navi
+%{
+#ifdef bind
+	#undef bind
+#endif
+#ifdef close
+	#undef close
+#endif
+#ifdef snprintf
+	#undef snprintf
+#endif
+#ifdef vsnprintf
+	#undef vsnprintf
+#endif
+#ifdef shutdown
+	#undef shutdown
+#endif
+
+// Caused conflict on windows
+//#include <ext/hash_map>
+
+#include "Navi.h"
+using namespace NaviLibrary;
+
+%}
+
+// Tell SWIG to keep track of mappings between C++ classes
+//%trackobjects;
+
+%exception {
+	try {
+		$function
+	} catch(Ogre::Exception e) {
+		printf(e.getFullDescription().c_str());
+		throw "OGRE exception";
+	}
+}
+
+// std library typemaps and ogre templates
+%include std_string.i
+%include std_vector.i
+%include std_pair.i
+%include std_map.i
+%include std_multimap.i
+
+%include Navi.i
+%include NaviData.i
+%include NaviProxies.i
+%include NaviManager.i

data/vendor/ogrerb/navi/std_multimap.i

@@ -0,0 +1,581 @@
+
+
+
+%include <std_common.i>
+
+%{
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+
+/*
+ This is NOT finished! Use std_map.i for ruby as a guide. What needs to be done:
+ - template specializiation for base types other than String,String
+ - %defines for KEY only, and VALUE only (do a find for specialize_std_on_value (and key))
+ - actually put type maps in for cross language compatability (right now can't ship a hash off to c, etc)
+*/
+
+%include std_vector.i
+
+
+namespace std {
+    
+    /*class multimap {
+    public:
+         %template(Container) std::vector<T *>;
+    };*/
+    template<class K, class T> class multimap {
+    public:
+        
+        %typemap(in) multimap<K,T> (std::multimap<K,T>* m) {
+
+                SWIG_ConvertPtr($input, (void **) &m, $&1_descriptor, 1);
+                $1 = *m;
+            
+        }
+        %typemap(in) const multimap<K,T>& (std::multimap<K,T> temp,
+                                      std::multimap<K,T>* m),
+                     const multimap<K,T>* (std::multimap<K,T> temp,
+                                      std::multimap<K,T>* m) {
+
+   
+                SWIG_ConvertPtr($input, (void **) &m, $1_descriptor, 1);
+                $1 = m;
+        }
+        
+    /*    %typemap(out) multimap<K,T> {
+            printf("multimap out");
+            $result = $1;
+        }
+        
+        %typemap(out) multimap<K,T>* {
+            printf("multimap ptr out");
+            $result = SWIG_NewPointerObj((void *) $1,
+                                         $descriptor(T *), 1);
+        }*/
+        /*
+        %typemap(out) map<K,T> {
+            $result = rb_hash_new();
+            for (std::map<K,T >::iterator i=$1.begin(); i!=$1.end(); ++i) {
+                K* key = new K(i->first);
+                T* val = new T(i->second);
+                rb_hash_aset($result,
+                             SWIG_NewPointerObj((void *) key, 
+                                                $descriptor(K *), 1),
+                             SWIG_NewPointerObj((void *) val, 
+                                                $descriptor(T *), 1));
+            }
+        }*/
+        %typecheck(SWIG_TYPECHECK_MULTIMAP) multimap<K,T> {
+                std::multimap<K,T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $&1_descriptor,0) != -1)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            
+        }
+        %typecheck(SWIG_TYPECHECK_MULTIMAP) const multimap<K,T>&,
+                                       const multimap<K,T>* {
+    
+                /* wrapped multimap? */
+                std::multimap<K,T >* m;
+                if (SWIG_ConvertPtr($input,(void **) &m,
+                                    $1_descriptor,0) != -1)
+                    $1 = 1;
+                else
+                    $1 = 0;
+            
+        }
+        
+        multimap();
+        multimap(const multimap<K,T> &);
+        /*%rename(__len__) size;
+        %rename("empty?") empty;
+        %rename("has_key?") has_key;
+        %rename("delete") __delitem__;*/
+        %ignore has_key;
+        %ignore empty;
+        %ignore size;
+        %ignore __delitem__;
+        
+        
+        %extend {
+            
+            std::vector<T> __getitem__(const K& key) throw (std::out_of_range)
+            {
+              
+                
+                std::multimap<K,T>::iterator
+                    lower = self->lower_bound(key),
+                    upper = self->upper_bound(key);
+                
+            
+                /*
+                VALUE ary;
+                if (lower != upper) {
+                    ary = rb_ary_new();
+                    for (; lower != upper; lower++) {
+                        rb_ary_push(ary,
+                                    SWIG_NewPointerObj((void *) &(*lower),
+                                                    $descriptor(T *),1));
+                    }
+                } else
+                    throw std::out_of_range("key not found");
+                return ary;*/
+                
+                std::vector<T> ary;
+                if (lower != upper) {
+                   // ary = rb_ary_new();
+                    for (; lower != upper; lower++) {
+                        ary.push_back(lower->second);
+                    }
+                } else
+                    throw std::out_of_range("key not found");
+                return ary;
+                    
+            }
+           
+           /*
+            VALUE __getitem__(const K& key) throw (std::out_of_range)
+            {
+              
+                
+                std::multimap<K,T>::iterator
+                    lower = self->lower_bound(key),
+                    upper = self->upper_bound(key);
+                
+                VALUE ary;
+                if (lower != upper) {
+                    ary = rb_ary_new();
+                    for (; lower != upper; lower++) {
+                        rb_ary_push(ary,
+                                    SWIG_NewPointerObj((void *) &(*lower),
+                                                    $descriptor(T *),1));
+                    }
+                } else
+                    throw std::out_of_range("key not found");
+                return ary;
+                    
+            }*/
+            
+            //%template(vecT) std::vector<T>;
+        
+
+            void __setitem__(const K& key, const T& x) {
+              self->insert( std::pair< K, T>(key, x) );
+            }
+            
+            void __delitem__(const K& key) throw (std::out_of_range)
+            {    
+                size_t num_deleted = self->erase(key);
+            }
+            
+            bool has_key(const K& key)
+            {
+                std::multimap<K,T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+            
+            /*VALUE keys()
+            {
+                VALUE keyList = rb_ary_new2(self->size());
+                std::multimap<K,T>::iterator i;
+                unsigned int j;
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    K* ptr = new K(i->first);
+                    rb_ary_store(keyList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $descriptor(K *),1));
+                }
+                return keyList;
+            }*/
+            
+            std::vector<K> keys()
+            {
+                //VALUE keyList = rb_ary_new2(self->size());
+                std::vector<K> keyList;
+                std::multimap<K,T>::iterator i;
+                unsigned int j;
+         
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    keyList.push_back(i->first);
+                  /*  K* ptr = new K(i->first);
+                    rb_ary_store(keyList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $descriptor(K *),1));*/
+                }
+                return keyList;
+            }
+            
+            std::vector<T> values()
+            {
+               // VALUE valueList = rb_ary_new2(self->size());
+                std::multimap<K,T >::iterator i;
+                std::vector<T> valueList;
+                unsigned int j;
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    valueList.push_back(i->second);
+                  /*  T* ptr = new T(i->second);
+                    rb_ary_store(valueList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $descriptor(T *),1));*/
+                }
+                return valueList;
+            }
+            
+            void each()
+            {
+                std::multimap<K,T>::iterator lower = self->begin(),
+                                        end = self->end();
+                //upper = self->upper_bound(lower->first);
+                for (; lower!=end;
+                     lower=self->upper_bound(lower->first))
+                {
+                    VALUE pair = rb_ary_new2(2);
+                    rb_ary_store(pair,0,
+                                 SWIG_NewPointerObj((void*)&lower->first,
+                                                    $descriptor(K*), 1));
+                    
+                    std::multimap<K,T>::iterator upper = self->upper_bound(lower->first);
+            
+                    VALUE ary;
+                    if (lower != upper) {
+                        VALUE ary = rb_ary_new();
+                        for (; lower != upper; lower++) {
+                            rb_ary_push(ary,
+                                        SWIG_NewPointerObj((void *) &(*lower),
+                                                        $descriptor(T *),1));
+                        }
+                    } else
+                        throw std::out_of_range("key not found");
+                    
+                    rb_ary_store(pair,1,ary);
+                    rb_yield(ary);
+                }
+                
+            }
+            
+            
+        }
+        
+    };
+    
+    template<class K, class T>
+    class multimap<K, T*> {
+    public:
+        multimap();
+        multimap(const multimap<K,T*> &);
+        %rename(__len__) size;
+        %rename("empty?") empty;
+        %rename("has_key?") has_key;
+        %rename("delete") __delitem__;
+        
+        
+        %extend {
+           // %template(vecT) std::vector<T>;
+           //%template(Container) std::vector<T *>;
+            std::vector<T> __getitem__(const K& key) throw (std::out_of_range)
+            {
+              
+                
+                std::multimap<K,T*>::iterator
+                    lower = self->lower_bound(key),
+                    upper = self->upper_bound(key);
+                
+            
+                /*
+                VALUE ary;
+                if (lower != upper) {
+                    ary = rb_ary_new();
+                    for (; lower != upper; lower++) {
+                        rb_ary_push(ary,
+                                    SWIG_NewPointerObj((void *) &(*lower),
+                                                    $descriptor(T *),1));
+                    }
+                } else
+                    throw std::out_of_range("key not found");
+                return ary;*/
+                
+                std::vector<T> ary;
+                if (lower != upper) {
+                   // ary = rb_ary_new();
+                    for (; lower != upper; lower++) {
+                        ary.push_back(*lower->second);
+                    }
+                } else
+                    throw std::out_of_range("key not found");
+                return ary;
+                    
+            }
+            
+            //%template(vecT) std::vector<T>;
+        
+
+            void __setitem__(const K& key, const T& x) {
+              self->insert( std::pair< K, T*>(key, new T(x)) );
+            }
+            
+            void __delitem__(const K& key) throw (std::out_of_range)
+            {    
+                size_t num_deleted = self->erase(key);
+            }
+            
+            bool has_key(const K& key)
+            {
+                std::multimap<K,T*>::iterator i = self->find(key);
+                return i != self->end();
+            }
+            
+            std::vector<K> keys()
+            {
+                VALUE keyList = rb_ary_new2(self->size());
+                std::multimap<K,T*>::iterator i;
+                unsigned int j;
+                std::vector<K> keyList;
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    keyList.push_back(i->first);
+                  /*  K* ptr = new K(i->first);
+                    rb_ary_store(keyList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $descriptor(K *),1));*/
+                }
+                return keyList;
+            }
+            
+            std::vector<T*> values()
+            {
+               // VALUE valueList = rb_ary_new2(self->size());
+                std::vector<T*> valueList;
+                std::multimap<K,T*>::iterator i;
+                unsigned int j;
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    T* ptr = new T(*i->second);
+                    valueList.push_back(ptr);
+                    
+                    /*rb_ary_store(valueList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $descriptor(T *),1));*/
+                }
+                return valueList;
+            }
+            
+            void each()
+            {
+                std::multimap<K,T*>::iterator lower = self->begin(),
+                                        end = self->end();
+                //upper = self->upper_bound(lower->first);
+                for (; lower!=end;
+                     lower=self->upper_bound(lower->first))
+                {
+                    VALUE pair = rb_ary_new2(2);
+                    rb_ary_store(pair,0,
+                                 SWIG_NewPointerObj((void*)&lower->first,
+                                                    $descriptor(K*), 1));
+                    
+                    std::multimap<K,T*>::iterator upper = self->upper_bound(lower->first);
+            
+                    VALUE ary;
+                    if (lower != upper) {
+                        VALUE ary = rb_ary_new();
+                        for (; lower != upper; lower++) {
+                            rb_ary_push(ary,
+                                        SWIG_NewPointerObj((void *) &(*lower),
+                                                        $descriptor(T *),1));
+                        }
+                    } else
+                        throw std::out_of_range("key not found");
+                    
+                    rb_ary_store(pair,1,ary);
+                    rb_yield(ary);
+                }
+                
+            }
+            
+            
+        }
+        
+    };
+    
+    //%define specialize_std_multimap_on_key(K,CONVERT_FROM, CONVERT_TO)
+    //%endif
+    //%define specialize_std_multimap_on_value(T,CONVERT_FROM,CONVERT_TO)
+    //%endif
+    %define specialize_std_multimap_on_both(K,CONVERT_K_FROM, CONVERT_K_TO,
+                                            T,CONVERT_T_FROM, CONVERT_T_TO)
+    
+    template<> class multimap<K,T> {
+        
+     /*   %typemap(out) multimap<K,T> {
+            printf("multimap out");
+            $result = $1;
+        }
+        
+        %typemap(out) multimap<K,T>* {
+            printf("multimap ptr out");
+            $result = SWIG_NewPointerObj((void *) $1,
+                                         $descriptor(T *), 1);
+        }*/
+        
+        %rename(__len__) size;
+        %rename("empty?") empty;
+        %rename("has_key?") has_key;
+        %rename("delete") __delitem__;
+        
+    public:
+        multimap();
+        multimap(const multimap<K,T> &);
+   
+        
+        %extend {
+            VALUE __getitem__(const K& key) throw (std::out_of_range)
+            {
+              
+                
+                std::multimap<K,T>::iterator
+                    lower = self->lower_bound(key),
+                    upper = self->upper_bound(key);
+                
+                VALUE ary;
+                if (lower != upper) {
+                    ary = rb_ary_new();
+                    for (; lower != upper; lower++) {
+                        rb_ary_push(ary, CONVERT_T_TO(lower->second));
+                    }
+                } else
+                    throw std::out_of_range("key not found");
+                return ary;
+                    
+            }
+            
+            //%template(vecT) std::vector<T>;
+        
+
+            void __setitem__(const K& key, const T& x) {
+              self->insert( std::pair< K, T>(key, x) );
+            }
+            
+            void __delitem__(const K& key) throw (std::out_of_range)
+            {    
+                size_t num_deleted = self->erase(key);
+            }
+            
+            bool has_key(const K& key)
+            {
+                std::multimap<K,T >::iterator i = self->find(key);
+                return i != self->end();
+            }
+            
+            std::vector<T> keys()
+            {
+               // VALUE keyList = rb_ary_new2(self->size());
+                std::vector<T> keyList;
+                
+                std::multimap<K,T>::iterator i;
+                unsigned int j;
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    /*
+                    K* ptr = new K(i->first);
+                    rb_ary_store(keyList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $descriptor(K *),1));
+                    */
+                    
+                    keyList.push_back(i->first);
+                }
+                return keyList;
+            }
+            
+            std::vector<T> values()
+            {
+                //VALUE valueList = rb_ary_new2(self->size());
+                std::multimap<K,T >::iterator i;
+                std::vector<T> valueList;
+                unsigned int j;
+                for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
+                    /*T* ptr = new T(i->second);
+                    rb_ary_store(valueList,j,
+                                 SWIG_NewPointerObj((void *) ptr,
+                                                    $dSescriptor(T *),1));*/
+                    valueList.push_back(i->second);
+                }
+                return valueList;
+            }
+            
+            void each()
+            {
+           
+                //upper = self->upper_bound(lower->first);
+                printf("specialized on both each");
+                
+                
+                std::multimap<K,T>::iterator lower, end, upper;
+                end = self->end();
+                lower = self->lower_bound(self->begin()->first);
+                upper = self->upper_bound(self->begin()->first);
+        
+        
+                
+                while (lower != end) {
+                        VALUE pair = rb_ary_new2(2);
+                        VALUE ary = rb_ary_new();
+                        
+                        rb_ary_store(pair, 0, CONVERT_K_TO(lower->first));
+                        
+                        lower = self->lower_bound(lower->first);
+                        upper = self->upper_bound(lower->first);
+                        while (lower != upper) {
+                               // std::cout << lower->first << " " << lower->second << std::endl;
+                                rb_ary_push(ary, CONVERT_T_TO(lower->second));
+                                lower++;
+                                
+                        }
+                        rb_ary_store(pair, 1, ary);
+                        rb_yield(pair);
+                }
+                /*
+                for (; lower!=end;
+                     lower=self->upper_bound(lower->first))
+                {
+                    VALUE pair = rb_ary_new2(2);
+                    rb_ary_store(pair,0,
+                                 CONVERT_K_TO(lower->first));
+                                 /*SWIG_NewPointerObj((void*)&lower->first,
+                                                    $descriptor(K*), 1));
+                    
+                    std::multimap<K,T>::iterator upper = self->upper_bound(lower->first);
+            
+                    VALUE ary;
+                    if (lower != upper) {
+                        VALUE ary = rb_ary_new();
+                        for (; lower != upper; lower++) {
+                            rb_ary_push(ary, CONVERT_T_TO(lower->second));
+                                        /*SWIG_NewPointerObj((void *) &(*lower),
+                                                        $descriptor(T *),1));
+                        }
+                    } else
+                        throw std::out_of_range("key not found");
+                    
+                    rb_ary_store(pair,1,ary);
+                    rb_yield(ary);*/
+                
+                
+            }
+            
+            
+        }
+        
+    };
+    %enddef
+    
+    specialize_std_multimap_on_both(std::string, SWIG_RB2STR, SWIG_STR2RB,
+                                    std::string, SWIG_RB2STR, SWIG_STR2RB);
+    
+    
+    
+    
+    
+    
+}