%module namespace_class


%warnfilter(SWIGWARN_PARSE_NAMED_NESTED_CLASS) Ala::Ola;

#ifdef SWIGD
%warnfilter(SWIGWARN_IGNORE_OPERATOR_LT);
#endif

%inline %{
  template<class T> void foobar(T t) {}
  namespace test {
    template<class T> void barfoo(T t) {}
  }  
%}

%template(FooBarInt) ::foobar<int>;
%template(BarFooInt) test::barfoo<int>;


%inline %{
  template <class C>
  struct Bar_T
  {
  };
  
  
  namespace test {
    enum Hello {
      Hi
    };    
    
    struct Test;

    struct Bar  {
      Hello foo(Hello h) {
	return h;
      }
    };

    namespace hola {
      struct Bor;
      struct Foo;
      struct Foobar;
      template <class T> struct BarT {
      };

      template <class T> class FooT;
    }

    template <class T>
    class hola::FooT {
    public:
      Hello foo(Hello h) {
	return h;
      }
      
      T bar(T h) {
	return h;
      }
    };

    namespace hola {
      template <> class FooT<double>;
      template <> class FooT<int>;
    }
    
    template <>
    class hola::FooT<double> {
    public:
      double moo(double h) {
	return h;
      }
    };

    int a;

    struct hola::Foo : Bar {
      Hello bar(Hello h) {
	return h;
      }    
    };
  }
  
  struct test::Test {
    Hello foo(Hello h) {
      return h;
    }
  };

  struct test::hola::Bor {
    Hello foo(Hello h) {
      return h;
    }    
  };

  namespace test {
    struct hola::Foobar : Bar {
      Hello bar(Hello h) {
	return h;
      }    
    };
  }

  template <>
  class test::hola::FooT<int> {
  public:
    int quack(int h) {
      return h;
    }
  };

%}


namespace test
{
  namespace hola {
    %template(FooT_i) FooT<int>;
  }

  %template(FooT_H) hola::FooT<Hello>;
}

%template(FooT_d) ::test::hola::FooT<double>;
%template(BarT_H) test::hola::BarT<test::Hello>;

%inline %{

  namespace hi {
    namespace hello {
      template <class T> struct PooT;
    }

    namespace hello {
      template <class T> struct PooT
      {
      }; 
    }
  }
%}

%template(Poo_i) hi::hello::PooT<int>;

%inline %{

  template <class T> struct BooT {
  };

  namespace test {
    
    typedef ::BooT<Hello> BooT_H;
  }

%}

namespace test {
  
  %template(BooT_H) ::BooT<Hello>;
}
%template(BooT_i) ::BooT<int>;


%inline %{

namespace jafar {
  namespace jmath {
    class EulerT3D {
    public:
      static void hello(){}
      
      template<class VecFrame, class Vec, class VecRes>
      static void toFrame(const VecFrame& frame_, const Vec&v_,const VecRes& vRes){}
      
      template<class T>
      void operator ()(T& x){}

      template<class T>
      void operator < (T& x){}
      
      template<class T>
      operator Bar_T<T> () {}

    };
  }
}
%}

%template(toFrame) jafar::jmath::EulerT3D::toFrame<int,int,int>;
%template(callint) jafar::jmath::EulerT3D::operator()<int>;
%template(lessint) jafar::jmath::EulerT3D::operator < <int>;
%template(callfooi) jafar::jmath::EulerT3D::operator() <test::hola::FooT<int> >;
%template(lessfooi) jafar::jmath::EulerT3D::operator < < test::hola::FooT<int> >;


%inline %{

namespace {
  /* the unnamed namespace is 'private', so, the following
     declarations shouldn't be wrapped */
  class Private1
  {
  };

}

namespace a
{
  namespace 
  {
    class Private2
    {
    };
  }
}
 
%}

%inline %{
  class Ala {
  public : 
    Ala() {}
    class Ola {
    public:
      Ola() {}
      void eek() {}
    };
    
    template <class T>
    static void hi() 
    {
    }
  };
%}


%template(hi) Ala::hi<int>;

%extend jafar::jmath::EulerT3D 
{
  
}

%rename(FLACFile) TagLib::FLAC::File;

%inline {
namespace TagLib
{
  class File {
  public:
    File() {}
  };

  class AudioProperties {
  };

  class AudioPropertiesFile {
  public:
    typedef TagLib::File File;
  };
  
  namespace FLAC
  {
    class File;
    class Properties : public AudioProperties  {
    public:
      Properties(File *) {}
    };

    class PropertiesFile : public AudioPropertiesFile  {
    public:
      PropertiesFile(File * = 0) {}
    };

    namespace bar {
      class PropertiesFree  : public AudioProperties  {
      public:
	PropertiesFree(File *) {}
      };
    }

    class FooFilePrivate : private PropertiesFile  {
    public:
      FooFilePrivate(File *) {}
    };

    class FooFile : public PropertiesFile  {
    public:
      FooFile(File *) {}
    };

    class File {
    public:
      File() {}
    };
  }
}
}