Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
arrays_csharp.i	7.15 KB	-rw-r--r--
boost_intrusive_ptr.i	23.52 KB	-rw-r--r--
boost_shared_ptr.i	14.59 KB	-rw-r--r--
complex.i	109 B	-rw-r--r--
csharp.swg	39.83 KB	-rw-r--r--
csharphead.swg	15.99 KB	-rw-r--r--
csharpkw.swg	1.81 KB	-rw-r--r--
director.swg	1.23 KB	-rw-r--r--
enums.swg	2.87 KB	-rw-r--r--
enumsimple.swg	2.82 KB	-rw-r--r--
enumtypesafe.swg	4.69 KB	-rw-r--r--
std_array.i	6.96 KB	-rw-r--r--
std_auto_ptr.i	928 B	-rw-r--r--
std_common.i	102 B	-rw-r--r--
std_complex.i	2.66 KB	-rw-r--r--
std_deque.i	28 B	-rw-r--r--
std_except.i	2.24 KB	-rw-r--r--
std_list.i	15.34 KB	-rw-r--r--
std_map.i	10.82 KB	-rw-r--r--
std_pair.i	773 B	-rw-r--r--
std_set.i	9.51 KB	-rw-r--r--
std_shared_ptr.i	68 B	-rw-r--r--
std_string.i	3.1 KB	-rw-r--r--
std_vector.i	14.54 KB	-rw-r--r--
std_wstring.i	3.88 KB	-rw-r--r--
stl.i	291 B	-rw-r--r--
swiginterface.i	3.05 KB	-rw-r--r--
swigtype_inout.i	1.44 KB	-rw-r--r--
typemaps.i	10.46 KB	-rw-r--r--
wchar.i	3.54 KB	-rw-r--r--

Code Editor : std_set.i

/* -----------------------------------------------------------------------------
 * std_set.i
 *
 * SWIG typemaps for std::set<T>.
 *
 * Note that ISet<> used here requires .NET 4 or later.
 *
 * The C# wrapper implements ISet<> interface and shares performance
 * characteristics of C# System.Collections.Generic.SortedSet<> class, but
 * doesn't provide quite all of its methods.
 * ----------------------------------------------------------------------------- */

%{
#include <set>
#include <algorithm>
#include <stdexcept>
%}

%csmethodmodifiers std::set::size "private"
%csmethodmodifiers std::set::getitem "private"
%csmethodmodifiers std::set::create_iterator_begin "private"
%csmethodmodifiers std::set::get_next "private"
%csmethodmodifiers std::set::destroy_iterator "private"

namespace std {

// TODO: Add support for comparator and allocator template parameters.
template <class T>
class set {

%typemap(csinterfaces) std::set<T> "global::System.IDisposable, global::System.Collections.Generic.ISet<$typemap(cstype, T)>\n";
%proxycode %{
  void global::System.Collections.Generic.ICollection<$typemap(cstype, T)>.Add($typemap(cstype, T) item) {
      ((global::System.Collections.Generic.ISet<$typemap(cstype, T)>)this).Add(item);
  }

public bool TryGetValue($typemap(cstype, T) equalValue, out $typemap(cstype, T) actualValue) {
    try {
      actualValue = getitem(equalValue);
      return true;
    } catch {
      actualValue = default($typemap(cstype, T));
      return false;
    }
  }

public int Count {
    get {
      return (int)size();
    }
  }

public bool IsReadOnly {
    get {
      return false;
    }
  }

public void CopyTo($typemap(cstype, T)[] array) {
    CopyTo(array, 0);
  }

public void CopyTo($typemap(cstype, T)[] array, int arrayIndex) {
    if (array == null)
      throw new global::System.ArgumentNullException("array");
    if (arrayIndex < 0)
      throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
    if (array.Rank > 1)
      throw new global::System.ArgumentException("Multi dimensional array.", "array");
    if (arrayIndex+this.Count > array.Length)
      throw new global::System.ArgumentException("Number of elements to copy is too large.");

foreach ($typemap(cstype, T) item in this) {
      array.SetValue(item, arrayIndex++);
    }
  }

public void ExceptWith(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    foreach ($typemap(cstype, T) item in other) {
      Remove(item);
    }
  }

public void IntersectWith(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    $csclassname old = new $csclassname(this);

Clear();
    foreach ($typemap(cstype, T) item in other) {
      if (old.Contains(item))
        Add(item);
    }
  }

private static int count_enum(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    int count = 0;
    foreach ($typemap(cstype, T) item in other) {
      count++;
    }

return count;
  }

public bool IsProperSubsetOf(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    return IsSubsetOf(other) && Count < count_enum(other);
  }

public bool IsProperSupersetOf(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    return IsSupersetOf(other) && Count > count_enum(other);
  }

public bool IsSubsetOf(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    int countContained = 0;

foreach ($typemap(cstype, T) item in other) {
      if (Contains(item))
        countContained++;
    }

return countContained == Count;
  }

public bool IsSupersetOf(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    foreach ($typemap(cstype, T) item in other) {
      if (!Contains(item))
        return false;
    }

return true;
  }

public bool Overlaps(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    foreach ($typemap(cstype, T) item in other) {
      if (Contains(item))
        return true;
    }

return false;
  }

public bool SetEquals(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    return IsSupersetOf(other) && Count == count_enum(other);
  }

public void SymmetricExceptWith(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    foreach ($typemap(cstype, T) item in other) {
      if (!Remove(item))
        Add(item);
    }
  }

public void UnionWith(global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)> other) {
    foreach ($typemap(cstype, T) item in other) {
      Add(item);
    }
  }

private global::System.Collections.Generic.ICollection<$typemap(cstype, T)> Items {
    get {
      global::System.Collections.Generic.ICollection<$typemap(cstype, T)> items = new global::System.Collections.Generic.List<$typemap(cstype, T)>();
      int size = this.Count;
      if (size > 0) {
        global::System.IntPtr iter = create_iterator_begin();
        for (int i = 0; i < size; i++) {
          items.Add(get_next(iter));
        }
        destroy_iterator(iter);
      }
      return items;
    }
  }

global::System.Collections.Generic.IEnumerator<$typemap(cstype, T)> global::System.Collections.Generic.IEnumerable<$typemap(cstype, T)>.GetEnumerator() {
    return new $csclassnameEnumerator(this);
  }

global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() {
    return new $csclassnameEnumerator(this);
  }

public $csclassnameEnumerator GetEnumerator() {
    return new $csclassnameEnumerator(this);
  }

// Type-safe enumerator
  /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
  /// whenever the collection is modified. This has been done for changes in the size of the
  /// collection but not when one of the elements of the collection is modified as it is a bit
  /// tricky to detect unmanaged code that modifies the collection under our feet.
  public sealed class $csclassnameEnumerator : global::System.Collections.IEnumerator,
      global::System.Collections.Generic.IEnumerator<$typemap(cstype, T)>
  {
    private $csclassname collectionRef;
    private global::System.Collections.Generic.IList<$typemap(cstype, T)> ItemsCollection;
    private int currentIndex;
    private object currentObject;
    private int currentSize;

public $csclassnameEnumerator($csclassname collection) {
      collectionRef = collection;
      ItemsCollection = new global::System.Collections.Generic.List<$typemap(cstype, T)>(collection.Items);
      currentIndex = -1;
      currentObject = null;
      currentSize = collectionRef.Count;
    }

// Type-safe iterator Current
    public $typemap(cstype, T) Current {
      get {
        if (currentIndex == -1)
          throw new global::System.InvalidOperationException("Enumeration not started.");
        if (currentIndex > currentSize - 1)
          throw new global::System.InvalidOperationException("Enumeration finished.");
        if (currentObject == null)
          throw new global::System.InvalidOperationException("Collection modified.");
        return ($typemap(cstype, T))currentObject;
      }
    }

// Type-unsafe IEnumerator.Current
    object global::System.Collections.IEnumerator.Current {
      get {
        return Current;
      }
    }

public bool MoveNext() {
      int size = collectionRef.Count;
      bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
      if (moveOkay) {
        currentIndex++;
        currentObject = ItemsCollection[currentIndex];
      } else {
        currentObject = null;
      }
      return moveOkay;
    }

public void Reset() {
      currentIndex = -1;
      currentObject = null;
      if (collectionRef.Count != currentSize) {
        throw new global::System.InvalidOperationException("Collection modified.");
      }
    }

public void Dispose() {
      currentIndex = -1;
      currentObject = null;
    }
  }

public:
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef T key_type;
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;

set();
    set(const set& other);
    size_type size() const;
    bool empty() const;
    %rename(Clear) clear;
    void clear();
    %extend {
      bool Add(const value_type& item) {
        return $self->insert(item).second;
      }

bool Contains(const value_type& item) {
        return $self->count(item) != 0;
      }

bool Remove(const value_type& item) {
        return $self->erase(item) != 0;
      }

const value_type& getitem(const value_type& item) throw (std::out_of_range) {
        std::set<T>::iterator iter = $self->find(item);
        if (iter == $self->end())
          throw std::out_of_range("item not found");

return *iter;
      }

// create_iterator_begin(), get_next() and destroy_iterator work together to provide a collection of items to C#
      %apply void *VOID_INT_PTR { std::set<T>::iterator *create_iterator_begin }
      %apply void *VOID_INT_PTR { std::set<T>::iterator *swigiterator }

std::set<T>::iterator *create_iterator_begin() {
        return new std::set<T>::iterator($self->begin());
      }

const key_type& get_next(std::set<T>::iterator *swigiterator) {
        std::set<T>::iterator iter = *swigiterator;
        (*swigiterator)++;
        return *iter;
      }

void destroy_iterator(std::set<T>::iterator *swigiterator) {
        delete swigiterator;
      }
    }
};

}

${this.title}

Code Editor : std_set.i