# exception_check boolean True if PyErr_Occurred check needed
# nogil boolean Can be called without gil
# with_gil boolean Acquire gil around function body
+ # is_const_method boolean Whether this is a const method
child_attrs = ["base", "args", "exception_value"]
overridable = 0
optional_arg_count = 0
+ is_const_method = 0
templates = None
def analyse_templates(self):
exception_value = exc_val, exception_check = exc_check,
calling_convention = self.base.calling_convention,
nogil = self.nogil, with_gil = self.with_gil, is_overridable = self.overridable,
+ is_const_method = self.is_const_method,
templates = self.templates)
if self.optional_arg_count:
p_positional_and_keyword_args(s, (']',), templates)
)
s.expect(']')
-
+
if s.sy == '[':
base_type_node = p_buffer_or_template(s, base_type_node, templates)
else:
#if api:
# s.error("'api' not allowed with variable declaration")
+ if is_const_method:
+ declarator.is_const_method = is_const_method
declarators = [declarator]
while s.sy == ',':
s.next()
def __init__(self, return_type, args, has_varargs = 0,
exception_value = None, exception_check = 0, calling_convention = "",
nogil = 0, with_gil = 0, is_overridable = 0, optional_arg_count = 0,
- templates = None, is_strict_signature = False):
+ is_const_method = False, templates = None, is_strict_signature = False):
self.return_type = return_type
self.args = args
self.has_varargs = has_varargs
self.nogil = nogil
self.with_gil = with_gil
self.is_overridable = is_overridable
+ self.is_const_method = is_const_method
self.templates = templates
self.is_strict_signature = is_strict_signature
with_gil = self.with_gil,
is_overridable = self.is_overridable,
optional_arg_count = self.optional_arg_count,
+ is_const_method = self.is_const_method,
templates = self.templates)
result.from_fused = self.is_fused
cdef extern from "shapes.h" namespace "shapes":
cdef cppclass Shape:
- float area()
+ float area() const
cdef cppclass RegularPolygon(Shape):
float radius # major
__init__(int n, float radius):
this.n = n
this.radius = radius
- float area():
+ float area() const:
cdef double theta = pi / this.n
return this.radius * this.radius * sin(theta) * cos(theta) * this.n
"""
cdef WithTemplate[long] *base = new WithTemplate[long]()
del base
-
+
cdef ResolveTemplate *resolved = new ResolveTemplate()
resolved.set_value(value)
assert resolved.value == resolved.get_value() == value, resolved.value
base = resolved
base.set_value(2 * value)
assert base.get_value() == base.value == 2 * value, base.value
-
+
del base
class Shape
{
public:
- virtual float area() = 0;
+ virtual float area() const = 0;
Shape() { constructor_count++; }
virtual ~Shape() { destructor_count++; }
};
this->height = height;
}
- float area() { return width * height; }
+ float area() const { return width * height; }
int width;
int height;
class Circle : public Shape {
public:
Circle(int radius) { this->radius = radius; }
- float area() { return 3.1415926535897931f * radius; }
+ float area() const { return 3.1415926535897931f * radius; }
int radius;
};
class Empty : public Shape {
public:
- float area() { return 0; }
+ float area() const { return 0; }
};
}