1/**
2 * @file   std_queue.i
3 * @date   Sun May  6 01:48:07 2007
4 *
5 * @brief  A wrapping of std::queue for Ruby.
6 *
7 *
8 */
9
10%include <std_container.i>
11
12// Queue
13
14%define %std_queue_methods(queue...)
15  queue();
16  queue( const _Sequence& );
17
18  bool empty() const;
19  size_type size() const;
20  const value_type& front() const;
21  const value_type& back() const;
22  void pop();
23  void push( const value_type& );
24%enddef
25
26%define %std_queue_methods_val(queue...)
27  %std_queue_methods(queue)
28%enddef
29
30// ------------------------------------------------------------------------
31// std::queue
32//
33// const declarations are used to guess the intent of the function being
34// exported; therefore, the following rationale is applied:
35//
36//   -- f(std::queue<T>), f(const std::queue<T>&):
37//      the parameter being read-only, either a sequence or a
38//      previously wrapped std::queue<T> can be passed.
39//   -- f(std::queue<T>&), f(std::queue<T>*):
40//      the parameter may be modified; therefore, only a wrapped std::queue
41//      can be passed.
42//   -- std::queue<T> f(), const std::queue<T>& f():
43//      the queue is returned by copy; therefore, a sequence of T:s
44//      is returned which is most easily used in other functions
45//   -- std::queue<T>& f(), std::queue<T>* f():
46//      the queue is returned by reference; therefore, a wrapped std::queue
47//      is returned
48//   -- const std::queue<T>* f(), f(const std::queue<T>*):
49//      for consistency, they expect and return a plain queue pointer.
50// ------------------------------------------------------------------------
51
52%{
53#include <queue>
54%}
55
56// exported classes
57
58namespace std {
59
60  template<class _Tp, class _Sequence = std::deque<_Tp> >
61  class queue {
62  public:
63    typedef size_t size_type;
64    typedef _Tp value_type;
65    typedef value_type& reference;
66    typedef const value_type& const_reference;
67    typedef _Sequence container_type;
68
69    %traits_swigtype(_Tp);
70
71    %fragment(SWIG_Traits_frag(std::queue<_Tp, _Sequence >), "header",
72	      fragment=SWIG_Traits_frag(_Tp),
73	      fragment="StdQueueTraits") {
74      namespace swig {
75	template <>  struct traits<std::queue<_Tp, _Sequence > > {
76	  typedef pointer_category category;
77	  static const char* type_name() {
78	    return "std::queue<" #_Tp "," #_Sequence " >";
79	  }
80	};
81      }
82    }
83
84    %typemap_traits_ptr(SWIG_TYPECHECK_QUEUE, std::queue<_Tp, _Sequence >);
85
86#ifdef %swig_queue_methods
87    // Add swig/language extra methods
88    %swig_queue_methods(std::queue<_Tp, _Sequence >);
89#endif
90
91    %std_queue_methods(queue);
92  };
93
94  template<class _Tp, class _Sequence >
95  class queue<_Tp*, _Sequence > {
96  public:
97    typedef size_t size_type;
98    typedef _Tp value_type;
99    typedef value_type& reference;
100    typedef const value_type& const_reference;
101    typedef _Sequence container_type;
102
103    %traits_swigtype(_Tp);
104
105    %fragment(SWIG_Traits_frag(std::queue<_Tp*, _Sequence >), "header",
106	      fragment=SWIG_Traits_frag(_Tp),
107	      fragment="StdQueueTraits") {
108      namespace swig {
109	template <>  struct traits<std::queue<_Tp*, _Sequence > > {
110	  typedef value_category category;
111	  static const char* type_name() {
112	    return "std::queue<" #_Tp "," #_Sequence " * >";
113	  }
114	};
115      }
116    }
117
118    %typemap_traits_ptr(SWIG_TYPECHECK_QUEUE, std::queue<_Tp*, _Sequence >);
119
120#ifdef %swig_queue_methods_val
121    // Add swig/language extra methods
122    %swig_queue_methods_val(std::queue<_Tp*, _Sequence >);
123#endif
124
125    %std_queue_methods_val(std::queue<_Tp*, _Sequence >);
126  };
127
128}
129
130