Changeset 761

trunk/phobos/internal/object.d

r758	r761
127	127	// BUG: this prevents a compacting GC from working, needs to be fixed
128	128	//return cast(int)cast(void )this - cast(int)cast(void )o;
129	129
130	130	throw new Error(cast(string) ("need opCmp for class "
131	131	~ this.classinfo.name));
132	132	}
133	133
134	134	/**
135	135	* Returns !=0 if this object does have the same contents as obj.
136	136	*/
137		~~int~~ opEquals(Object o)
138		{
139		~~return cast(int)~~(this is o);
	137	bool opEquals(Object o)
	138	{
	139	return (this is o);
140	140	}
141	141
142	142	/* **
143	143	* Call delegate dg, passing this to it, when this object gets destroyed.
144	144	* Use extreme caution, as the list of delegates is stored in a place
145	145	* not known to the gc. Thus, if any objects pointed to by one of these
146	146	* delegates gets freed by the gc, calling the delegate will cause a
147	147	* crash.
148	148	* This is only for use by library developers, as it will need to be
149	149	* redone if weak pointers are added or a moving gc is developed.
…	…
355	355
356	356
357	357	/**
358	358	* Runtime type information about a type.
359	359	* Can be retrieved for any type using a
360	360	* <a href="../expression.html#typeidexpression">TypeidExpression</a>.
361	361	*/
362	362	class TypeInfo
363	363	{
364	364	override hash_t toHash()
365		{
366		hash_t hash;
367
368		foreach (char c; this.toString())
369		hash = hash * 9 + c;
370		return hash;
	365	{ hash_t hash;
	366
	367	foreach (char c; this.toString())
	368	hash = hash * 9 + c;
	369	return hash;
371	370	}
372	371
373	372	override int opCmp(Object o)
374	373	{
375		if (this is o)
376		return 0;
377		TypeInfo ti = cast(TypeInfo)o;
378		if (ti is null)
379		return 1;
380		return std.string.cmp(this.toString(), ti.toString());
381		}
382
383		override ~~int~~ opEquals(Object o)
384		{
385		/* TypeInfo instances are singletons, but duplicates can exist
386		* across DLL's. Therefore, comparing for a name match is
387		* sufficient.
388		*/
389		if (this is o)
390		return 1;
391		TypeInfo ti = cast(TypeInfo)o;
392		~~return cast(int)~~(ti && this.toString() == ti.toString());
	374	if (this is o)
	375	return 0;
	376	TypeInfo ti = cast(TypeInfo)o;
	377	if (ti is null)
	378	return 1;
	379	return std.string.cmp(this.toString(), ti.toString());
	380	}
	381
	382	override bool opEquals(Object o)
	383	{
	384	/* TypeInfo instances are singletons, but duplicates can exist
	385	* across DLL's. Therefore, comparing for a name match is
	386	* sufficient.
	387	*/
	388	if (this is o)
	389	return 1;
	390	TypeInfo ti = cast(TypeInfo)o;
	391	return (ti && this.toString() == ti.toString());
393	392	}
394	393
395	394	/// Returns a hash of the instance of a type.
396	395	hash_t getHash(in void *p) { return cast(uint)p; }
397	396
398	397	/// Compares two instances for equality.
399		~~int equals(in void p1, in void p2) { return cast(int)~~(p1 == p2); }
	398	bool equals(in void p1, in void p2) { return (p1 == p2); }
400	399
401	400	/// Compares two instances for <, ==, or >.
402	401	int compare(in void p1, in void p2) { return 0; }
403	402
404	403	/// Returns size of the type.
405	404	size_t tsize() { return 0; }
406	405
407	406	/// Swaps two instances of the type.
408	407	void swap(void p1, void p2)
409	408	{
…	…
434	433	void destroy(void *p) { }
435	434
436	435	/// Run the postblit on the object and all its sub-objects
437	436	void postblit(void *p) { }
438	437	}
439	438
440	439	class TypeInfo_Typedef : TypeInfo
441	440	{
442	441	override string toString() { return name; }
443	442
444		override ~~int~~ opEquals(Object o)
	443	override bool opEquals(Object o)
445	444	{ TypeInfo_Typedef c;
446	445
447		return cast(int)
448		(this is o \|\|
449		((c = cast(TypeInfo_Typedef)o) !is null &&
450		this.name == c.name &&
451		this.base == c.base));
	446	return this is o \|\|
	447	((c = cast(TypeInfo_Typedef)o) !is null &&
	448	this.name == c.name &&
	449	this.base == c.base);
452	450	}
453	451
454	452	override hash_t getHash(in void *p) { return base.getHash(p); }
455		override ~~int~~ equals(in void p1, in void p2) { return base.equals(p1, p2); }
	453	override bool equals(in void p1, in void p2) { return base.equals(p1, p2); }
456	454	override int compare(in void p1, in void p2) { return base.compare(p1, p2); }
457	455	override size_t tsize() { return base.tsize(); }
458	456	override void swap(void p1, void p2) { return base.swap(p1, p2); }
459	457
460	458	override TypeInfo next() { return base.next(); }
461	459	override uint flags() { return base.flags(); }
462	460	override void[] init() { return m_init.length ? m_init : base.init(); }
463	461
464	462	override void destroy(void *p) { base.destroy(p); }
465	463	override void postblit(void *p) { base.postblit(p); }
…	…
470	468	}
471	469
472	470	class TypeInfo_Enum : TypeInfo_Typedef
473	471	{
474	472	}
475	473
476	474	class TypeInfo_Pointer : TypeInfo
477	475	{
478	476	override string toString() { return cast(string) (m_next.toString() ~ "*"); }
479	477
480		override ~~int~~ opEquals(Object o)
	478	override bool opEquals(Object o)
481	479	{ TypeInfo_Pointer c;
482	480
483	481	return this is o \|\|
484	482	((c = cast(TypeInfo_Pointer)o) !is null &&
485	483	this.m_next == c.m_next);
486	484	}
487	485
488	486	override hash_t getHash(in void *p)
489	487	{
490	488	return cast(uint)cast(void *)p;
491	489	}
492	490
493		override ~~int~~ equals(in void p1, in void p2)
494		{
495		return ~~cast(int)~~(cast(void )p1 == cast(void* *)p2);
	491	override bool equals(in void p1, in void p2)
	492	{
	493	return (cast(void )p1 == cast(void* *)p2);
496	494	}
497	495
498	496	override int compare(in void p1, in void p2)
499	497	{
500	498	if (cast(void )p1 < cast(void* *)p2)
501	499	return -1;
502	500	else if (cast(void )p1 > cast(void* *)p2)
503	501	return 1;
504	502	else
505	503	return 0;
506	504	}
507	505
508	506	override size_t tsize()
509	507	{
510	508	return (void*).sizeof;
511	509	}
512	510
513	511	override void swap(void p1, void p2)
514		{
515		void* tmp;
516		tmp = cast(void*)p1;
517		cast(void)p1 = cast(void**)p2;
518		cast(void*)p2 = tmp;
	512	{ void* tmp;
	513	tmp = cast(void*)p1;
	514	cast(void)p1 = cast(void**)p2;
	515	cast(void*)p2 = tmp;
519	516	}
520	517
521	518	override TypeInfo next() { return m_next; }
522	519	override uint flags() { return 1; }
523	520
524	521	TypeInfo m_next;
525	522	}
526	523
527	524	class TypeInfo_Array : TypeInfo
528	525	{
529	526	override string toString() { return cast(string) (value.toString() ~ "[]"); }
530	527
531		override ~~int~~ opEquals(Object o)
	528	override bool opEquals(Object o)
532	529	{ TypeInfo_Array c;
533	530
534		return cast(int)
535		(this is o \|\|
536		((c = cast(TypeInfo_Array)o) !is null &&
537		this.value == c.value));
	531	return this is o \|\|
	532	((c = cast(TypeInfo_Array)o) !is null &&
	533	this.value == c.value);
538	534	}
539	535
540	536	override hash_t getHash(in void *p)
541		{
542		size_t sz = value.tsize();
543		hash_t hash = 0;
544		void[] a = cast(void[])p;
545		for (size_t i = 0; i < a.length; i++)
546		hash += value.getHash(a.ptr + i * sz);
	537	{ size_t sz = value.tsize();
	538	hash_t hash = 0;
	539	void[] a = cast(void[])p;
	540	for (size_t i = 0; i < a.length; i++)
	541	hash += value.getHash(a.ptr + i * sz);
547	542	return hash;
548	543	}
549	544
550		override ~~int~~ equals(in void p1, in void p2)
551		{
552		void[] a1 = cast(void[])p1;
553		void[] a2 = cast(void[])p2;
554		if (a1.length != a2.length)
555		return 0;
556		size_t sz = value.tsize();
557		for (size_t i = 0; i < a1.length; i++)
558		{
559		if (!value.equals(a1.ptr + i * sz, a2.ptr + i * sz))
560		return 0;
561		}
	545	override bool equals(in void p1, in void p2)
	546	{
	547	void[] a1 = cast(void[])p1;
	548	void[] a2 = cast(void[])p2;
	549	if (a1.length != a2.length)
	550	return 0;
	551	size_t sz = value.tsize();
	552	for (size_t i = 0; i < a1.length; i++)
	553	{
	554	if (!value.equals(a1.ptr + i * sz, a2.ptr + i * sz))
	555	return 0;
	556	}
562	557	return 1;
563	558	}
564	559
565	560	override int compare(in void p1, in void p2)
566	561	{
567	562	void[] a1 = cast(void[])p1;
568	563	void[] a2 = cast(void[])p2;
569	564	size_t sz = value.tsize();
570	565	size_t len = a1.length;
571	566
…	…
579	574	}
580	575	return cast(int)a1.length - cast(int)a2.length;
581	576	}
582	577
583	578	override size_t tsize()
584	579	{
585	580	return (void[]).sizeof;
586	581	}
587	582
588	583	override void swap(void p1, void p2)
589		{
590		void[] tmp;
591		tmp = cast(void[])p1;
592		cast(void[])p1 = cast(void[])p2;
593		cast(void[])p2 = tmp;
	584	{ void[] tmp;
	585	tmp = cast(void[])p1;
	586	cast(void[])p1 = cast(void[])p2;
	587	cast(void[])p2 = tmp;
594	588	}
595	589
596	590	TypeInfo value;
597	591
598	592	override TypeInfo next()
599	593	{
600	594	return value;
601	595	}
602	596
603	597	override uint flags() { return 1; }
604	598	}
605	599
606	600	class TypeInfo_StaticArray : TypeInfo
607	601	{
608	602	override string toString()
609	603	{
610	604	return cast(string)
611	605	(value.toString() ~ "[" ~ std.string.toString(len) ~ "]");
612	606	}
613	607
614		override ~~int~~ opEquals(Object o)
	608	override bool opEquals(Object o)
615	609	{ TypeInfo_StaticArray c;
616	610
617		return cast(int)
618		(this is o \|\|
619		((c = cast(TypeInfo_StaticArray)o) !is null &&
620		this.len == c.len &&
621		this.value == c.value));
	611	return this is o \|\|
	612	((c = cast(TypeInfo_StaticArray)o) !is null &&
	613	this.len == c.len &&
	614	this.value == c.value);
622	615	}
623	616
624	617	override hash_t getHash(in void *p)
625		{
626		size_t sz = value.tsize();
627		hash_t hash = 0;
628		for (size_t i = 0; i < len; i++)
629		hash += value.getHash(p + i * sz);
	618	{ size_t sz = value.tsize();
	619	hash_t hash = 0;
	620	for (size_t i = 0; i < len; i++)
	621	hash += value.getHash(p + i * sz);
630	622	return hash;
631	623	}
632	624
633		override ~~int~~ equals(in void p1, in void p2)
634		{
635		size_t sz = value.tsize();
	625	override bool equals(in void p1, in void p2)
	626	{
	627	size_t sz = value.tsize();
636	628
637	629	for (size_t u = 0; u < len; u++)
638	630	{
639	631	if (!value.equals(p1 + u * sz, p2 + u * sz))
640	632	return 0;
641	633	}
642	634	return 1;
643	635	}
644	636
645	637	override int compare(in void p1, in void p2)
…	…
654	646	}
655	647	return 0;
656	648	}
657	649
658	650	override size_t tsize()
659	651	{
660	652	return len * value.tsize();
661	653	}
662	654
663	655	override void swap(void p1, void p2)
664		{
665		void* tmp;
666		size_t sz = value.tsize();
667		ubyte[16] buffer;
668		void* pbuffer;
669
670		if (sz < buffer.sizeof)
671		tmp = buffer.ptr;
672		else
673		tmp = pbuffer = (new void[sz]).ptr;
674
675		for (size_t u = 0; u < len; u += sz)
676		{ size_t o = u * sz;
677		memcpy(tmp, p1 + o, sz);
678		memcpy(p1 + o, p2 + o, sz);
679		memcpy(p2 + o, tmp, sz);
680		}
681		if (pbuffer)
682		delete pbuffer;
	656	{ void* tmp;
	657	size_t sz = value.tsize();
	658	ubyte[16] buffer;
	659	void* pbuffer;
	660
	661	if (sz < buffer.sizeof)
	662	tmp = buffer.ptr;
	663	else
	664	tmp = pbuffer = (new void[sz]).ptr;
	665
	666	for (size_t u = 0; u < len; u += sz)
	667	{ size_t o = u * sz;
	668	memcpy(tmp, p1 + o, sz);
	669	memcpy(p1 + o, p2 + o, sz);
	670	memcpy(p2 + o, tmp, sz);
	671	}
	672	if (pbuffer)
	673	delete pbuffer;
683	674	}
684	675
685	676	override void[] init() { return value.init(); }
686	677	override TypeInfo next() { return value; }
687	678	override uint flags() { return value.flags(); }
688	679
689	680	override void destroy(void *p)
690	681	{
691	682	auto sz = value.tsize();
692	683	p += sz * len;
…	…
708	699	}
709	700
710	701	TypeInfo value;
711	702	size_t len;
712	703	}
713	704
714	705	class TypeInfo_AssociativeArray : TypeInfo
715	706	{
716	707	override string toString()
717	708	{
718		return cast(string) (value.toString() ~ "[" ~ key.toString() ~ "]");
719		}
720
721		override ~~int~~ opEquals(Object o)
	709	return cast(string) (value.toString() ~ "[" ~ key.toString() ~ "]");
	710	}
	711
	712	override bool opEquals(Object o)
722	713	{ TypeInfo_AssociativeArray c;
723	714
724	715	return this is o \|\|
725	716	((c = cast(TypeInfo_AssociativeArray)o) !is null &&
726	717	this.key == c.key &&
727	718	this.value == c.value);
728	719	}
729	720
730	721	// BUG: need to add the rest of the functions
731	722
…	…
738	729	override uint flags() { return 1; }
739	730
740	731	TypeInfo value;
741	732	TypeInfo key;
742	733	}
743	734
744	735	class TypeInfo_Function : TypeInfo
745	736	{
746	737	override string toString()
747	738	{
748		return cast(string) (next.toString() ~ "()");
749		}
750
751		override ~~int~~ opEquals(Object o)
	739	return cast(string) (next.toString() ~ "()");
	740	}
	741
	742	override bool opEquals(Object o)
752	743	{ TypeInfo_Function c;
753	744
754	745	return this is o \|\|
755	746	((c = cast(TypeInfo_Function)o) !is null &&
756	747	this.next == c.next);
757	748	}
758	749
759	750	// BUG: need to add the rest of the functions
760	751
761	752	override size_t tsize()
…	…
763	754	return 0; // no size for functions
764	755	}
765	756
766	757	TypeInfo next; // function return type
767	758	}
768	759
769	760	class TypeInfo_Delegate : TypeInfo
770	761	{
771	762	override string toString()
772	763	{
773		return cast(string) (next.toString() ~ " delegate()");
774		}
775
776		override ~~int~~ opEquals(Object o)
	764	return cast(string) (next.toString() ~ " delegate()");
	765	}
	766
	767	override bool opEquals(Object o)
777	768	{ TypeInfo_Delegate c;
778	769
779	770	return this is o \|\|
780	771	((c = cast(TypeInfo_Delegate)o) !is null &&
781	772	this.next == c.next);
782	773	}
783	774
784	775	// BUG: need to add the rest of the functions
785	776
786	777	override size_t tsize()
787		{
788		alias int delegate() dg;
789		return dg.sizeof;
	778	{ alias int delegate() dg;
	779	return dg.sizeof;
790	780	}
791	781
792	782	override uint flags() { return 1; }
793	783
794	784	TypeInfo next; // delegate return type
795	785	}
796	786
797	787	class TypeInfo_Class : TypeInfo
798	788	{
799	789	override string toString() { return info.name; }
800	790
801		override ~~int~~ opEquals(Object o)
	791	override bool opEquals(Object o)
802	792	{ TypeInfo_Class c;
803	793
804	794	return this is o \|\|
805	795	((c = cast(TypeInfo_Class)o) !is null &&
806	796	this.info.name == c.classinfo.name);
807	797	}
808	798
809	799	override hash_t getHash(in void *p)
810	800	{
811		Object o = cast(Object)p;
812		return o ? o.toHash() : 0;
813		}
814
815		override ~~int~~ equals(in void p1, in void p2)
816		{
817		Object o1 = cast(Object)p1;
818		Object o2 = cast(Object)p2;
819
820		return (o1 is o2) \|\| (o1 && o1.opEquals(o2));
	801	Object o = cast(Object)p;
	802	return o ? o.toHash() : 0;
	803	}
	804
	805	override bool equals(in void p1, in void p2)
	806	{
	807	Object o1 = cast(Object)p1;
	808	Object o2 = cast(Object)p2;
	809
	810	return (o1 is o2) \|\| (o1 && o1.opEquals(o2));
821	811	}
822	812
823	813	override int compare(in void p1, in void p2)
824	814	{
825		Object o1 = cast(Object)p1;
826		Object o2 = cast(Object)p2;
827		int c = 0;
828
829		// Regard null references as always being "less than"
830		if (o1 !is o2)
831		{
832		if (o1)
833		{
834		if (!o2)
835		c = 1;
836		else
837		c = o1.opCmp(o2);
838		}
839		else
840		c = -1;
841		}
842		return c;
	815	Object o1 = cast(Object)p1;
	816	Object o2 = cast(Object)p2;
	817	int c = 0;
	818
	819	// Regard null references as always being "less than"
	820	if (o1 !is o2)
	821	{
	822	if (o1)
	823	{ if (!o2)
	824	c = 1;
	825	else
	826	c = o1.opCmp(o2);
	827	}
	828	else
	829	c = -1;
	830	}
	831	return c;
843	832	}
844	833
845	834	override size_t tsize()
846	835	{
847	836	return Object.sizeof;
848	837	}
849	838
850	839	override uint flags() { return 1; }
851	840
852	841	override OffsetTypeInfo[] offTi()
…	…
854	843	return (info.flags & 4) ? info.offTi : null;
855	844	}
856	845
857	846	ClassInfo info;
858	847	}
859	848
860	849	class TypeInfo_Interface : TypeInfo
861	850	{
862	851	override string toString() { return info.name; }
863	852
864		override ~~int~~ opEquals(Object o)
	853	override bool opEquals(Object o)
865	854	{ TypeInfo_Interface c;
866	855
867	856	return this is o \|\|
868	857	((c = cast(TypeInfo_Interface)o) !is null &&
869	858	this.info.name == c.classinfo.name);
870	859	}
871	860
872	861	override hash_t getHash(in void *p)
873	862	{
874		Interface* pi = cast(Interface )cast(void**)p;
875		Object o = cast(Object)(cast(void*)p - pi.offset);
876		assert(o);
877		return o.toHash();
878		}
879
880		override ~~int~~ equals(in void p1, in void p2)
881		{
882		Interface* pi = cast(Interface )cast(void**)p1;
883		Object o1 = cast(Object)(cast(void*)p1 - pi.offset);
884		pi = cast(Interface )cast(void**)p2;
885		Object o2 = cast(Object)(cast(void*)p2 - pi.offset);
886
887		return o1 == o2 \|\| (o1 && o1.opCmp(o2) == 0);
	863	Interface* pi = cast(Interface )cast(void**)p;
	864	Object o = cast(Object)(cast(void*)p - pi.offset);
	865	assert(o);
	866	return o.toHash();
	867	}
	868
	869	override bool equals(in void p1, in void p2)
	870	{
	871	Interface* pi = cast(Interface )cast(void**)p1;
	872	Object o1 = cast(Object)(cast(void*)p1 - pi.offset);
	873	pi = cast(Interface )cast(void**)p2;
	874	Object o2 = cast(Object)(cast(void*)p2 - pi.offset);
	875
	876	return o1 == o2 \|\| (o1 && o1.opCmp(o2) == 0);
888	877	}
889	878
890	879	override int compare(in void p1, in void p2)
891	880	{
892		Interface* pi = cast(Interface )cast(void**)p1;
893		Object o1 = cast(Object)(cast(void*)p1 - pi.offset);
894		pi = cast(Interface )cast(void**)p2;
895		Object o2 = cast(Object)(cast(void*)p2 - pi.offset);
896		int c = 0;
897
898		// Regard null references as always being "less than"
899		if (o1 != o2)
900		{
901		if (o1)
902		{
903		if (!o2)
904		c = 1;
905		else
906		c = o1.opCmp(o2);
907		}
908		else
909		c = -1;
910		}
911		return c;
	881	Interface* pi = cast(Interface )cast(void**)p1;
	882	Object o1 = cast(Object)(cast(void*)p1 - pi.offset);
	883	pi = cast(Interface )cast(void**)p2;
	884	Object o2 = cast(Object)(cast(void*)p2 - pi.offset);
	885	int c = 0;
	886
	887	// Regard null references as always being "less than"
	888	if (o1 != o2)
	889	{
	890	if (o1)
	891	{ if (!o2)
	892	c = 1;
	893	else
	894	c = o1.opCmp(o2);
	895	}
	896	else
	897	c = -1;
	898	}
	899	return c;
912	900	}
913	901
914	902	override size_t tsize()
915	903	{
916	904	return Object.sizeof;
917	905	}
918	906
919	907	override uint flags() { return 1; }
920	908
921	909	ClassInfo info;
922	910	}
923	911
924	912	class TypeInfo_Struct : TypeInfo
925	913	{
926	914	override string toString() { return name; }
927	915
928		override ~~int~~ opEquals(Object o)
	916	override bool opEquals(Object o)
929	917	{ TypeInfo_Struct s;
930	918
931	919	return this is o \|\|
932	920	((s = cast(TypeInfo_Struct)o) !is null &&
933	921	this.name == s.name &&
934	922	this.init.length == s.init.length);
935	923	}
936	924
937	925	override hash_t getHash(in void *p)
938		{
939		hash_t h;
940
941		assert(p);
942		if (xtoHash)
943		{ //printf("getHash() using xtoHash\n");
944		h = (*xtoHash)(p);
945		}
946		else
947		{
948		//printf("getHash() using default hash\n");
949		// A sorry hash algorithm.
950		// Should use the one for strings.
951		// BUG: relies on the GC not moving objects
952		auto q = cast(const(ubyte)*)p;
953		for (size_t i = 0; i < init.length; i++)
954		{
955		h = h * 9 + *q;
956		q++;
957		}
958		}
959		return h;
960		}
961
962		override int equals(in void p2, in void p1)
963		{
964		int c;
965
966		if (p1 == p2)
967		c = 1;
968		else if (!p1 \|\| !p2)
969		c = 0;
970		else if (xopEquals)
971		c = (*xopEquals)(p1, p2);
972		else
973		// BUG: relies on the GC not moving objects
974		c = (memcmp(p1, p2, init.length) == 0);
975		return c;
	926	{ hash_t h;
	927
	928	assert(p);
	929	if (xtoHash)
	930	{ //printf("getHash() using xtoHash\n");
	931	h = (*xtoHash)(p);
	932	}
	933	else
	934	{
	935	//printf("getHash() using default hash\n");
	936	// A sorry hash algorithm.
	937	// Should use the one for strings.
	938	// BUG: relies on the GC not moving objects
	939	auto q = cast(const(ubyte)*)p;
	940	for (size_t i = 0; i < init.length; i++)
	941	{ h = h * 9 + *q;
	942	q++;
	943	}
	944	}
	945	return h;
	946	}
	947
	948	override bool equals(in void p2, in void p1)
	949	{ bool c;
	950
	951	if (p1 == p2)
	952	c = 1;
	953	else if (!p1 \|\| !p2)
	954	c = 0;
	955	else if (xopEquals)
	956	c = (*xopEquals)(p1, p2);
	957	else
	958	// BUG: relies on the GC not moving objects
	959	c = (memcmp(p1, p2, init.length) == 0);
	960	return c;
976	961	}
977	962
978	963	override int compare(in void p2, in void p1)
979	964	{
980		int c = 0;
981
982		// Regard null references as always being "less than"
983		if (p1 != p2)
984		{
985		if (p1)
986		{
987		if (!p2)
988		c = 1;
989		else if (xopCmp)
990		c = (*xopCmp)(p1, p2);
991		else
992		// BUG: relies on the GC not moving objects
993		c = memcmp(p1, p2, init.length);
994		}
995		else
996		c = -1;
997		}
998		return c;
	965	int c = 0;
	966
	967	// Regard null references as always being "less than"
	968	if (p1 != p2)
	969	{
	970	if (p1)
	971	{ if (!p2)
	972	c = 1;
	973	else if (xopCmp)
	974	c = (*xopCmp)(p1, p2);
	975	else
	976	// BUG: relies on the GC not moving objects
	977	c = memcmp(p1, p2, init.length);
	978	}
	979	else
	980	c = -1;
	981	}
	982	return c;
999	983	}
1000	984
1001	985	override size_t tsize()
1002	986	{
1003	987	return init.length;
1004	988	}
1005	989
1006	990	override void[] init() { return m_init; }
1007	991
1008	992	override uint flags() { return m_flags; }
…	…
1016	1000	override void postblit(void *p)
1017	1001	{
1018	1002	if (xpostblit)
1019	1003	(*xpostblit)(p);
1020	1004	}
1021	1005
1022	1006	string name;
1023	1007	void[] m_init; // initializer; init.ptr == null if 0 initialize
1024	1008
1025	1009	hash_t function(in void*) xtoHash;
1026		~~int~~ function(in void, in void) xopEquals;
	1010	bool function(in void, in void) xopEquals;
1027	1011	int function(in void, in void) xopCmp;
1028	1012	string function(const(void)*) xtoString;
1029	1013
1030	1014	uint m_flags;
1031	1015
1032	1016	const(MemberInfo[]) function(string) xgetMembers;
1033	1017	void function(void*) xdtor;
1034	1018	void function(void*) xpostblit;
1035	1019	}
1036	1020
…	…
1045	1029	foreach (i, element; elements)
1046	1030	{
1047	1031	if (i)
1048	1032	s ~= ',';
1049	1033	s ~= element.toString();
1050	1034	}
1051	1035	s ~= ")";
1052	1036	return s;
1053	1037	}
1054	1038
1055		override ~~int~~ opEquals(Object o)
1056		{
1057		if (this is o)
1058		return 1;
1059
1060		auto t = cast(TypeInfo_Tuple)o;
1061		if (t && elements.length == t.elements.length)
1062		{
1063		for (size_t i = 0; i < elements.length; i++)
1064		{
1065		if (elements[i] != t.elements[i])
1066		return 0;
1067		}
1068		return 1;
1069		}
1070		return 0;
	1039	override bool opEquals(Object o)
	1040	{
	1041	if (this is o)
	1042	return 1;
	1043
	1044	auto t = cast(TypeInfo_Tuple)o;
	1045	if (t && elements.length == t.elements.length)
	1046	{
	1047	for (size_t i = 0; i < elements.length; i++)
	1048	{
	1049	if (elements[i] != t.elements[i])
	1050	return 0;
	1051	}
	1052	return 1;
	1053	}
	1054	return 0;
1071	1055	}
1072	1056
1073	1057	override hash_t getHash(in void *p)
1074	1058	{
1075	1059	assert(0);
1076	1060	}
1077	1061
1078		override ~~int~~ equals(in void p1, in void p2)
	1062	override bool equals(in void p1, in void p2)
1079	1063	{
1080	1064	assert(0);
1081	1065	}
1082	1066
1083	1067	override int compare(in void p1, in void p2)
1084	1068	{
1085	1069	assert(0);
1086	1070	}
1087	1071
1088	1072	override size_t tsize()
…	…
1104	1088	{
1105	1089	assert(0);
1106	1090	}
1107	1091	}
1108	1092
1109	1093	class TypeInfo_Const : TypeInfo
1110	1094	{
1111	1095	override string toString() { return cast(string)
1112	1096	("const(" ~ base.toString() ~ ")"); }
1113	1097
1114		override ~~int~~ opEquals(Object o) { return base.opEquals(o); }
	1098	override bool opEquals(Object o) { return base.opEquals(o); }
1115	1099	override hash_t getHash(in void *p) { return base.getHash(p); }
1116		override ~~int~~ equals(in void p1, in void p2) { return base.equals(p1, p2); }
	1100	override bool equals(in void p1, in void p2) { return base.equals(p1, p2); }
1117	1101	override int compare(in void p1, in void p2) { return base.compare(p1, p2); }
1118	1102	override size_t tsize() { return base.tsize(); }
1119	1103	override void swap(void p1, void p2) { return base.swap(p1, p2); }
1120	1104
1121	1105	override TypeInfo next() { return base.next(); }
1122	1106	override uint flags() { return base.flags(); }
1123	1107	override void[] init() { return base.init(); }
1124	1108
1125	1109	TypeInfo base;
1126	1110	}

trunk/phobos/object.d

r550	r761
17	17	{ int printf(in char *, ...);
18	18	void trace_term();
19	19	}
20	20
21	21	class Object
22	22	{
23	23	void print();
24	24	string toString();
25	25	hash_t toHash();
26	26	int opCmp(Object o);
27		~~int~~ opEquals(Object o);
	27	bool opEquals(Object o);
28	28
29	29	final void notifyRegister(void delegate(Object) dg);
30	30	final void notifyUnRegister(void delegate(Object) dg);
31	31
32	32	static Object factory(string classname);
33	33	}
34	34
35	35	struct Interface
36	36	{
37	37	ClassInfo classinfo;
…	…
138	138	{
139	139	ClassInfo info;
140	140	}
141	141
142	142	class TypeInfo_Struct : TypeInfo
143	143	{
144	144	string name;
145	145	void[] m_init;
146	146
147	147	uint function(in void*) xtoHash;
148		~~int~~ function(in void, in void) xopEquals;
	148	bool function(in void, in void) xopEquals;
149	149	int function(in void, in void) xopCmp;
150	150	string function(const(void)*) xtoString;
151	151
152	152	uint m_flags;
153	153
154	154	const(MemberInfo[]) function(string) xgetMembers;
155	155	void function(void*) xdtor;
156	156	void function(void*) xpostblit;
157	157	}
158	158

trunk/phobos/std/bitmanip.d

r689	r761
540	540	assert(ba[i] == false);
541	541	for (size_t i = 6; i < 10; i++)
542	542	assert(ba[i] == true);
543	543	}
544	544
545	545
546	546	/***************************************
547	547	* Support for operators == and != for bit arrays.
548	548	*/
549	549
550		~~int~~ opEquals(BitArray a2)
	550	bool opEquals(BitArray a2)
551	551	{ int i;
552	552
553	553	if (this.length != a2.length)
554	554	return 0; // not equal
555	555	byte p1 = cast(byte)this.ptr;
556	556	byte p2 = cast(byte)a2.ptr;
557	557	uint n = this.length / 8;
558	558	for (i = 0; i < n; i++)
559	559	{
560	560	if (p1[i] != p2[i])

trunk/phobos/std/regexp.d

r589	r761
1372	1372	break;
1373	1373	//debug(regexp) printf("Starting new try: '%.*s'\n", input[si + 1 .. input.length]);
1374	1374	}
1375	1375	return 0; // no match
1376	1376	}
1377	1377
1378	1378	/**
1379	1379	Returns whether string $(D_PARAM s) matches $(D_PARAM this).
1380	1380	*/
1381	1381	alias test opEquals;
1382		// ~~int~~ opEquals(string s)
	1382	// bool opEquals(string s)
1383	1383	// {
1384	1384	// return test(s);
1385	1385	// }
1386	1386
1387	1387	unittest
1388	1388	{
1389	1389	assert("abc" == RegExp(".b."));
1390	1390	assert("abc" != RegExp(".b.."));
1391	1391	}
1392	1392

trunk/phobos/std/typeinfo/ti_AC.d

r408	r761
9	9	hash_t hash = 0;
10	10
11	11	foreach (Object o; s)
12	12	{
13	13	if (o)
14	14	hash += o.toHash();
15	15	}
16	16	return hash;
17	17	}
18	18
19		override ~~int~~ equals(in void p1, in void p2)
	19	override bool equals(in void p1, in void p2)
20	20	{
21	21	Object[] s1 = cast(Object[])p1;
22	22	Object[] s2 = cast(Object[])p2;
23	23
24	24	if (s1.length == s2.length)
25	25	{
26	26	for (size_t u = 0; u < s1.length; u++)
27	27	{ Object o1 = s1[u];
28	28	Object o2 = s2[u];
29	29

trunk/phobos/std/typeinfo/ti_Acdouble.d

r408	r761
44	44	hash += (cast(uint *)str)[1];
45	45	hash += (cast(uint *)str)[2];
46	46	hash += (cast(uint *)str)[3];
47	47	str++;
48	48	len--;
49	49	}
50	50
51	51	return hash;
52	52	}
53	53
54		override ~~int~~ equals(in void p1, in void p2)
	54	override bool equals(in void p1, in void p2)
55	55	{
56	56	cdouble[] s1 = cast(cdouble[])p1;
57	57	cdouble[] s2 = cast(cdouble[])p2;
58	58	size_t len = s1.length;
59	59
60	60	if (len != s2.length)
61	61	return 0;
62	62	for (size_t u = 0; u < len; u++)
63	63	{
64		~~int~~ c = TypeInfo_r._equals(s1[u], s2[u]);
65		if (~~c == 0~~)
	64	auto c = TypeInfo_r._equals(s1[u], s2[u]);
	65	if (!c)
66	66	return 0;
67	67	}
68	68	return 1;
69	69	}
70	70
71	71	override int compare(in void p1, in void p2)
72	72	{
73	73	cdouble[] s1 = cast(cdouble[])p1;
74	74	cdouble[] s2 = cast(cdouble[])p2;
75	75	size_t len = s1.length;

trunk/phobos/std/typeinfo/ti_Acfloat.d

r408	r761
42	42	hash *= 9;
43	43	hash += (cast(uint *)str)[0];
44	44	hash += (cast(uint *)str)[1];
45	45	str++;
46	46	len--;
47	47	}
48	48
49	49	return hash;
50	50	}
51	51
52		override ~~int~~ equals(in void p1, in void p2)
	52	override bool equals(in void p1, in void p2)
53	53	{
54	54	cfloat[] s1 = cast(cfloat[])p1;
55	55	cfloat[] s2 = cast(cfloat[])p2;
56	56	size_t len = s1.length;
57	57
58	58	if (len != s2.length)
59	59	return 0;
60	60	for (size_t u = 0; u < len; u++)
61	61	{
62		~~int~~ c = TypeInfo_q._equals(s1[u], s2[u]);
	62	auto c = TypeInfo_q._equals(s1[u], s2[u]);
63	63	if (c == 0)
64	64	return 0;
65	65	}
66	66	return 1;
67	67	}
68	68
69	69	override int compare(in void p1, in void p2)
70	70	{
71	71	cfloat[] s1 = cast(cfloat[])p1;
72	72	cfloat[] s2 = cast(cfloat[])p2;

trunk/phobos/std/typeinfo/ti_Acreal.d

r408	r761
45	45	hash += (cast(uint *)str)[2];
46	46	hash += (cast(uint *)str)[3];
47	47	hash += (cast(uint *)str)[4];
48	48	str++;
49	49	len--;
50	50	}
51	51
52	52	return hash;
53	53	}
54	54
55		override ~~int~~ equals(in void p1, in void p2)
	55	override bool equals(in void p1, in void p2)
56	56	{
57	57	creal[] s1 = cast(creal[])p1;
58	58	creal[] s2 = cast(creal[])p2;
59	59	size_t len = s1.length;
60	60
61	61	if (len != s2.length)
62	62	return 0;
63	63	for (size_t u = 0; u < len; u++)
64	64	{
65		~~int~~ c = TypeInfo_c._equals(s1[u], s2[u]);
	65	auto c = TypeInfo_c._equals(s1[u], s2[u]);
66	66	if (c == 0)
67	67	return 0;
68	68	}
69	69	return 1;
70	70	}
71	71
72	72	override int compare(in void p1, in void p2)
73	73	{
74	74	creal[] s1 = cast(creal[])p1;
75	75	creal[] s2 = cast(creal[])p2;

trunk/phobos/std/typeinfo/ti_Adouble.d

r408	r761
42	42	hash *= 9;
43	43	hash += (cast(uint *)str)[0];
44	44	hash += (cast(uint *)str)[1];
45	45	str++;
46	46	len--;
47	47	}
48	48
49	49	return hash;
50	50	}
51	51
52		override ~~int~~ equals(in void p1, in void p2)
	52	override bool equals(in void p1, in void p2)
53	53	{
54	54	double[] s1 = cast(double[])p1;
55	55	double[] s2 = cast(double[])p2;
56	56	size_t len = s1.length;
57	57
58	58	if (len != s2.length)
59	59	return 0;
60	60	for (size_t u = 0; u < len; u++)
61	61	{
62		~~int~~ c = TypeInfo_d._equals(s1[u], s2[u]);
63		if (~~c == 0~~)
	62	auto c = TypeInfo_d._equals(s1[u], s2[u]);
	63	if (!c)
64	64	return 0;
65	65	}
66	66	return 1;
67	67	}
68	68
69	69	override int compare(in void p1, in void p2)
70	70	{
71	71	double[] s1 = cast(double[])p1;
72	72	double[] s2 = cast(double[])p2;
73	73	size_t len = s1.length;

trunk/phobos/std/typeinfo/ti_Afloat.d

r408	r761
41	41	{
42	42	hash *= 9;
43	43	hash += cast(uint )str;
44	44	str++;
45	45	len--;
46	46	}
47	47
48	48	return hash;
49	49	}
50	50
51		override ~~int~~ equals(in void p1, in void p2)
	51	override bool equals(in void p1, in void p2)
52	52	{
53	53	float[] s1 = cast(float[])p1;
54	54	float[] s2 = cast(float[])p2;
55	55	size_t len = s1.length;
56	56
57	57	if (len != s2.length)
58	58	return 0;
59	59	for (size_t u = 0; u < len; u++)
60	60	{
61		~~int~~ c = TypeInfo_f._equals(s1[u], s2[u]);
62		if (~~c == 0~~)
	61	auto c = TypeInfo_f._equals(s1[u], s2[u]);
	62	if (!c)
63	63	return 0;
64	64	}
65	65	return 1;
66	66	}
67	67
68	68	override int compare(in void p1, in void p2)
69	69	{
70	70	float[] s1 = cast(float[])p1;
71	71	float[] s2 = cast(float[])p2;
72	72	size_t len = s1.length;

trunk/phobos/std/typeinfo/ti_Ag.d

r408	r761
44	44	hash += cast(uint )str;
45	45	str += 4;
46	46	len -= 4;
47	47	break;
48	48	}
49	49	}
50	50
51	51	return hash;
52	52	}
53	53
54		override ~~int~~ equals(in void p1, in void p2)
	54	override bool equals(in void p1, in void p2)
55	55	{
56	56	byte[] s1 = cast(byte[])p1;
57	57	byte[] s2 = cast(byte[])p2;
58	58
59	59	return s1.length == s2.length &&
60	60	memcmp(cast(byte )s1, cast(byte )s2, s1.length) == 0;
61	61	}
62	62
63	63	override int compare(in void p1, in void p2)
64	64	{

trunk/phobos/std/typeinfo/ti_Aint.d

r703	r761
19	19	{
20	20	hash *= 9;
21	21	hash += cast(uint )str;
22	22	str++;
23	23	len--;
24	24	}
25	25
26	26	return hash;
27	27	}
28	28
29		override ~~int~~ equals(in void p1, in void p2)
	29	override bool equals(in void p1, in void p2)
30	30	{
31	31	int[] s1 = cast(int[])p1;
32	32	int[] s2 = cast(int[])p2;
33	33
34	34	return s1.length == s2.length &&
35	35	memcmp(cast(void )s1, cast(void )s2, s1.length * int.sizeof) == 0;
36	36	}
37	37
38	38	override int compare(in void p1, in void p2)
39	39	{

trunk/phobos/std/typeinfo/ti_Along.d

r408	r761
19	19	{
20	20	hash *= 9;
21	21	hash += cast(uint )str + (cast(uint )str + 1);
22	22	str++;
23	23	len--;
24	24	}
25	25
26	26	return hash;
27	27	}
28	28
29		override ~~int~~ equals(in void p1, in void p2)
	29	override bool equals(in void p1, in void p2)
30	30	{
31	31	long[] s1 = cast(long[])p1;
32	32	long[] s2 = cast(long[])p2;
33	33
34	34	return s1.length == s2.length &&
35	35	memcmp(cast(void )s1, cast(void )s2, s1.length * long.sizeof) == 0;
36	36	}
37	37
38	38	override int compare(in void p1, in void p2)
39	39	{

trunk/phobos/std/typeinfo/ti_Areal.d

r408	r761
43	43	hash += (cast(uint *)str)[0];
44	44	hash += (cast(uint *)str)[1];
45	45	hash += (cast(ushort *)str)[4];
46	46	str++;
47	47	len--;
48	48	}
49	49
50	50	return hash;
51	51	}
52	52
53		override ~~int~~ equals(in void p1, in void p2)
	53	override bool equals(in void p1, in void p2)
54	54	{
55	55	real[] s1 = cast(real[])p1;
56	56	real[] s2 = cast(real[])p2;
57	57	size_t len = s1.length;
58	58
59	59	if (len != s2.length)
60	60	return 0;
61	61	for (size_t u = 0; u < len; u++)
62	62	{
63		~~int~~ c = TypeInfo_e._equals(s1[u], s2[u]);
64		if (c == 0)
65		return 0;
	63	bool c = TypeInfo_e._equals(s1[u], s2[u]);
	64	if (c == false)
	65	return false;
66	66	}
67	67	return 1;
68	68	}
69	69
70	70	override int compare(in void p1, in void p2)
71	71	{
72	72	real[] s1 = cast(real[])p1;
73	73	real[] s2 = cast(real[])p2;
74	74	size_t len = s1.length;
75	75

trunk/phobos/std/typeinfo/ti_Ashort.d

r408	r761
32	32	hash += cast(uint )str;
33	33	str += 2;
34	34	len -= 2;
35	35	break;
36	36	}
37	37	}
38	38
39	39	return hash;
40	40	}
41	41
42		override ~~int~~ equals(in void p1, in void p2)
	42	override bool equals(in void p1, in void p2)
43	43	{
44	44	short[] s1 = cast(short[])p1;
45	45	short[] s2 = cast(short[])p2;
46	46
47	47	return s1.length == s2.length &&
48	48	memcmp(cast(void )s1, cast(void )s2, s1.length * short.sizeof) == 0;
49	49	}
50	50
51	51	override int compare(in void p1, in void p2)
52	52	{

trunk/phobos/std/typeinfo/ti_byte.d

r408	r761
5	5
6	6	class TypeInfo_g : TypeInfo
7	7	{
8	8	override string toString() { return "byte"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(byte )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(byte )p1 == cast(byte )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
25	25	override size_t tsize()

trunk/phobos/std/typeinfo/ti_C.d

r664	r761
26	26	// Object
27	27
28	28	class TypeInfo_C : TypeInfo
29	29	{
30	30	override hash_t getHash(in void *p)
31	31	{
32	32	Object o = cast(Object)p;
33	33	return o ? o.toHash() : 0;
34	34	}
35	35
36		override ~~int~~ equals(in void p1, in void p2)
	36	override bool equals(in void p1, in void p2)
37	37	{
38	38	Object o1 = cast(Object)p1;
39	39	Object o2 = cast(Object)p2;
40	40
41	41	return o1 == o2;
42	42	}
43	43
44	44	override int compare(in void p1, in void p2)
45	45	{
46	46	Object o1 = cast(Object)p1;

trunk/phobos/std/typeinfo/ti_cdouble.d

r408	r761
6	6	class TypeInfo_r : TypeInfo
7	7	{
8	8	override string toString() { return "cdouble"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1] +
13	13	(cast(uint )p)[2] + (cast(uint )p)[3];
14	14	}
15	15
16		static ~~int~~ _equals(cdouble f1, cdouble f2)
	16	static bool _equals(cdouble f1, cdouble f2)
17	17	{
18	18	return f1 == f2;
19	19	}
20	20
21	21	static int _compare(cdouble f1, cdouble f2)
22	22	{ int result;
23	23
24	24	if (f1.re < f2.re)
25	25	result = -1;
26	26	else if (f1.re > f2.re)
27	27	result = 1;
28	28	else if (f1.im < f2.im)
29	29	result = -1;
30	30	else if (f1.im > f2.im)
31	31	result = 1;
32	32	else
33	33	result = 0;
34	34	return result;
35	35	}
36	36
37		override ~~int~~ equals(in void p1, in void p2)
	37	override bool equals(in void p1, in void p2)
38	38	{
39	39	return _equals(cast(cdouble )p1, cast(cdouble )p2);
40	40	}
41	41
42	42	override int compare(in void p1, in void p2)
43	43	{
44	44	return _compare(cast(cdouble )p1, cast(cdouble )p2);
45	45	}
46	46
47	47	override size_t tsize()

trunk/phobos/std/typeinfo/ti_cfloat.d

r408	r761
5	5
6	6	class TypeInfo_q : TypeInfo
7	7	{
8	8	override string toString() { return "cfloat"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1];
13	13	}
14	14
15		static ~~int~~ _equals(cfloat f1, cfloat f2)
	15	static bool _equals(cfloat f1, cfloat f2)
16	16	{
17	17	return f1 == f2;
18	18	}
19	19
20	20	static int _compare(cfloat f1, cfloat f2)
21	21	{ int result;
22	22
23	23	if (f1.re < f2.re)
24	24	result = -1;
25	25	else if (f1.re > f2.re)
26	26	result = 1;
27	27	else if (f1.im < f2.im)
28	28	result = -1;
29	29	else if (f1.im > f2.im)
30	30	result = 1;
31	31	else
32	32	result = 0;
33	33	return result;
34	34	}
35	35
36		override ~~int~~ equals(in void p1, in void p2)
	36	override bool equals(in void p1, in void p2)
37	37	{
38	38	return _equals(cast(cfloat )p1, cast(cfloat )p2);
39	39	}
40	40
41	41	override int compare(in void p1, in void p2)
42	42	{
43	43	return _compare(cast(cfloat )p1, cast(cfloat )p2);
44	44	}
45	45
46	46	override size_t tsize()

trunk/phobos/std/typeinfo/ti_char.d

r408	r761
3	3
4	4	class TypeInfo_a : TypeInfo
5	5	{
6	6	override string toString() { return "char"; }
7	7
8	8	override hash_t getHash(in void *p)
9	9	{
10	10	return cast(char )p;
11	11	}
12	12
13		override ~~int~~ equals(in void p1, in void p2)
	13	override bool equals(in void p1, in void p2)
14	14	{
15	15	return cast(char )p1 == cast(char )p2;
16	16	}
17	17
18	18	override int compare(in void p1, in void p2)
19	19	{
20	20	return cast(char )p1 - cast(char )p2;
21	21	}
22	22
23	23	override size_t tsize()

trunk/phobos/std/typeinfo/ti_creal.d

r408	r761
7	7	{
8	8	override string toString() { return "creal"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return (cast(uint )p)[0] + (cast(uint )p)[1] +
13	13	(cast(uint )p)[2] + (cast(uint )p)[3] +
14	14	(cast(uint *)p)[4];
15	15	}
16	16
17		static ~~int~~ _equals(creal f1, creal f2)
	17	static bool _equals(creal f1, creal f2)
18	18	{
19	19	return f1 == f2;
20	20	}
21	21
22	22	static int _compare(creal f1, creal f2)
23	23	{ int result;
24	24
25	25	if (f1.re < f2.re)
26	26	result = -1;
27	27	else if (f1.re > f2.re)
28	28	result = 1;
29	29	else if (f1.im < f2.im)
30	30	result = -1;
31	31	else if (f1.im > f2.im)
32	32	result = 1;
33	33	else
34	34	result = 0;
35	35	return result;
36	36	}
37	37
38		override ~~int~~ equals(in void p1, in void p2)
	38	override bool equals(in void p1, in void p2)
39	39	{
40	40	return _equals(cast(creal )p1, cast(creal )p2);
41	41	}
42	42
43	43	override int compare(in void p1, in void p2)
44	44	{
45	45	return _compare(cast(creal )p1, cast(creal )p2);
46	46	}
47	47
48	48	override size_t tsize()

trunk/phobos/std/typeinfo/ti_dchar.d

r408	r761
5	5
6	6	class TypeInfo_w : TypeInfo
7	7	{
8	8	override string toString() { return "dchar"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(dchar )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(dchar )p1 == cast(dchar )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	return cast(dchar )p1 - cast(dchar )p2;
23	23	}
24	24
25	25	override size_t tsize()

trunk/phobos/std/typeinfo/ti_delegate.d

r408	r761
6	6	alias void delegate(int) dg;
7	7
8	8	class TypeInfo_D : TypeInfo
9	9	{
10	10	override hash_t getHash(in void *p)
11	11	{ long l = cast(long )p;
12	12
13	13	return cast(uint)(l + (l >> 32));
14	14	}
15	15
16		override ~~int~~ equals(in void p1, in void p2)
	16	override bool equals(in void p1, in void p2)
17	17	{
18	18	return cast(dg )p1 == cast(dg )p2;
19	19	}
20	20
21	21	override size_t tsize()
22	22	{
23	23	return dg.sizeof;
24	24	}
25	25
26	26	override void swap(void p1, void p2)

trunk/phobos/std/typeinfo/ti_double.d

r408	r761
7	7
8	8	class TypeInfo_d : TypeInfo
9	9	{
10	10	override string toString() { return "double"; }
11	11
12	12	override hash_t getHash(in void *p)
13	13	{
14	14	return (cast(uint )p)[0] + (cast(uint )p)[1];
15	15	}
16	16
17		static ~~int~~ _equals(double f1, double f2)
	17	static bool _equals(double f1, double f2)
18	18	{
19	19	return f1 == f2 \|\|
20	20	(isnan(f1) && isnan(f2));
21	21	}
22	22
23	23	static int _compare(double d1, double d2)
24	24	{
25	25	if (d1 !<>= d2) // if either are NaN
26	26	{
27	27	if (isnan(d1))
28	28	{ if (isnan(d2))
29	29	return 0;
30	30	return -1;
31	31	}
32	32	return 1;
33	33	}
34	34	return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
35	35	}
36	36
37		override ~~int~~ equals(in void p1, in void p2)
	37	override bool equals(in void p1, in void p2)
38	38	{
39	39	return _equals(cast(double )p1, cast(double )p2);
40	40	}
41	41
42	42	override int compare(in void p1, in void p2)
43	43	{
44	44	return _compare(cast(double )p1, cast(double )p2);
45	45	}
46	46
47	47	override size_t tsize()

trunk/phobos/std/typeinfo/ti_float.d

r408	r761
7	7
8	8	class TypeInfo_f : TypeInfo
9	9	{
10	10	override string toString() { return "float"; }
11	11
12	12	override hash_t getHash(in void *p)
13	13	{
14	14	return cast(uint )p;
15	15	}
16	16
17		static ~~int~~ _equals(float f1, float f2)
	17	static bool _equals(float f1, float f2)
18	18	{
19	19	return f1 == f2 \|\|
20	20	(isnan(f1) && isnan(f2));
21	21	}
22	22
23	23	static int _compare(float d1, float d2)
24	24	{
25	25	if (d1 !<>= d2) // if either are NaN
26	26	{
27	27	if (isnan(d1))
28	28	{ if (isnan(d2))
29	29	return 0;
30	30	return -1;
31	31	}
32	32	return 1;
33	33	}
34	34	return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
35	35	}
36	36
37		override ~~int~~ equals(in void p1, in void p2)
	37	override bool equals(in void p1, in void p2)
38	38	{
39	39	return _equals(cast(float )p1, cast(float )p2);
40	40	}
41	41
42	42	override int compare(in void p1, in void p2)
43	43	{
44	44	return _compare(cast(float )p1, cast(float )p2);
45	45	}
46	46
47	47	override size_t tsize()

trunk/phobos/std/typeinfo/ti_int.d

r408	r761
5	5
6	6	class TypeInfo_i : TypeInfo
7	7	{
8	8	override string toString() { return "int"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(uint )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(uint )p1 == cast(uint )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	if (cast(int) p1 < cast(int) p2)
23	23	return -1;
24	24	else if (cast(int) p1 > cast(int) p2)
25	25	return 1;

trunk/phobos/std/typeinfo/ti_long.d

r408	r761
5	5
6	6	class TypeInfo_l : TypeInfo
7	7	{
8	8	override string toString() { return "long"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(uint )p + (cast(uint *)p)[1];
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(long )p1 == cast(long )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	if (cast(long )p1 < cast(long )p2)
23	23	return -1;
24	24	else if (cast(long )p1 > cast(long )p2)
25	25	return 1;

trunk/phobos/std/typeinfo/ti_ptr.d

r408	r761
3	3
4	4	module std.typeinfo.ti_ptr;
5	5
6	6	class TypeInfo_P : TypeInfo
7	7	{
8	8	override hash_t getHash(in void *p)
9	9	{
10	10	return cast(uint)cast(void *)p;
11	11	}
12	12
13		override ~~int~~ equals(in void p1, in void p2)
	13	override bool equals(in void p1, in void p2)
14	14	{
15	15	return cast(void )p1 == cast(void* *)p2;
16	16	}
17	17
18	18	override int compare(in void p1, in void p2)
19	19	{
20	20	return cast(void )p1 - cast(void* *)p2;
21	21	}
22	22
23	23	override size_t tsize()

trunk/phobos/std/typeinfo/ti_real.d

r408	r761
7	7
8	8	class TypeInfo_e : TypeInfo
9	9	{
10	10	override string toString() { return "real"; }
11	11
12	12	override hash_t getHash(in void *p)
13	13	{
14	14	return (cast(uint )p)[0] + (cast(uint )p)[1] + (cast(ushort *)p)[4];
15	15	}
16	16
17		static ~~int~~ _equals(real f1, real f2)
	17	static bool _equals(real f1, real f2)
18	18	{
19	19	return f1 == f2 \|\|
20	20	(isnan(f1) && isnan(f2));
21	21	}
22	22
23	23	static int _compare(real d1, real d2)
24	24	{
25	25	if (d1 !<>= d2) // if either are NaN
26	26	{
27	27	if (isnan(d1))
28	28	{ if (isnan(d2))
29	29	return 0;
30	30	return -1;
31	31	}
32	32	return 1;
33	33	}
34	34	return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
35	35	}
36	36
37		override ~~int~~ equals(in void p1, in void p2)
	37	override bool equals(in void p1, in void p2)
38	38	{
39	39	return _equals(cast(real )p1, cast(real )p2);
40	40	}
41	41
42	42	override int compare(in void p1, in void p2)
43	43	{
44	44	return _compare(cast(real )p1, cast(real )p2);
45	45	}
46	46
47	47	override size_t tsize()

trunk/phobos/std/typeinfo/ti_short.d

r408	r761
5	5
6	6	class TypeInfo_s : TypeInfo
7	7	{
8	8	override string toString() { return "short"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(short )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(short )p1 == cast(short )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	return cast(short )p1 - cast(short )p2;
23	23	}
24	24
25	25	override size_t tsize()

trunk/phobos/std/typeinfo/ti_ubyte.d

r408	r761
5	5
6	6	class TypeInfo_h : TypeInfo
7	7	{
8	8	override string toString() { return "ubyte"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(ubyte )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(ubyte )p1 == cast(ubyte )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	return cast(ubyte )p1 - cast(ubyte )p2;
23	23	}
24	24
25	25	override size_t tsize()

trunk/phobos/std/typeinfo/ti_uint.d

r408	r761
5	5
6	6	class TypeInfo_k : TypeInfo
7	7	{
8	8	override string toString() { return "uint"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(uint )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(uint )p1 == cast(uint )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	if (cast(uint) p1 < cast(uint) p2)
23	23	return -1;
24	24	else if (cast(uint) p1 > cast(uint) p2)
25	25	return 1;

trunk/phobos/std/typeinfo/ti_ulong.d

r408	r761
5	5
6	6	class TypeInfo_m : TypeInfo
7	7	{
8	8	override string toString() { return "ulong"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(uint )p + (cast(uint *)p)[1];
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(ulong )p1 == cast(ulong )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	if (cast(ulong )p1 < cast(ulong )p2)
23	23	return -1;
24	24	else if (cast(ulong )p1 > cast(ulong )p2)
25	25	return 1;

trunk/phobos/std/typeinfo/ti_ushort.d

r408	r761
5	5
6	6	class TypeInfo_t : TypeInfo
7	7	{
8	8	override string toString() { return "ushort"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	return cast(ushort )p;
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(ushort )p1 == cast(ushort )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	return cast(ushort )p1 - cast(ushort )p2;
23	23	}
24	24
25	25	override size_t tsize()

trunk/phobos/std/typeinfo/ti_void.d

r408	r761
5	5
6	6	class TypeInfo_v : TypeInfo
7	7	{
8	8	override string toString() { return "void"; }
9	9
10	10	override hash_t getHash(in void *p)
11	11	{
12	12	assert(0);
13	13	}
14	14
15		override ~~int~~ equals(in void p1, in void p2)
	15	override bool equals(in void p1, in void p2)
16	16	{
17	17	return cast(byte )p1 == cast(byte )p2;
18	18	}
19	19
20	20	override int compare(in void p1, in void p2)
21	21	{
22	22	return cast(byte )p1 - cast(byte )p2;
23	23	}
24	24
25	25	override size_t tsize()

trunk/phobos/std/typeinfo/ti_wchar.d

r408	r761
4	4
5	5	class TypeInfo_u : TypeInfo
6	6	{
7	7	override string toString() { return "wchar"; }
8	8
9	9	override hash_t getHash(in void *p)
10	10	{
11	11	return cast(wchar )p;
12	12	}
13	13
14		override ~~int~~ equals(in void p1, in void p2)
	14	override bool equals(in void p1, in void p2)
15	15	{
16	16	return cast(wchar )p1 == cast(wchar )p2;
17	17	}
18	18
19	19	override int compare(in void p1, in void p2)
20	20	{
21	21	return cast(wchar )p1 - cast(wchar )p2;
22	22	}
23	23
24	24	override size_t tsize()

trunk/phobos/std/variant.d

r716	r761
594	594	string result;
595	595	fptr(OpID.toString, &store, &result) == 0 \|\| assert(false);
596	596	return result;
597	597	}
598	598
599	599	/**
600	600	* Comparison for equality used by the "==" and "!=" operators.
601	601	*/
602	602
603	603	// returns 1 if the two are equal
604		~~int~~ opEquals(T)(T rhs)
	604	bool opEquals(T)(T rhs)
605	605	{
606	606	static if (is(T == VariantN))
607	607	alias rhs temp;
608	608	else
609	609	auto temp = Variant(rhs);
610	610	return fptr(OpID.compare, &store, &temp) == 0;
611	611	}
612	612
613	613	/**
614	614	* Ordering comparison used by the "<", "<=", ">", and ">="

trunk/phobos/std/xml.d

r753	r761
499	499	{
500	500	/**
501	501	* Compares two Documents for equality
502	502	*
503	503	* Examples:
504	504	* --------------
505	505	* Document d1,d2;
506	506	* if (d1 == d2) { }
507	507	* --------------
508	508	*/
509		override ~~int~~ opEquals(Object o)
	509	override bool opEquals(Object o)
510	510	{
511	511	const doc = toType!(const Document)(o);
512	512	return
513	513	(prolog != doc.prolog ) ? false : (
514	514	(super != cast(const Element)doc) ? false : (
515	515	(epilog != doc.epilog ) ? false : (
516	516	true )));
517	517	}
518	518
519	519	/**
…	…
730	730
731	731	/**
732	732	* Compares two Elements for equality
733	733	*
734	734	* Examples:
735	735	* --------------
736	736	* Element e1,e2;
737	737	* if (e1 == e2) { }
738	738	* --------------
739	739	*/
740		override ~~int~~ opEquals(Object o)
	740	override bool opEquals(Object o)
741	741	{
742	742	const element = toType!(const Element)(o);
743	743	uint len = items.length;
744	744	if (len != element.items.length) return false;
745	745	for (uint i=0; i<len; ++i)
746	746	{
747	747	if (!items[i].opEquals(element.items[i])) return false;
748	748	}
749	749	return true;
750	750	}
…	…
998	998	*
999	999	* You should rarely need to call this function. It exists so that Tags
1000	1000	* can be used as associative array keys.
1001	1001	*
1002	1002	* Examples:
1003	1003	* --------------
1004	1004	* Tag tag1,tag2
1005	1005	* if (tag1 == tag2) { }
1006	1006	* --------------
1007	1007	*/
1008		override ~~int~~ opEquals(Object o)
	1008	override bool opEquals(Object o)
1009	1009	{
1010	1010	const tag = toType!(const Tag)(o);
1011	1011	return
1012	1012	(name != tag.name) ? false : (
1013	1013	(attr != tag.attr) ? false : (
1014	1014	(type != tag.type) ? false : (
1015	1015	true )));
1016	1016	}
1017	1017
1018	1018	/**
…	…
1142	1142
1143	1143	/**
1144	1144	* Compares two comments for equality
1145	1145	*
1146	1146	* Examples:
1147	1147	* --------------
1148	1148	* Comment item1,item2;
1149	1149	* if (item1 == item2) { }
1150	1150	* --------------
1151	1151	*/
1152		override ~~int~~ opEquals(Object o)
	1152	override bool opEquals(Object o)
1153	1153	{
1154	1154	const item = toType!(const Item)(o);
1155	1155	const t = cast(Comment)item;
1156	1156	return t !is null && content == t.content;
1157	1157	}
1158	1158
1159	1159	/**
1160	1160	* Compares two comments
1161	1161	*
1162	1162	* You should rarely need to call this function. It exists so that Comments
…	…
1221	1221
1222	1222	/**
1223	1223	* Compares two CDatas for equality
1224	1224	*
1225	1225	* Examples:
1226	1226	* --------------
1227	1227	* CData item1,item2;
1228	1228	* if (item1 == item2) { }
1229	1229	* --------------
1230	1230	*/
1231		override ~~int~~ opEquals(Object o)
	1231	override bool opEquals(Object o)
1232	1232	{
1233	1233	const item = toType!(const Item)(o);
1234	1234	const t = cast(CData)item;
1235	1235	return t !is null && content == t.content;
1236	1236	}
1237	1237
1238	1238	/**
1239	1239	* Compares two CDatas
1240	1240	*
1241	1241	* You should rarely need to call this function. It exists so that CDatas
…	…
1298	1298
1299	1299	/**
1300	1300	* Compares two text sections for equality
1301	1301	*
1302	1302	* Examples:
1303	1303	* --------------
1304	1304	* Text item1,item2;
1305	1305	* if (item1 == item2) { }
1306	1306	* --------------
1307	1307	*/
1308		override ~~int~~ opEquals(Object o)
	1308	override bool opEquals(Object o)
1309	1309	{
1310	1310	const item = toType!(const Item)(o);
1311	1311	const t = cast(Text)item;
1312	1312	return t !is null && content == t.content;
1313	1313	}
1314	1314
1315	1315	/**
1316	1316	* Compares two text sections
1317	1317	*
1318	1318	* You should rarely need to call this function. It exists so that Texts
…	…
1380	1380
1381	1381	/**
1382	1382	* Compares two XML instructions for equality
1383	1383	*
1384	1384	* Examples:
1385	1385	* --------------
1386	1386	* XMLInstruction item1,item2;
1387	1387	* if (item1 == item2) { }
1388	1388	* --------------
1389	1389	*/
1390		override ~~int~~ opEquals(Object o)
	1390	override bool opEquals(Object o)
1391	1391	{
1392	1392	const item = toType!(const Item)(o);
1393	1393	const t = cast(XMLInstruction)item;
1394	1394	return t !is null && content == t.content;
1395	1395	}
1396	1396
1397	1397	/**
1398	1398	* Compares two XML instructions
1399	1399	*
1400	1400	* You should rarely need to call this function. It exists so that
…	…
1459	1459
1460	1460	/**
1461	1461	* Compares two processing instructions for equality
1462	1462	*
1463	1463	* Examples:
1464	1464	* --------------
1465	1465	* ProcessingInstruction item1,item2;
1466	1466	* if (item1 == item2) { }
1467	1467	* --------------
1468	1468	*/
1469		override ~~int~~ opEquals(Object o)
	1469	override bool opEquals(Object o)
1470	1470	{
1471	1471	const item = toType!(const Item)(o);
1472	1472	const t = cast(ProcessingInstruction)item;
1473	1473	return t !is null && content == t.content;
1474	1474	}
1475	1475
1476	1476	/**
1477	1477	* Compares two processing instructions
1478	1478	*
1479	1479	* You should rarely need to call this function. It exists so that
…	…
1508	1508
1509	1509	override const bool isEmptyXML() { return false; } /// Returns false always
1510	1510	}
1511	1511
1512	1512	/**
1513	1513	* Abstract base class for XML items
1514	1514	*/
1515	1515	abstract class Item
1516	1516	{
1517	1517	/// Compares with another Item of same type for equality
1518		abstract override ~~int~~ opEquals(Object o);
	1518	abstract override bool opEquals(Object o);
1519	1519
1520	1520	/// Compares with another Item of same type
1521	1521	abstract override int opCmp(Object o);
1522	1522
1523	1523	/// Returns the hash of this item
1524	1524	abstract override hash_t toHash();
1525	1525
1526	1526	/// Returns a string representation of this item
1527	1527	abstract override const string toString();
1528	1528

trunk/phobos/win32.mak

r756	r761
233	233	std\stdio.d std\perf.d std\openrj.d std\uni.d std\boxer.d \
234	234	std\cstream.d std\demangle.d std\cover.d std\bitarray.d \
235	235	std\signals.d std\cpuid.d std\typetuple.d std\traits.d std\bind.d \
236	236	std\metastrings.d std\hiddenfunc.d std\contracts.d std\getopt.d \
237	237	std\variant.d std\numeric.d std\bitmanip.d std\complex.d \
238	238	std\functional.d std\algorithm.d std\typecons.d std\iterator.d \
239	239	std\xml.d std\encoding.d std\bigint.d
240	240
241	241	SRC_STD_C= std\c\process.d std\c\stdlib.d std\c\time.d std\c\stdio.d \
242	242	std\c\math.d std\c\stdarg.d std\c\stddef.d std\c\fenv.d std\c\string.d \
243		std\c\locale.d stc\c\wcharh.d
	243	std\c\locale.d std\c\wcharh.d
244	244
245	245	SRC_TI= \
246	246	std\typeinfo\ti_wchar.d std\typeinfo\ti_uint.d \
247	247	std\typeinfo\ti_short.d std\typeinfo\ti_ushort.d \
248	248	std\typeinfo\ti_byte.d std\typeinfo\ti_ubyte.d \
249	249	std\typeinfo\ti_long.d std\typeinfo\ti_ulong.d \
250	250	std\typeinfo\ti_ptr.d std\typeinfo\ti_dchar.d \
251	251	std\typeinfo\ti_float.d std\typeinfo\ti_double.d \
252	252	std\typeinfo\ti_real.d std\typeinfo\ti_delegate.d \
253	253	std\typeinfo\ti_creal.d std\typeinfo\ti_ireal.d \

Navigation

Legend:

Download in other formats: