Gecko [ www.casapremiada.novaexata.com.br ]

Name	Size	Permission
carray.i	3.18 KB	-rw-r--r--
class.swg	1.68 KB	-rw-r--r--
cstring.i	5.93 KB	-rw-r--r--
director.swg	2.94 KB	-rw-r--r--
ocaml.i	1.42 KB	-rw-r--r--
ocaml.swg	14.05 KB	-rw-r--r--
ocamldec.swg	5.21 KB	-rw-r--r--
ocamlkw.swg	1.04 KB	-rw-r--r--
preamble.swg	473 B	-rw-r--r--
std_common.i	531 B	-rw-r--r--
std_complex.i	1.51 KB	-rw-r--r--
std_deque.i	722 B	-rw-r--r--
std_list.i	4.22 KB	-rw-r--r--
std_map.i	2.28 KB	-rw-r--r--
std_pair.i	712 B	-rw-r--r--
std_string.i	3.13 KB	-rw-r--r--
std_vector.i	2.69 KB	-rw-r--r--
stl.i	357 B	-rw-r--r--
swig.ml	4.57 KB	-rw-r--r--
swig.mli	1.66 KB	-rw-r--r--
swigp4.ml	6.5 KB	-rw-r--r--
typecheck.i	4.59 KB	-rw-r--r--
typemaps.i	8.83 KB	-rw-r--r--
typeregister.swg	55 B	-rw-r--r--

Code Editor : std_list.i

/* -----------------------------------------------------------------------------
 * std_list.i
 *
 * SWIG typemaps for std::list types
 * ----------------------------------------------------------------------------- */

%include <std_common.i>

%module std_list
%{
#include <list>
#include <stdexcept>
%}

namespace std{
    template<class T> class list
    {
    public:
	     
	typedef T &reference;
	typedef const T& const_reference;
	typedef T &iterator;
	typedef const T& const_iterator; 
	    
	list();
	list(unsigned int size, const T& value = T());
	list(const list<T> &);

~list();
	void assign(unsigned int n, const T& value);
	void swap(list<T> &x);

const_reference front();
	const_reference back();
	const_iterator begin();
	const_iterator end();
	     
	void resize(unsigned int n, T c = T());
	bool empty() const;

void push_front(const T& x);
	void push_back(const T& x);

void pop_front();
	void pop_back();
	void clear();
	unsigned int size() const;
	unsigned int max_size() const;
	void resize(unsigned int n, const T& value);
		
	void remove(const T& value);
	void unique();
	void reverse();
	void sort();
             
	     
		
	%extend 
	    {
		const_reference __getitem__(int i) throw (std::out_of_range) 
		    {
			std::list<T>::iterator first = self->begin(); 
			int size = int(self->size());
			if (i<0) i += size;
			if (i>=0 && i<size)
			{
			    for (int k=0;k<i;k++)
			    {
				first++;
			    }
			    return *first;
			}
			else throw std::out_of_range("list index out of range");
		    }
		void __setitem__(int i, const T& x) throw (std::out_of_range)
		    {
			std::list<T>::iterator first = self->begin(); 
			int size = int(self->size());
			if (i<0) i += size;
			if (i>=0 && i<size)
			{
			    for (int k=0;k<i;k++)
			    {
				first++;
			    }
			    *first = x;
			}
			else throw std::out_of_range("list index out of range");
		    }
		void __delitem__(int i) throw (std::out_of_range)
		    {
			std::list<T>::iterator first = self->begin(); 
			int size = int(self->size());
			if (i<0) i += size;
			if (i>=0 && i<size)
			{
			    for (int k=0;k<i;k++)
			    {
				first++;
			    }
			    self->erase(first);
			}
			else throw std::out_of_range("list index out of range");
		    }	     
		std::list<T> __getslice__(int i,int j) 
		    {
			std::list<T>::iterator first = self->begin();
			std::list<T>::iterator end = self->end();

int size = int(self->size());
			if (i<0) i += size;
			if (j<0) j += size;
			if (i<0) i = 0;
			if (j>size) j = size;
			if (i>=j) i=j;
			if (i>=0 && i<size && j>=0)
			{
			    for (int k=0;k<i;k++)
			    {
				first++;
			    }
			    for (int m=0;m<j;m++)
			    {
				end++;
			    }
			    std::list<T> tmp(j-i);
			    if (j>i) std::copy(first,end,tmp.begin());
			    return tmp;
			}
			else throw std::out_of_range("list index out of range");
		    }
		void __delslice__(int i,int j) 
		    {
			std::list<T>::iterator first = self->begin();
			std::list<T>::iterator end = self->end();

int size = int(self->size());
			if (i<0) i += size;
			if (j<0) j += size;
			if (i<0) i = 0;
			if (j>size) j = size;
	
			for (int k=0;k<i;k++)
			{
			    first++;
			}
			for (int m=0;m<=j;m++)
			{
			    end++;
			}		   
			self->erase(first,end);		
		    }
		void __setslice__(int i,int j, const std::list<T>& v) 
		    {
			std::list<T>::iterator first = self->begin();
			std::list<T>::iterator end = self->end();

int size = int(self->size());
			if (i<0) i += size;
			if (j<0) j += size;
			if (i<0) i = 0;
			if (j>size) j = size;
		
			for (int k=0;k<i;k++)
			{
			    first++;
			}
			for (int m=0;m<=j;m++)
			{
			    end++;
			}
			if (int(v.size()) == j-i) 
			{
			    std::copy(v.begin(),v.end(),first);
			}
			else {
			    self->erase(first,end);
			    if (i+1 <= int(self->size())) 
			    {
				first = self->begin();
				for (int k=0;k<i;k++)
				{
				    first++;
				}
				self->insert(first,v.begin(),v.end());
			    }
			    else self->insert(self->end(),v.begin(),v.end());
			}
			   	
		    }
		unsigned int __len__() 
		    {
			return self->size();
		    }	
		bool __nonzero__()
		    {
			return !(self->empty());
		    }
		void append(const T& x)
		    {
			self->push_back(x);
		    }
		void pop()
		    {
			self->pop_back();
		    }
	      
	    };   
	  
    };
}

${this.title}

Code Editor : std_list.i