DPaste - Paste #502 - pastebin, online compiler and collaboration tool dedicated to D Programming Language

Code

import std.stdio;
import std.conv : to;
import std.traits;

import NotNull_d;

class Vector2D(T) {
public:
    T x;
    T y;

this(T x, T y) {
        this.x = x;
        this.y = y;
    }

static Vector2D!(T) opCall(U)(const Vector2D!(U) Copy) {
        return new Vector2D!(T)(to!(T)(Copy.x), to!(T)(Copy.y));
    }

static Vector2D!(T) opCall(U, V)(U x, V y) {
        return new Vector2D!(T)(to!(T)(x), to!(T)(y));
    }

typeof(this) opOpAssign(string op, U)(const Vector2D!(U) vec) if (isNumeric!(U)) {
        if (op == "*") {
            this.x *= vec.x;
            this.y *= vec.y;
        }

return this;
    }

typeof(this) opOpAssign(string op, U)(U scalar) if (isNumeric!(U)) {
        if (op == "*") {
			static if (is(U == T) || is(U : T)) {
				this.x *= scalar;
				this.y *= scalar;
			} else {
				this.x *= cast(T) scalar;
				this.y *= cast(T) scalar;
			}
        }

return this;
    }

typeof(this) Clone() const {
		return Vector2D!(T)(this);
	}

void Set(U, V)(U x, V y) {
		this.x = to!(T)(x);
		this.y = to!(T)(y);
	}

override string toString() const {
        return "Vector2D!(" ~ T.stringof ~ ")(" ~ to!(string)(this.x) ~ "|" ~ to!(string)(this.y) ~ ")";
    }
}

alias Vector2D!(short) Vector2s;
alias Vector2D!(float) Vector2f;

class Foo {
private:
	static uint _counter;

public:
	this() {
		_counter++;
	}

void Identicate(uint nr = 0) const {
		writefln("[%d] %s -> %d", nr, Foo.stringof, _counter);
	}
}

class Bar {
public:
	void Identicate(uint nr = 0) const {
		writefln("%s -> %d", Bar.stringof, nr);
	}

mixin TNotNull!(Bar);
}

void test_nn_foo(NotNull!(Foo) nnf) {
	nnf.Identicate();

writeln(nnf.GetCounter());

Foo fp = nnf;
	fp.Identicate(1);

Foo f = cast(Foo) nnf;
	f.Identicate(2);
}

void test_foo(Foo f) {
	f.Identicate();
}

void test_nn_bar(NotNull!(Bar) nnb) {
	nnb.Identicate();

writeln(nnb.GetCounter());

Bar bp1 = *nnb;
	bp1.Identicate(1);

Bar* bp2 = nnb;
	bp2.Identicate(2);

Bar b = cast(Bar) nnb;
	b.Identicate(3);
}

void test_bar(Bar b) {
	b.Identicate(42);
}

void vec_calc(NotNull!(Vector2s) vec) {
	writeln(vec);

vec.x *= 2;
}

void vec_calc_ref(ref NotNull!(Vector2s) vec) {
	vec *= 2;
}

void main() {
	Foo f1 = new Foo();
	Foo f2;

test_nn_foo(assignNotNull(f1));
	test_nn_foo(assignNotNull(f1));
	test_nn_foo(assignNotNull(f1));
	test_nn_foo(createNotNull!(Foo));
	///test_nn_foo(createNotNull!(null));
	//#test_nn_foo(assignNotNull(f2));
	///test_nn_foo(assignNotNull(null));

/*
	test_foo(ensureNotNull(f1));
	test_foo(ensureNotNull(f2));
	test_foo(ensureNotNull(null));
	*/

///NotNull!(Foo).Create(null);
	///NotNull!(Foo) nnfn = null;

///NotNull!(Foo) not_pos1 = null;
	NotNull!(Foo) nnf1 = f1;
	//#NotNull!(Foo) nnf2 = f2;

Bar b1 = new Bar();
	Bar b2;

test_bar(ensureNotNull(b1));
	///test_bar(ensureNotNull(b2));

writeln("---");

///NotNull!(Bar) not_pos2 = null;
	NotNull!(Bar) nnb1 = b1;
	///#!NotNull!(Bar) nnb2 = b2;
	///NotNull!(Bar) test_nnb = b2.GetNotNull();

writeln("####");
	test_nn_bar(b1);
	test_nn_bar(b1);
	test_nn_bar(b1);
	test_nn_bar(assignNotNull(b1));
	///#test_nn_bar(assignNotNull(b2));
	///#test_nn_bar(b2);

Vector2s vec1 = Vector2s(42, 23);

vec_calc(assignNotNull(Vector2s(4, 2)));
	ensureNotNull(Vector2s(4, 2));

writeln(vec1);

vec_calc_ref(assignNotNull(vec1));

writeln(vec1);

writeln(NotNull!(Vector2s).GetCounter());
}

Compilation output:

/c280/c221.d(5): Error: module NotNull_d is in file 'NotNull_d.d' which cannot be read
import path[0] = /opt/compilers/dmd2/include
import path[1] = /usr/include/d
import path[2] = /usr/include/d/druntime/import

Paste info

Author: Namespace

Views: 180

Private: no

Expires: Never

Uploaded: 06.07.12 11:44

Votes: 0

Compilation

Compiler: DMD 2.062

Pointer size: m64

Code

Compilation output:

Paste info

Compilation

Actions

Confirm

Confirm