%module li_std_map

/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * li_std_map.i
 *
 * SWIG test generator for std_map.i
 * Implementation by Yuval Baror (http://yuval.bar-or.org)
 *
 * Note that the basic usage of the std_map.i is:
 *
 *   %include "std_map.i"
 *   %template(Int_Vector) std::vector<int>
 *   %template(Int_Double_Mector) std::map<int, double>
 *
 * In C#, for non-basic types a call to SWIG_STD_MAP_SPECIALIZE must be made. For example:
 *   SWIG_STD_MAP_SPECIALIZE(MyCppKeyClass, MyCppValueClass, MyCsKeyClass, MyCsValueClass)
 *   %template(MyCppKeyClass_Vector) std::vector<MyCppKeyClass >;
 *   %template(MyKeyClass_MyValueClass_Map) std::map<MyCppKeyClass, MyCppValueClass >;
 *
 * Or if the C# class names are the same as the C++ class names, you can use:
 *
 *   SWIG_STD_MAP_SPECIALIZE_SIMPLE(MyKeyClass, MyValueClass)
 *   %template(MyKeyClass_Vector) std::vector<MyCKeyClass >;
 *   %template(MyKeyClass_MyValueClass_Map) std::map<MyKeyClass, MyValueClass >;
 *
 * ----------------------------------------------------------------------------- */

%include "std_map.i"
%include "std_vector.i"
%include "std_string.i"

// Declare some vector templates to be used as keys for the maps
%template(IntVector) std::vector<int>;
%template(StringVector) std::vector<std::string>;
%template(BoolVector) std::vector<bool>;
%template(CharVector) std::vector<char>;
%template(DoubleVector) std::vector<double>;

// Declare some maps to play around with
%template(IntIntMap) std::map<int, int>;
%template(StringIntMap) std::map<std::string, int>;


// Add an inline function to test
%inline %{

double keyAverage(std::map<int, int> m) {
    if (m.size() == 0)
    {
      return 0.0;
    }
    
    double a = 0.0;
    for (std::map<int, int>::iterator i = m.begin(); i != m.end(); i++)
    {
      a += i->first;
    }
    
    return a / m.size();

}
    
struct Struct {
  double num;
  Struct() : num(0.0) {}
  Struct(double d) : num(d) {}
};


%}

#if defined(SWIGCSHARP)

// Specialize some more non-default map types
SWIG_STD_MAP_SPECIALIZED(int, int *, int, SWIGTYPE_p_int)
SWIG_STD_MAP_SPECIALIZED(int, const int *, int, SWIGTYPE_p_int)
SWIG_STD_MAP_SPECIALIZED_SIMPLE(int, Struct)
SWIG_STD_MAP_SPECIALIZED(int, Struct *, int, Struct)
SWIG_STD_MAP_SPECIALIZED(int, const Struct *, int, Struct)
SWIG_STD_MAP_SPECIALIZED(Struct *, int, Struct, int)

#endif

#if !defined(SWIGR)

// Test out some maps with pointer types
%template(IntIntPtrMap) std::map<int, int *>;
%template(IntConstIntPtrMap) std::map<int, const int *>;

#endif

// Test out some maps with non-basic types and non-basic pointer types
%template(IntStructMap) std::map<int, Struct>;
%template(IntStructPtrMap) std::map<int, Struct *>;
%template(IntStructConstPtrMap) std::map<int, const Struct *>;
%template(StructPtrVector) std::vector<Struct *>;
%template(StructPtrIntMap) std::map<Struct *, int>;

// Test out a non-specialized map
%template(LongIntMap) std::map<long, int>;



#if defined(SWIGRUBY)
%template(LanguageVector) std::vector< swig::LANGUAGE_OBJ >;

%inline {
  std::vector< swig::LANGUAGE_OBJ > LanguageVector; 
}

#endif