jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

attribute tidy up. %attributeref replaces %attribute_ref

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@10000 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
William S Fulton 2007-10-17 21:27:21 +00:00
commit 2a89d09add
5 changed files with 102 additions and 134 deletions
Download patch file Download diff file Expand all files Collapse all files

8
CHANGES.current
View file

@ -1,6 +1,14 @@
Version 1.3.32 (in progress)
============================
10/16/2007: wsfulton
Deprecate %attribute_ref and replace with %attributeref. There is just an argument
order change in order to maintain consistency with %attribute, from:
%attribute_ref(Class, AttributeType, AccessorMethod, AttributeName)
to
%attributeref(Class, AttributeType, AttributeName, AccessorMethod)
10/16/2007: olly
[Tcl] Fix several ocurrences of "warning: deprecated conversion
from string constant to 'char*'" from GCC 4.2 in generated C/C++

22
Examples/test-suite/li_attribute.i
View file

@ -8,18 +8,19 @@
%{
// forward reference needed if using SWIG_ATTRIBUTE_TEMPLATE
class A;
class MyFoo; // %attribute2 does not work with templates
%}
%attribute(A, int, a, get_a, set_a);
%attribute_ref(A, int, b);
%attributeref(A, int, b);
%attribute_ref(Param<int>, int, value);
%attributeref(Param<int>, int, value);
%attribute(A, int, c, get_c); /* read-only */
%attribute_ref(A, int, b, d); /* different attribute name 'd' */
%attributeref(A, int, d, b); /* renames accessor method 'b' to attribute name 'd' */
%attribute_ref(B, A*, a)
%attributeref(B, A*, a)
%inline
{
@ -92,3 +93,16 @@ class A;
%template(Param_i) Param<int>;
%attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
%inline %{
struct MyFoo {
int x;
};
class MyClass {
MyFoo foo;
public:
MyFoo& GetFoo() { return foo; }
void SetFoo(const MyFoo& other) { foo = other; }
};
%}

75
Examples/test-suite/python/attributetest.i
View file

@ -1,75 +0,0 @@
%module attributetest
%include attribute.i
%attribute(A, int, a, get_a, set_a);
%attribute_ref(A, int, b);
%attribute_ref(Param<int>, int, value);
%attribute(A, int, c, get_c); /* read-only */
%attribute_ref(A, int, b, d); /* different attribute name 'd' */
%inline
{
struct A
{
A(int a, int b, int c) : _a(a), _b(b), _c(c)
{
}
int get_a() const
{
return _a;
}
void set_a(int aa)
{
_a = aa;
}
const int& b() const
{
return _b;
}
int& b()
{
return _b;
}
int get_c() const
{
return _c;
}
private:
int _a;
int _b;
int _c;
};
template <class C>
struct Param
{
Param(C v) : _v(v)
{
}
const int& value() const
{
return _v;
}
int& value()
{
return _v;
}
private:
C _v;
};
}
%template(Param_i) Param<int>;

6
Examples/test-suite/python/li_attribute_runme.py
View file

@ -43,4 +43,10 @@ if b.a.c != 3:
raise RuntimeError
myFoo = li_attribute.MyFoo
myFoo.x = 8
myClass = li_attribute.MyClass
myClass.Foo = myFoo
if myClass.Foo.x != 8:
raise RuntimeError

125
Lib/typemaps/attribute.swg
View file

@ -15,57 +15,59 @@
like in:
%attribute(A, int, a, get_a, set_a);
struct A
{
int get_a() const;
void set_a(int aa);
};
struct A
{
int get_a() const;
void set_a(int aa);
};
If you don't provide a 'set' method, a 'read-only' attribute
is generated, ie, like in:
%attribute(A, int, c, get_c);
Use %attribute_ref when you have const/non-const reference
Use %attributeref when you have const/non-const reference
access methods, like in:
%attribute_ref(A, int, b);
struct A
{
const int& b() const;
int& b();
};
%attribute_ref(B, int, c);
struct B
{
int& c();
};
%attributeref(A, int, b);
struct A
{
const int& b() const;
int& b();
};
%attributeref(B, int, c);
struct B
{
int& c();
};
You can also use
%attribute_ref(class, type, refname, attr);
%attributeref(Class, AttributeType, AttributeName, AccessorMethod)
if the internal C++ reference methods have a different name from the
attribute you want. There's an inconsistency here (retained for
compatibility): when using %attribute_ref, the C++ symbol name comes
before the attribute name, but when you use %attribute, the attribute
name comes before the C++ symbol names.
attribute you want, so
%attributeref(B, int, d, c);
is the same as the last example, but instead of the attribute 'c' being
called 'c', it is called 'd'.
Now you can use the attributes like so:
x = A()
x.a = 3 # calls A::set_a
print x.a # calls A::get_a
x.b = 3 # calls A::b()
x = A()
x.a = 3 # calls A::set_a
print x.a # calls A::get_a
x.b = 3 # calls A::b()
print x.b # calls A::b() const
Use %attribute2 instead of %attribute to indicate that reference-pointer
translation is required. You use %attribute2 instead of %attribute in
Use %attribute2 instead of %attribute to indicate that reference-pointer
translation is required. You use %attribute2 instead of %attribute in
cases like this:
%attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
@ -79,29 +81,29 @@
MyFoo& GetFoo() { return foo; }
void SetFoo(const MyFoo& other) { foo = other; }
};
%}
%}
Here, the data type of the property is a wrapped type (MyFoo) and on the
C++ side it is passed by reference. The problem is that the SWIG wrapper will
pass around a pointer (MyFoo *) which is not compatible with the reference
type of the accessors (MyFoo &). Therefore, if you use %attribute, you'll get
an error from your C/C++ compiler. %attribute2 translates between a pointer
and a reference to eliminate the error. In case you're confused, I'll make it
simple: just use %attribute at first, but if the C/C++ compiler gives an error
Here, the data type of the property is a wrapped type (MyFoo) and on the
C++ side it is passed by reference. The problem is that the SWIG wrapper will
pass around a pointer (MyFoo *) which is not compatible with the reference
type of the accessors (MyFoo &). Therefore, if you use %attribute, you'll get
an error from your C/C++ compiler. %attribute2 translates between a pointer
and a reference to eliminate the error. In case you're confused, let's make it
simple: just use %attribute at first, but if the C/C++ compiler gives an error
while compiling the wrapper, try %attribute2 instead.
NOTE: remember that if the type contains commas, such as 'std::pair<int,int>',
NOTE: remember that if the type contains commas, such as 'std::pair<int,int>',
you need to use the macro like:
%attribute_ref(A, %arg(std::pair<int,int>), pval);
%attributeref(A, %arg(std::pair<int,int>), pval);
where %arg() 'normalizes' the type to be understood as a single
argument, otherwise the macro will get confused by the comma (see the
'cpp' documentation).
argument, otherwise the macro will get confused by the comma.
*/
//
// Define SWIG_ATTRIBUTE_TEMPLATE if you want to use templates instead of macros for the C++ get and set wrapper methods
// Does not always generate compileable code, use at your peril!
//
//#define SWIG_ATTRIBUTE_TEMPLATE
@ -157,6 +159,9 @@
#endif
%enddef
// User macros
%define %attribute(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
#if #SetMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, self_->GetMethod(), self_->SetMethod(val_))
@ -173,18 +178,28 @@
#endif
%enddef
%define %attribute_ref(Class, AttributeType, Accessor, AttributeName...)
#if #AttributeName != ""
%attribute_custom(Class, AttributeType, AttributeName, Accessor, Accessor, self_->Accessor(), self_->Accessor() = val_)
%define %attributeref(Class, AttributeType, AttributeName, AccessorMethod...)
#if #AccessorMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
#else
%attribute_custom(Class, AttributeType, Accessor, Accessor, Accessor, self_->Accessor(), self_->Accessor() = val_)
%attribute_custom(Class, AttributeType, AttributeName, AttributeName, AttributeName, self_->AttributeName(), self_->AttributeName() = val_)
#endif
%enddef
%define %attribute2_ref(Class, AttributeType, Accessor, AttributeName...)
#if #AttributeName != ""
%attribute_custom(Class, AttributeType, AttributeName, Accessor, Accessor, &self_->Accessor(), self_->Accessor() = *val_)
%define %attribute2ref(Class, AttributeType, AttributeName, AccessorMethod...)
#if #AccessorMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
#else
%attribute_custom(Class, AttributeType, Accessor, Accessor, Accessor, &self_->Accessor(), self_->Accessor() = *val_)
%attribute_custom(Class, AttributeType, AccessorMethod, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
#endif
%enddef
// deprecated (same as %attributeref, but there is an argument order inconsistency)
%define %attribute_ref(Class, AttributeType, AccessorMethod, AttributeName...)
#if #AttributeName != ""
%attribute_custom(Class, AttributeType, AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
#else
%attribute_custom(Class, AttributeType, AccessorMethod, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
#endif
%enddef