# Copy a file def filecopy(source, target): - f1 = fopen(source, "r") - f2 = fopen(target, "w") - buffer = malloc(8192) - nbytes = fread(buffer, 8192, 1, f1) - while (nbytes > 0): - fwrite(buffer, 8192, 1, f2) - nbytes = fread(buffer, 8192, 1, f1) - free(buffer) + f1 = fopen(source, "r") + f2 = fopen(target, "w") + buffer = malloc(8192) + nbytes = fread(buffer, 8192, 1, f1) + while (nbytes > 0): + fwrite(buffer, 8192, 1, f2) + nbytes = fread(buffer, 8192, 1, f1) + free(buffer)
diff --git a/Doc/Manual/SWIGPlus.html b/Doc/Manual/SWIGPlus.html index 3d8263e37..87fe30fa8 100644 --- a/Doc/Manual/SWIGPlus.html +++ b/Doc/Manual/SWIGPlus.html @@ -777,9 +777,9 @@ the normal constructor function. For example, if you have this:
class List {
public:
- List();
- List(const List &); // Copy constructor
- ...
+ List();
+ List(const List &); // Copy constructor
+ ...
};
@@ -803,7 +803,7 @@ through a special function like this:
List *copy_List(List *f) {
- return new List(*f);
+ return new List(*f);
}
class Foo {
public:
- Foo();
+ Foo();
%name(CopyFoo) Foo(const Foo &);
- ...
+ ...
};
@@ -969,8 +969,8 @@ not primitive types, such as classes. For instance, if you had another class lik
class Foo {
public:
- List items;
- ...
+ List items;
+ ...
@@ -982,10 +982,10 @@ For example:
List *Foo_items_get(Foo *self) {
- return &self->items;
+ return &self->items;
}
void Foo_items_set(Foo *self, List *value) {
- self->items = *value;
+ self->items = *value;
}
const List &Foo_items_get(Foo *self) {
- return self->items;
+ return self->items;
}
void Foo_items_set(Foo *self, const List &value) {
- self->items = value;
+ self->items = value;
}
class Foo {
public:
- void bar(int x, int y = 3, int z = 4);
+ void bar(int x, int y = 3, int z = 4);
};
@@ -1120,9 +1120,9 @@ Thus for the example above, it is as if we had instead given the following to SW
class Foo {
public:
- void bar(int x, int y, int z);
- void bar(int x, int y);
- void bar(int x);
+ void bar(int x, int y, int z);
+ void bar(int x, int y);
+ void bar(int x);
};
@@ -1158,7 +1158,7 @@ can be re-activated by using the compactdefaultargs
%feature("compactdefaultargs") Foo::bar;
class Foo {
public:
- void bar(int x, int y = 3, int z = 4);
+ void bar(int x, int y = 3, int z = 4);
};
@@ -1485,8 +1485,8 @@ class A;
%feature("valuewrapper") B;
struct B {
- B();
- // ....
+ B();
+ // ....
};
@@ -3000,15 +3000,15 @@ provide an expanded version of the class directly like this:
%rename(intList) List<int>; // Rename to a suitable identifier
class List<int> {
private:
- int *data;
- int nitems;
- int maxitems;
+ int *data;
+ int nitems;
+ int maxitems;
public:
- List(int max);
- ~List();
- void append(int obj);
- int length();
- int get(int n);
+ List(int max);
+ ~List();
+ void append(int obj);
+ int length();
+ int get(int n);
};
@@ -3244,15 +3244,15 @@ a class like this,
template<> class List<int> {
private:
- int *data;
- int nitems;
- int maxitems;
+ int *data;
+ int nitems;
+ int maxitems;
public:
- List(int max);
- ~List();
- void append(int obj);
- int length();
- int get(int n);
+ List(int max);
+ ~List();
+ void append(int obj);
+ int length();
+ int get(int n);
};
@@ -3275,15 +3275,15 @@ code defines a template that is applied when the template argument is a pointer.
template<class T> class List<T*> {
private:
- T *data;
- int nitems;
- int maxitems;
+ T *data;
+ int nitems;
+ int maxitems;
public:
- List(int max);
- ~List();
- void append(int obj);
- int length();
- T get(int n);
+ List(int max);
+ ~List();
+ void append(int obj);
+ int length();
+ T get(int n);
};
@@ -3587,11 +3587,11 @@ It is also possible to separate these declarations from the template class. For
...
template<class T> class List {
- ...
- public:
- List() { }
- T get(int index);
- ...
+ ...
+ public:
+ List() { }
+ T get(int index);
+ ...
};
@@ -3609,9 +3609,9 @@ additional methods to a specific instantiation. For example:
%template(intList) List<int>;
%extend List<int> {
- void blah() {
- printf("Hey, I'm an List<int>!\n");
- }
+ void blah() {
+ printf("Hey, I'm an List<int>!\n");
+ }
};
@@ -3698,7 +3698,7 @@ template <class T> class OuterTemplateClass {};
// OuterTemplateClass<OuterClass::InnerStruct> and thus the template needs
// to be expanded with %template before the OuterClass declaration.
%template(OuterTemplateClass_OuterClass__InnerStruct)
- OuterTemplateClass<OuterClass::InnerStruct>
+ OuterTemplateClass<OuterClass::InnerStruct>
// Don't forget to use %feature("flatnested") for OuterClass::InnerStruct and
@@ -3736,7 +3736,7 @@ introduced a new class name. This name could then be used with other directives
%template(vectori) vector<int>;
%extend vectori {
- void somemethod() { }
+ void somemethod() { }
};
@@ -3750,7 +3750,7 @@ as the class name. For example:
%template(vectori) vector<int>;
%extend vector<int> {
- void somemethod() { }
+ void somemethod() { }
};
@@ -4011,7 +4011,7 @@ in a different namespace. For example:
namespace foo {
- template<typename T> T max(T a, T b) { return a > b ? a : b; }
+ template<typename T> T max(T a, T b) { return a > b ? a : b; }
}
using foo::max;
@@ -4020,8 +4020,8 @@ using foo::max;
%template(maxfloat) foo::max<float>; // Okay (qualified name).
namespace bar {
- using namespace foo;
- %template(maxdouble) max<double>; // Okay.
+ using namespace foo;
+ %template(maxdouble) max<double>; // Okay.
}
class Foo {
public:
- int x;
+ int x;
};
class Bar {
public:
- int x;
- Foo *operator->();
+ int x;
+ Foo *operator->();
};
@@ -4970,14 +4970,14 @@ you wrap this code in Python, the module works just like you would expect:
class Foo {
protected:
- int x;
- int blah(int x);
+ int x;
+ int blah(int x);
};
class Bar : public Foo {
public:
- using Foo::x; // Make x public
- using Foo::blah; // Make blah public
+ using Foo::x; // Make x public
+ using Foo::blah; // Make blah public
};