#[unsafe_destructor]
impl<T: Owned> Drop for Unique<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
let x = intrinsics::init(); // dummy value to swap in
// moving the object out is needed to call the destructor
> iterations of the language, and often still are.
Additionally, the `Drop` trait is used to define destructors. This
-trait defines one method called `finalize`, which is automatically
+trait defines one method called `drop`, which is automatically
called when a value of the type that implements this trait is
destroyed, either because the value went out of scope or because the
garbage collector reclaimed it.
}
impl Drop for TimeBomb {
- fn finalize(&self) {
+ fn drop(&self) {
for self.explosivity.times {
println("blam!");
}
}
~~~
-It is illegal to call `finalize` directly. Only code inserted by the compiler
+It is illegal to call `drop` directly. Only code inserted by the compiler
may call it.
## Declaring and implementing traits
syn match rustAssert "\<assert\(\w\)*!"
syn match rustFail "\<fail\(\w\)*!"
-syn keyword rustKeyword break copy do drop extern
+syn keyword rustKeyword break copy do extern
syn keyword rustKeyword for if impl let log
syn keyword rustKeyword copy do extern
syn keyword rustKeyword for impl let log
}
impl Drop for PoisonOnFail {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
/* assert!(!*self.failed);
-- might be false in case of cond.wait() */
#[unsafe_destructor]
impl Drop for Arena {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
destroy_chunk(&self.head);
for self.chunks.each |chunk| {
#[unsafe_destructor]
impl Drop for DtorRes {
- fn finalize(&self) {
+ fn drop(&self) {
match self.dtor {
option::None => (),
option::Some(f) => f()
// over ~fn's that have pipes and so forth within!
#[unsafe_destructor]
impl<A> Drop for Future<A> {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
priv enum FutureState<A> {
#[unsafe_destructor]
impl Drop for TcpSocket {
- fn finalize(&self) {
+ fn drop(&self) {
tear_down_socket_data(self.socket_data)
}
}
#[unsafe_destructor]
impl<T> Drop for Rc<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
if self.ptr.is_not_null() {
(*self.ptr).count -= 1;
#[unsafe_destructor]
impl<T> Drop for RcMut<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
if self.ptr.is_not_null() {
(*self.ptr).count -= 1;
#[unsafe_destructor]
impl<'self> Drop for LVal<'self> {
- fn finalize(&self) {
+ fn drop(&self) {
let x = unsafe { local_data::local_data_get(self.key) };
match x {
Some(@y) => {
#[doc(hidden)]
#[unsafe_destructor]
impl<'self, Q:Owned> Drop for SemReleaseGeneric<'self, Q> {
- fn finalize(&self) {
+ fn drop(&self) {
self.sem.release();
}
}
}
#[unsafe_destructor]
-impl<'self> Drop for Condvar<'self> { fn finalize(&self) {} }
+impl<'self> Drop for Condvar<'self> { fn drop(&self) {} }
impl<'self> Condvar<'self> {
/**
#[unsafe_destructor]
impl<'self> Drop for CondvarReacquire<'self> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
// Needs to succeed, instead of itself dying.
do task::unkillable {
#[doc(hidden)]
#[unsafe_destructor]
impl<'self> Drop for RWlockReleaseRead<'self> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
do task::unkillable {
let state = &mut *self.lock.state.get();
#[doc(hidden)]
#[unsafe_destructor]
impl<'self> Drop for RWlockReleaseDowngrade<'self> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
do task::unkillable {
let writer_or_last_reader;
/// The "write permission" token used for rwlock.write_downgrade().
pub struct RWlockWriteMode<'self> { priv lock: &'self RWlock }
#[unsafe_destructor]
-impl<'self> Drop for RWlockWriteMode<'self> { fn finalize(&self) {} }
+impl<'self> Drop for RWlockWriteMode<'self> { fn drop(&self) {} }
/// The "read permission" token used for rwlock.write_downgrade().
pub struct RWlockReadMode<'self> { priv lock: &'self RWlock }
#[unsafe_destructor]
-impl<'self> Drop for RWlockReadMode<'self> { fn finalize(&self) {} }
+impl<'self> Drop for RWlockReadMode<'self> { fn drop(&self) {} }
impl<'self> RWlockWriteMode<'self> {
/// Access the pre-downgrade rwlock in write mode.
}
impl Drop for SendOnFailure {
- fn finalize(&self) {
+ fn drop(&self) {
self.c.send(());
}
}
#[unsafe_destructor]
impl<T> Drop for TaskPool<T> {
- fn finalize(&self) {
+ fn drop(&self) {
for self.channels.iter().advance |channel| {
channel.send(Quit);
}
}
impl Drop for PassManager {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
llvm::LLVMDisposePassManager(self.llpm);
}
}
impl Drop for target_data_res {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
llvm::LLVMDisposeTargetData(self.TD);
}
}
impl Drop for pass_manager_res {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
llvm::LLVMDisposePassManager(self.PM);
}
}
impl Drop for object_file_res {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
llvm::LLVMDisposeObjectFile(self.ObjectFile);
}
}
impl Drop for section_iter_res {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
llvm::LLVMDisposeSectionIterator(self.SI);
}
#[unsafe_destructor]
impl Drop for _InsnCtxt {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
do local_data::local_data_modify(task_local_insn_key) |c| {
do c.map_consume |@ctx| {
}
impl Drop for BuilderRef_res {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
llvm::LLVMDisposeBuilder(self.B);
}
#[unsafe_destructor]
impl Drop for CrateContext {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
unset_task_llcx();
}
}
impl Drop for finally {
- fn finalize(&self) { self.ch.send(done); }
+ fn drop(&self) { self.ch.send(done); }
}
let _finally = finally { ch: ch };
}
impl Drop for _indenter {
- fn finalize(&self) { debug!("<<"); }
+ fn drop(&self) { debug!("<<"); }
}
pub fn _indenter(_i: ()) -> _indenter {
}
impl Drop for Bored {
- fn finalize(&self) { }
+ fn drop(&self) { }
}
/**
#[unsafe_destructor]
impl<'self, T, U> Drop for Guard<'self, T, U> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
debug!("Guard: popping handler from TLS");
let curr = local_data_pop(self.cond.key);
}
impl Drop for FILERes {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
libc::fclose(self.f);
}
}
impl Drop for FdRes {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
libc::close(self.fd);
}
#[unsafe_destructor]
impl<T:Copy> Drop for Res<T> {
- fn finalize(&self) {
+ fn drop(&self) {
match self.arg.opt_level {
None => (),
Some(level) => {
#[lang="drop"]
pub trait Drop {
- fn finalize(&self); // FIXME(#4332): Rename to "drop"? --pcwalton
+ fn drop(&self);
}
#[lang="add"]
#[unsafe_destructor]
impl ::ops::Drop for R {
- fn finalize(&self) { *(self.i) += 1; }
+ fn drop(&self) { *(self.i) += 1; }
}
fn R(i: @mut int) -> R {
#[unsafe_destructor]
impl<T> Drop for BufferResource<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
// FIXME(#4330) Need self by value to get mutability.
let this: &mut BufferResource<T> = transmute_mut(self);
#[unsafe_destructor]
impl<T:Owned,Tbuffer:Owned> Drop for SendPacketBuffered<T,Tbuffer> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
let this: &mut SendPacketBuffered<T,Tbuffer> = transmute(self);
if this.p != None {
#[unsafe_destructor]
impl<T:Owned,Tbuffer:Owned> Drop for RecvPacketBuffered<T,Tbuffer> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
let this: &mut RecvPacketBuffered<T,Tbuffer> = transmute(self);
if this.p != None {
#[unsafe_destructor]
impl<T> Drop for ChanOneHack<T> {
- fn finalize(&self) {
+ fn drop(&self) {
if self.suppress_finalize { return }
unsafe {
#[unsafe_destructor]
impl<T> Drop for PortOneHack<T> {
- fn finalize(&self) {
+ fn drop(&self) {
if self.suppress_finalize { return }
unsafe {
}
impl Drop for LocalHeap {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
rust_delete_boxed_region(self.boxed_region);
rust_delete_memory_region(self.memory_region);
#[unsafe_destructor]
impl<T> Drop for RC<T> {
- fn finalize(&self) {
+ fn drop(&self) {
assert!(self.refcount() > 0);
unsafe {
}
impl Drop for StackSegment {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
// XXX: Using the FFI to call a C macro. Slow
rust_valgrind_stack_deregister(self.valgrind_id);
}
impl Drop for Task {
- fn finalize(&self) { assert!(self.destroyed) }
+ fn drop(&self) { assert!(self.destroyed) }
}
// Just a sanity check to make sure we are catching a Rust-thrown exception
}
impl Drop for Thread {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe { rust_raw_thread_join_delete(self.raw_thread) }
}
}
}
impl Drop for UvEventLoop {
- fn finalize(&self) {
+ fn drop(&self) {
// XXX: Need mutable finalizer
let this = unsafe {
transmute::<&UvEventLoop, &mut UvEventLoop>(self)
}
impl Drop for UvTcpListener {
- fn finalize(&self) {
+ fn drop(&self) {
let watcher = self.watcher();
let scheduler = Local::take::<Scheduler>();
do scheduler.deschedule_running_task_and_then |task| {
}
impl Drop for UvTcpStream {
- fn finalize(&self) {
+ fn drop(&self) {
rtdebug!("closing tcp stream");
let watcher = self.watcher();
let scheduler = Local::take::<Scheduler>();
}
impl Drop for UvEventLoop {
- fn finalize(&self) {
+ fn drop(&self) {
// XXX: Need mutable finalizer
let this = unsafe {
transmute::<&UvEventLoop, &mut UvEventLoop>(self)
}
impl Drop for UvTcpListener {
- fn finalize(&self) {
+ fn drop(&self) {
// XXX: Again, this never gets called. Use .close() instead
//self.watcher().as_stream().close(||());
}
}
impl Drop for UvStream {
- fn finalize(&self) {
+ fn drop(&self) {
rtdebug!("closing stream");
//self.watcher().close(||());
}
}
impl Drop for Process {
- fn finalize(&self) {
+ fn drop(&self) {
// FIXME(#4330) Need self by value to get mutability.
let mut_self: &mut Process = unsafe { cast::transmute(self) };
impl Drop for TCB {
// Runs on task exit.
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
// FIXME(#4330) Need self by value to get mutability.
let this: &mut TCB = transmute(self);
}
impl Drop for AutoNotify {
- fn finalize(&self) {
+ fn drop(&self) {
let result = if self.failed { Failure } else { Success };
self.notify_chan.send(result);
}
#[unsafe_destructor]
impl<T> Drop for AtomicOption<T> {
- fn finalize(&self) {
+ fn drop(&self) {
// This will ensure that the contained data is
// destroyed, unless it's null.
unsafe {
pub struct DynamicLibrary { priv handle: *libc::c_void }
impl Drop for DynamicLibrary {
- fn finalize(&self) {
+ fn drop(&self) {
match do dl::check_for_errors_in {
unsafe {
dl::close(self.handle)
#[unsafe_destructor]
impl<'self> Drop for Finallyalizer<'self> {
- fn finalize(&self) {
+ fn drop(&self) {
(self.dtor)();
}
}
}
impl Drop for GlobalState {
- fn finalize(&self) {
+ fn drop(&self) {
for self.map.each_value |v| {
match v {
&(_, ref dtor) => (*dtor)()
#[unsafe_destructor]
impl<T> Drop for UnsafeAtomicRcBox<T>{
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
do task::unkillable {
let mut data: ~AtomicRcBoxData<T> = cast::transmute(self.data);
}
impl Drop for LittleLock {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
rust_destroy_little_lock(self.l);
}
}
impl Drop for NonCopyable {
- fn finalize(&self) { }
+ fn drop(&self) { }
}
#[unsafe_destructor]
impl Drop for Parser {
/* do not copy the parser; its state is tied to outside state */
- fn finalize(&self) {}
+ fn drop(&self) {}
}
impl Parser {
#[unsafe_destructor]
impl<T:Const> Drop for arc_destruct<T> {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn arc_destruct<T:Const>(data: int) -> arc_destruct<T> {
}
impl Drop for context_res {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn context_res() -> context_res {
}
impl Drop for socket_handle {
- fn finalize(&self) {
+ fn drop(&self) {
/* c::close(self.sockfd); */
}
}
}
impl Drop for rsrc {
- fn finalize(&self) {
+ fn drop(&self) {
foo(self.x);
}
}
}
impl Drop for S {
- fn finalize(&self) {
+ fn drop(&self) {
println("goodbye");
}
}
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn r(l: @nillist) -> r {
struct X { x: () }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct X { x: (), }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct X { x: (), }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct X { x: (), }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct X { x: (), }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct X { x: (), }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct X { x: (), }
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("destructor runs");
}
}
struct r;
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
true
}
}
#[unsafe_destructor]
impl<'self> Drop for defer<'self> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
error!("%?", self.x);
}
}
impl Drop for foo {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn foo(i:int) -> foo {
}
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("value: %s", self.x);
}
}
}
impl Drop for X {
- fn finalize(&self) {
+ fn drop(&self) {
error!("value: %s", self.x);
}
}
impl Drop for Foo { //~ ERROR the Drop trait may only be implemented
//~^ ERROR cannot provide an extension implementation
- fn finalize(&self) {
+ fn drop(&self) {
println("kaboom");
}
}
}
impl Drop for Foo {
- fn finalize(&self) {
+ fn drop(&self) {
println("kaboom");
}
}
fn main() {
let x = Foo { x: 3 };
- x.finalize(); //~ ERROR explicit call to destructor
+ x.drop(); //~ ERROR explicit call to destructor
}
}
impl Drop for Foo {
- fn finalize(&self) {
+ fn drop(&self) {
println("kaboom");
}
}
impl Bar for Foo {
fn blah(&self) {
- self.finalize(); //~ ERROR explicit call to destructor
+ self.drop(); //~ ERROR explicit call to destructor
}
}
#[unsafe_destructor]
impl Drop for foo {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
println("Goodbye, World!");
*self.x += 1;
}
impl Drop for C {
- fn finalize(&self) {
+ fn drop(&self) {
error!("dropping: %?", self.x);
}
}
}
impl<T> Drop for foo<T> {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
}
fn main() { }
}
impl Drop for Foo { //~ ERROR cannot implement a destructor on a struct that is not Owned
- fn finalize(&self) {
+ fn drop(&self) {
*self.f = 10;
}
}
#[unsafe_destructor]
impl Drop for foo {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn foo(x: Port<()>) -> foo {
}
impl Drop for bar {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn bar(x:int) -> bar {
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.i) = *(self.i) + 1;
}
}
impl Drop for Foo {
- fn finalize(&self) {
+ fn drop(&self) {
println("Goodbye!");
}
}
}
impl Drop for Bar {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
impl Foo for Bar {
}
impl Drop for r {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn main() {
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.i) = *(self.i) + 1;
}
}
impl Drop for S {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
impl S {
fn r(i:int) -> r { r { i: i } }
impl Drop for r {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn main() {
}
impl Drop for R {
- fn finalize(&self) {
+ fn drop(&self) {
let _y = R { b: self.b };
}
}
}
impl Drop for and_then_get_big_again {
- fn finalize(&self) {
+ fn drop(&self) {
fn getbig(i: int) {
if i != 0 {
getbig(i - 1);
}
impl Drop for and_then_get_big_again {
- fn finalize(&self) {
+ fn drop(&self) {
fn getbig(i: int) {
if i != 0 {
getbig(i - 1);
}
impl Drop for and_then_get_big_again {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn and_then_get_big_again(x:int) -> and_then_get_big_again {
// failed has no effect and the process exits with the
// runtime's exit code
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
os::set_exit_status(50);
}
}
}
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
if !*(self.recursed) {
*(self.recursed) = true;
}
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
let _v2: ~int = cast::transmute(self.v);
}
}
impl Drop for r {
- fn finalize(&self) { fail!("squirrel") }
+ fn drop(&self) { fail!("squirrel") }
}
fn r(i: int) -> r { r { i: i } }
}
impl Drop for r {
- fn finalize(&self) { fail!("wombat") }
+ fn drop(&self) { fail!("wombat") }
}
fn r(i: int) -> r { r { i: i } }
#[unsafe_destructor]
impl Drop for faily_box {
- fn finalize(&self) {
+ fn drop(&self) {
fail!("quux");
}
}
#[unsafe_destructor]
impl<T> Drop for Test<T> {
- fn finalize(&self) { }
+ fn drop(&self) { }
}
fn main() {
}
impl Drop for noncopyable {
- fn finalize(&self) {
+ fn drop(&self) {
error!("dropped");
}
}
impl Drop for cat {
#[cat_dropper]
- fn finalize(&self) { error!("%s landed on hir feet" , self . name); }
+ fn drop(&self) { error!("%s landed on hir feet" , self . name); }
}
/**
Actually, cats don't always land on their feet when you drop them.
*/
- fn finalize(&self) {
+ fn drop(&self) {
error!("%s landed on hir feet", self.name);
}
}
}
impl Drop for cat {
- fn finalize(&self) {
+ fn drop(&self) {
(self.done)(self.meows);
}
}
#[unsafe_destructor]
impl<T> ::std::ops::Drop for S<T> {
- fn finalize(&self) {
+ fn drop(&self) {
println("bye");
}
}
}
impl Drop for Foo {
- fn finalize(&self) {
+ fn drop(&self) {
println("bye");
}
}
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.i) = *(self.i) + 1;
}
}
impl Drop for socket {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
impl socket {
}
impl Drop for Font {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn Font() -> Font {
#[unsafe_destructor]
impl<T:Owned> Drop for send_packet<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
if self.p != None {
let self_p: &mut Option<*packet<T>> =
#[unsafe_destructor]
impl<T:Owned> Drop for recv_packet<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
if self.p != None {
let self_p: &mut Option<*packet<T>> =
#[unsafe_destructor]
impl Drop for defer {
- fn finalize(&self) {
+ fn drop(&self) {
*self.b = true;
}
}
#[unsafe_destructor]
impl Drop for defer {
- fn finalize(&self) {
+ fn drop(&self) {
*self.b = true;
}
}
}
impl Drop for Kitty {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
#[cfg(target_arch = "x86_64")]
struct thing { x: int, }
impl Drop for thing {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn thing() -> thing {
}
impl Drop for AsciiArt {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
// It's common to define a constructor sort of function to create struct instances.
}
impl<T: X> Drop for Z<T> {
- fn finalize(&self) {
+ fn drop(&self) {
self.x.call(); // Adding this statement causes an ICE.
}
}
struct NonCopyable(*c_void);
impl Drop for NonCopyable {
- fn finalize(&self) {
+ fn drop(&self) {
let p = **self;
let v = unsafe { transmute::<*c_void, ~int>(p) };
}
struct A { x: uint }
impl Drop for A {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn main() {}
\ No newline at end of file
struct A { x: uint }
impl Drop for A {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn main() {
struct A { x: uint }
impl Drop for A {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn main() {
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.b) += 1;
}
#[unsafe_destructor]
impl Drop for Foo {
- fn finalize(&self) {
+ fn drop(&self) {
***self = 23;
}
}
pub struct Fd(c_int);
impl Drop for Fd {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
libc::close(**self);
}
#[unsafe_destructor]
impl Drop for dtor {
- fn finalize(&self) {
+ fn drop(&self) {
// abuse access to shared mutable state to write this code
unsafe {
*self.x -= 1;
}
impl Drop for Buffer {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
proto! double_buffer (
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.i) += 1;
}
}
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
debug!("r's dtor: self = %x, self.v = %x, self.v's value = %x",
cast::transmute::<*r, uint>(self),
}
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
let v2: ~int = cast::transmute(self.v.c);
}
}
impl Drop for R {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
let _v2: ~int = cast::transmute(self.v.c);
// let _v3: ~int = cast::transmute_copy(self.x);
#[unsafe_destructor]
impl Drop for shrinky_pointer {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
error!(~"Hello!"); **(self.i) -= 1;
}
#[unsafe_destructor]
impl<T:Copy> Drop for finish<T> {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
(self.arg.fin)(copy self.arg.val);
}
#[unsafe_destructor]
impl Drop for close_res {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.i) = false;
}
}
impl Drop for test {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn test(f: int) -> test {
}
impl Drop for foo {
- fn finalize(&self) {
+ fn drop(&self) {
error!("%s", self.x);
}
}
#[unsafe_destructor]
impl Drop for notify {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
error!("notify: task=%? v=%x unwinding=%b b=%b",
task::get_task(),
}
impl Drop for r {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn r(i:int) -> r {
#[unsafe_destructor]
impl Drop for r {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*(self.i) = *(self.i) + 1;
}
struct Foo;
impl Drop for Foo {
- fn finalize(&self) {
+ fn drop(&self) {
fail!("This failure should happen.");
}
}
}
impl Drop for complainer {
- fn finalize(&self) {
+ fn drop(&self) {
error!("About to send!");
self.c.send(true);
error!("Sent!");
#[unsafe_destructor]
impl Drop for complainer {
- fn finalize(&self) {}
+ fn drop(&self) {}
}
fn complainer(c: @int) -> complainer {
#[unsafe_destructor]
impl Drop for foo {
- fn finalize(&self) {
+ fn drop(&self) {
unsafe {
*self.x += 1;
}
projects / rust.git / commitdiff