7 = 4 + 2 + 1

[Nielsz]

Oja joh?
Ja!


Goed ik zit dus een beetje te denken over een rechten systeem, en denk nu aan dit systeem:
1 = Je mag niets lezen
2 = je mag reageren op een item
4 = je mag items aanmaken
8 = je bent mag reacties toevoegen uit de que
16 = je bent moderator.


Kan je dus hetvolgende doen:
recht = 7.
Je mag dus items aanmaken (4)
reageren(2)
En niets lezen (1)

Ok, hoe je wilt reageren als je niet kan lezen doet er ff niet toe.

Ik wil de rechten in de volgende structuur neerzetten:
$right["react"] = true
$right["createitem"] = false

Die nummers zijn variabel, dus ik wil er strax dingen kunnen toevoegen.
En hoe kan ik snel (in combinatie met bovenstaande punt) lezen wat voor rechten ik heb adh van mijn recht 7.

Snappen jullie het probleem?

[.oisyn]

dit zijn gewoon simpele flag bewerkingen

flag aanzetten: $waarde |= $flag
flag uitzetten: $waarde &= ~$flag
flag testen: if ($waarde & $flag) { bla bla bla }


sim-pel

[Verwijderd]

Op woensdag 19 december 2001 23:25 schreef Nielsz het volgende:
Oja joh?
Ja!
Goed ik zit dus een beetje te denken over een rechten systeem, en denk nu aan dit systeem:
1 = Je mag niets lezen
2 = je mag reageren op een item
4 = je mag items aanmaken
8 = je bent mag reacties toevoegen uit de que
16 = je bent moderator.
Snappen jullie het probleem?

Umm je gebruikt een binaire methode om de recten toe te wijzen.

(1 = 00001)
(2 = 00010)
(4 = 00100)

Als je nou functie maakt die bijvoorbeeld het woord "superuser" (32) in een array $rechten[] als een binair bitje laat zetten. Dus dan zou je het een functie als volgend aan kunnen roepen.

PHP:

<?
rechten($lid, "superuser")
?>

vervolgens kijk je in de fuctie wat de user er bij moet krijgen in dit geval dus superuser.

PHP:

<?
function rechten($user, $type){
if ($type == "superuser")
{
   $user[7] = 1;
}
return $user;
?>

Als je dit wilt doen moet je wel even de binaire code omdraaien omdat je het variabel wilt houden.

Nu moet je alleen nog even een functie maken die vervolgens de array met binaire code omzet in een normaal getal.

Dan ben je d'r volgens mij toch? Of loop ik nu dom te lullen?

[maikel]

Kun je niet gewoon AND doen met verschillende binaire waarden ?
7: 00111

AND met "00100" (voor recht 4) geeft dus: 00100.
Indien de user dus die rechten niet heeft (00011) geeft de uitkomst gewoon 0)
En zo kun je dan per recht de waarde bepalen.

recht = 00111
if ((recht AND 00100) > 0) then recht = items aanmaken
if ((recht AND 00010) > 0) then recht = reageren
if ((recht AND 00001) > 0) then recht = niets lezen

Zoiets dus.

[Verwijderd]

Op donderdag 20 december 2001 00:17 schreef maikel het volgende:
Kun je niet gewoon AND doen met verschillende binaire waarden ?

Ja dat heb ik ook ooit eens gemaakt, dat werkt het makkelijkst. Daar hoef je helemaal niet mee te rekenen.

Anders moet je iedere keer weer die domme binaire berekeningen doen, dan moet je daar weer een functie voor schrijven en dat is omslachtig.

Maar wat maikel schrijft is het duidelijkst.

[Nielsz]

Maar dat is statisch, en niet dynamisch. Wil ik een soort toevoegen, wil ik zo weinig mogelijk (niets) in de code hoeven doen

[TimMer]

Je probeert dus gewoon chmod van Unix na te bouwen met php... toch?

[Nielsz]

Op donderdag 20 december 2001 00:25 schreef TimMer het volgende:
Je probeert dus gewoon chmod van Unix na te bouwen met php... toch?

Zo zou je het ook kunnen omschrijven jah

[SilentStorm]

nou moet je natuurlijk niet moeilijk gaan doen. Het enige wat jij moet doen is:
1) je decimale waarde binair maken [edit: via een functie uiteraard]
2) voor de rechten: niet bekend met precieze php syntax (heb het maar wat java-achtig gehouden.. ) maar je kunt er vast wel wat van maken:

PHP:

<?
if(BinStringRechten.charAt(0) == 1) then
{ $lezen = true;
}
else
{ $lezen = false;
}
if(BinStringRechten.charAt(1) == 1) then
//etc
?>

Hoef je alleen maar een statement toe te voegen als je een nieuw recht hebt bedacht

[Onno]

Op donderdag 20 december 2001 01:17 schreef SilentStorm het volgende:

PHP:

<?
if(BinStringRechten.charAt(0) == 1) then
{ $lezen = true;
}
else
{ $lezen = false;
}
if(BinStringRechten.charAt(1) == 1) then
//etc
?>

Waarom zou je er eerst een bitstring van maken?

code:

if (bla & 2^0)
 ..
if (bla & 2^1)
 ..
// etc

doet toch precies hetzelfde?

[.oisyn]

(zucht )
ik zal het nog een keer uitleggen

flag aanzetten: $waarde |= $flag
flag uitzetten: $waarde &= ~$flag
flag testen: if ($waarde & $flag) { bla bla bla }


om dat dynamisch te doen kun je bijvoorbeeld een array $flags maken, waarin de verschillende rechten staan:

PHP:

<?
$flags["nietlezen"] = 1;
$flags["reageren"] = 2;
$flags["itemsaanmaken" = 4;
$flags["toevoegen"] = 8;
$flags["moderator"] = 16;
?>

en vervolgens heb je een waarde $rechten met daarin je rechten:

PHP:

<?
if ($rechten &amp;amp; $flags["nietlezen"])
    print "je mag niet lezen";
if ($rechten &amp;amp; $flags["reageren"])
    print "je mag reageren";
?>

enz.

en om rechten toe te voegen:

$rechten |= $flags["moderator"];

of om ze te verwijderen:

$rechten &= ~$flags["moderator"];


sim-pel

[Pelle]

Op donderdag 20 december 2001 01:46 schreef OiSyN het volgende:
(zucht )
ik zal het nog een keer uitleggen

flag aanzetten: $waarde |= $flag
flag uitzetten: $waarde &= ~$flag
flag testen: if ($waarde & $flag) { bla bla bla }

* Pelle vraagt zich af of dat in PHP gaat werken

Testje gedaan, idd:

Fatal error: Unsupported operand types in \websites\trash\flag.php on line 14

Wat doen die operands precies? Ik kende ze nog niet...

[Orphix]

probeer eens door te casten:
dus $rechten = (int)$waarde & (int)$flag;

as stated in http://nl.php.net/manual/en/language.operators.bitwise.php

[drm]

Pelle:
* Pelle vraagt zich af of dat in PHP gaat werken

* drm denkt aan de XOR operator

ook handig

Flag omzetten kun je gewoon met XOR doen, want XOR is in feite "bitflip":
0001 XOR 0001 = 0000
0000 XOR 0000 = 0001
[sub][edit]
* drm door de bocht[/sub]
0000 XOR 0001 = 0001
^[/edit]



Oftewel, in navolging op OISyN:

code:

$rights = array (
   "lezen"  => 0x01,   // LSB: 0000 0001
   "schrijven"  => 0x02,   // etc...
   "aanmaken"   => 0x04,
   "veranderen" => 0x08
);

// mag hij schrijven?
if ( $userRights & $rights [ "schrijven" ] )
   ; // blabla

Doe maar dat user ook mag lezen:
if ( ! ( $userRights & $rights [ "lezen" ] ) )
   $userRights ^= $rights [ "lezen" ];

Het nadeel van deze oplossing tegenover die van OISyN is dat je eerst moet checken het bit al geset is. Maar toch handig zo hier en daar.

[dusty]

Op donderdag 20 december 2001 09:03 schreef drm het volgende:
[..]
0001 XOR 0001 = 0000
0000 XOR 0000 = 0001
[..]

uhm.. de laatste keer dat ik 0000 XOR 0000 berekende kwam er nog steeds 0000 uit.. tenzij jij XOR hergedefinieerd hebt

[drm]

dusty:
uhm.. de laatste keer dat ik 0000 XOR 0000 berekende kwam er nog steeds 0000 uit.. tenzij jij XOR hergedefinieerd hebt

moge...

* drm had XOR niet hergedefinieerd, maar moest zijn bak koffie even initialiseren...

[maikel]

Bij mijn oplossing hoef je ook bijna niet toe te voegen aan de code.
Maar 1 regel (zoals ook bij de andere oplossingen).
Je zou eventueel die rechte/waarden in een DB opkunnen slaan. Dan hoef je alleen aan de DB een record toe te voegen met het nieuwe recht en de waarde daarvan.
Dit toevoegen zou eventueel nog via een rechten-toevoeg-functie kunnen.

[drm]

maikel:
Bij mijn oplossing hoef je ook bijna niet toe te voegen aan de code.
Maar 1 regel (zoals ook bij de andere oplossingen).
Je zou eventueel die rechte/waarden in een DB opkunnen slaan. Dan hoef je alleen aan de DB een record toe te voegen met het nieuwe recht en de waarde daarvan.
Dit toevoegen zou eventueel nog via een rechten-toevoeg-functie kunnen.

Code zal je toch wel toe moeten voegen, want als je nooit checkt op bepaalde rechten, wat heeft het dan voor zin als iemand die rechten heeft?

* drm gebruikt overigens liever constanten (defines) voor rechten:

code:

define ( "READ",     0x1 );
define ( "WRITE",    0x2 );
define ( "EXECUTE",  0x4 );

if ( $rights & EXECUTE )
   ;

vind ik persoonlijk lekkerder lezen, maar dat is only mho

[dusty]

Op donderdag 20 december 2001 09:18 schreef drm het volgende:
* drm gebruikt overigens liever constanten (defines) voor rechten:

Ik gooi normaal de verschillende rechten in mijn database en dan met een definitie tabelletje koppel ik alles aan elkaar.. en dan kan ik alle rechten zetten in een bepaalde tabel.. (zoeken in de search en je zou de gehele idee moeten kunnen vinden..)

[Verwijderd]

Wat een gemier over simpele binaire tests

shr eax,[flagnr]
jnc blaat
call myFunc

:blaat
ret


Oh, dit zal wel offtopic zijn, maar met dat php en java gedoe met allemaal exotische operators vond ik dit niet misstaan

[Nielsz]

Op donderdag 20 december 2001 09:20 schreef dusty het volgende:

[..]

Ik gooi normaal de verschillende rechten in mijn database en dan met een definitie tabelletje koppel ik alles aan elkaar.. en dan kan ik alle rechten zetten in een bepaalde tabel.. (zoeken in de search en je zou de gehele idee moeten kunnen vinden..)

Dusty bedoelt:

codes:
====
codeid
codenaam
1 - read
2 - reply
3 - post
4 - mod

rechten:
====
userid
codeid
1 - 1
1 - 2
1 - 3
1 - 4

Deze kan je dan inlezen, en zo blijkt dat je alles mag.
Correct, Dusty?

[Goodielover]

Op donderdag 20 december 2001 00:24 schreef Nielsz het volgende:
Maar dat is statisch, en niet dynamisch. Wil ik een soort toevoegen, wil ik zo weinig mogelijk (niets) in de code hoeven doen

Een paar opmerkingen:
1. Al je rechten zijn dat je iets wel mag doen, behalve 1, daar mag je iets niet. Waarom maak je van 1 niet: Je mag lezen.
2. Het oplossen van de rights door een binaire codering voegt niets toe aan je behoefte aan flexibiliteit. Je kan net zo goed normale kenmerken van een user gebruiken.
3. Je rights zijn oplopend in mogelijkheden. Ik kan me tenminste niet voorstellen dat je wel mag posten, maar niet mag reageren. Functioneel gezien is de onderlinge onafhankelijkheid van de bitjes dus niet waar.

[farlane]

Op donderdag 20 december 2001 09:22 schreef wouterd het volgende:
Oh, dit zal wel offtopic zijn, maar met dat php en java gedoe met allemaal exotische operators vond ik dit niet misstaan

Ze zijn overigens geleend van C zo te zien. Zo exotisch is dat toch niet?

[Verwijderd]

Op donderdag 20 december 2001 09:29 schreef farlane het volgende:

[..]

Ze zijn overigens geleend van C zo te zien. Zo exotisch is dat toch niet?

Check Ik snap alleen niet waar de discussie over gaat, anders dan het feit dat er inderdaad afhankelijkheden bestaan tussen de verschillende 'flags', wat een dergelijke representatie niet 100% correct maakt

Maar dat zijn we gewend van software

[dusty]

Op donderdag 20 december 2001 09:27 schreef Nielsz het volgende:
[..]
Deze kan je dan inlezen, en zo blijkt dat je alles mag.
Correct, Dusty?

Zo ongeveer maar je zet dan nog in de verschillende tabellen (zoals forum tabel) een extra kolom toe die aangeeeft welke ID precies LEZEN, POSTEN e.d. is..

Waardoor je dynamisch je account editor kan gaan samenstellen.

[Nielsz]

Op donderdag 20 december 2001 09:27 schreef Goodielover het volgende:

[..]

3. Je rights zijn oplopend in mogelijkheden. Ik kan me tenminste niet voorstellen dat je wel mag posten, maar niet mag reageren. Functioneel gezien is de onderlinge onafhankelijkheid van de bitjes dus niet waar.

De redenatie dat het niet nodig is, betekent niet dat het niet ingebouwd mag worden
Want ik wil gewoon alles in kunnen stellen, en niet vast komen te zitten, omdat het systeem het niet aankan.
Stel je voor dat ik een pollmod aan maak, dan wil ik die gewoon onderaan die rij kunnen zetten (met 32 ofzo), en dan 1 gebruiker alleen die rechten geven. Op jou manier zou hij meteen moderator zijn, en dat willen we niet

[Nielsz]

Op donderdag 20 december 2001 09:33 schreef dusty het volgende:

[..]

Zo ongeveer maar je zet dan nog in de verschillende tabellen (zoals forum tabel) een extra kolom toe die aangeeeft welke ID precies LEZEN, POSTEN e.d. is..

Waardoor je dynamisch je account editor kan gaan samenstellen.

Dat staat er toch? Table codes?

[Verwijderd]

Op donderdag 20 december 2001 09:18 schreef drm het volgende:

[..]

Code zal je toch wel toe moeten voegen, want als je nooit checkt op bepaalde rechten, wat heeft het dan voor zin als iemand die rechten heeft?

* drm gebruikt overigens liever constanten (defines) voor rechten:

code:

define ( "READ",     0x1 );
define ( "WRITE",    0x2 );
define ( "EXECUTE",  0x4 );

if ( $rights & EXECUTE )
   ;

vind ik persoonlijk lekkerder lezen, maar dat is only mho

'k Heb helemaal geen verstand van PHP/C++ (klein beetje C) maar in Delphi zou ik het als volgt oplossen:

code:

type
  TRecht = (trNietLezen, trReageren, trAanmaken, trReactiesToevoegen, trModerator);
  TRechten = set of TRecht;

const
  sRechten: Array[TRecht] of String = ('Niet lezen', 'Reageren', 'Aanmaken',
'Reacties toevoegen', 'Moderator');

var
  Rechten: TRechten;
  I: Integer;
begin
  Rechten:=[trNietLezen, trReageren, trAanmaken];
  for I:=Ord(Low(TRecht)) to Ord(High(TRecht)) do
    if TRecht(I) in Rechten then
    WriteLn(sRechten[TRecht(I)]);
  Readln;
end.

Deze app drukt de rechten af die beschikbaar zijn. Misschien zitten enumerators en set of enumerators ook wel in C/PHP/C++? Persoonlijk vindt ik het namelijk veel beter leesbaar. Maar dat is natuurlijk mijn mening.

[drm]

hvdberg:
'k Heb helemaal geen verstand van PHP/C++ (klein beetje C) maar in Delphi zou ik het als volgt oplossen:

code:

meuk

Deze app drukt de rechten af die beschikbaar zijn. Misschien zitten enumerators en set of enumerators ook wel in C/PHP/C++? Persoonlijk vindt ik het namelijk veel beter leesbaar. Maar dat is natuurlijk mijn mening.

Tja, dat is maar net welke taal je het "beste leesbaar" vindt

Een dergelijke constructie is in alle talen wel te bedenken

[Verwijderd]

Delphi rulezzz natuurlijk. Kan echter niet in C(++). Daar doe je het met bitmasks.

[Creepy]

Op donderdag 20 december 2001 09:45 schreef hvdberg het volgende:

[..]

'k Heb helemaal geen verstand van PHP/C++ (klein beetje C) maar in Delphi zou ik het als volgt oplossen:

code:

type
  TRecht = (trNietLezen, trReageren, trAanmaken, trReactiesToevoegen, trModerator);
  TRechten = set of TRecht;

const
  sRechten: Array[TRecht] of String = ('Niet lezen', 'Reageren', 'Aanmaken',
'Reacties toevoegen', 'Moderator');

var
  Rechten: TRechten;
  I: Integer;
begin
  Rechten:=[trNietLezen, trReageren, trAanmaken];
  for I:=Ord(Low(TRecht)) to Ord(High(TRecht)) do
    if TRecht(I) in Rechten then
    WriteLn(sRechten[TRecht(I)]);
  Readln;
end.

Deze app drukt de rechten af die beschikbaar zijn. Misschien zitten enumerators en set of enumerators ook wel in C/PHP/C++? Persoonlijk vindt ik het namelijk veel beter leesbaar. Maar dat is natuurlijk mijn mening.

Sets? Hmm.. in Delphi zou ik ook gewoon gebruik maken van constanten en een bitmask.

code:

const b_lezen=1;
    b_bewerken=2;
    b_blaat=4;

var rechten: byte;

begin
     if (rechten and b_lezen = b_lezen) then
      writeln('lezen');
     if (rechten and b_bewerken = b_bewerken) then
      writeln('bewerken');   
end;

[Verwijderd]

Op donderdag 20 december 2001 10:01 schreef Doekman het volgende:
Delphi rulezzz natuurlijk. Kan echter niet in C(++). Daar doe je het met bitmasks.

Amen, maar zelfs VB kent enumerators (Set of enumerator is me nog niet gelukt). Ik meen ergens gelezen te hebben dat C ook een enumerator kon doen.

Bitjes kan natuurlijk ook, maar misschien in combi met een enumerator vanwege de leesbaarheid zou wel aardig zijn.

PS: Hou draai jij Delphi op de NEC V20? (En welke versie!?)

[drm]

hvdberg: Ik meen ergens gelezen te hebben dat C ook een enumerator kon doen.

Bitjes kan natuurlijk ook, maar misschien in combi met een enumerator vanwege de leesbaarheid zou wel aardig zijn.

klopt. kan ook in C. Maar dat werkt net ff anders. Er is vast wel een C(++)-er in de buurt die het je ff uiteen wil zetten.

[kvdveer]

Toen ik die titel las dacht ik even dat het een spoiler was voor GPC opgave 3... ;-)

Sets zijn in delphi best mooie dingen, het geeft je de mogelijkheid om eenvoudig aanpasbare code te maken, bovendien kun je met een combinatie van een enum en een set en wat arrays heel snel een selectiestatement maken in een paar regels (declaratie van constanten niet meegerekend).
Maar, heb je wel eens gekeken naar de performance van zo'n set?
De opdracht 'if tb_setitem in bset then ...' is een O(n)
Een loopje 'for t:=tb_eersteitem to tb_laatsteitem do array[t]:=waarde;' is zelfs O(n log n).
Toevoegen van x items aan een set met n mogelijkheden is
'x := set1 + set2;' O(n^2);

En dat terwijl je als je met bitmasks werkt hele snelle code kunt maken.
(zoeken in een set is O(1), loopje is O(n), toevoegen O(n)).

Een nadeel van zo'n bitmask is dat je enum beperkt is tot 32 items, of 64 items als je in een 64 bits integer werkt.

[Verwijderd]

?!?!?! ik doe het zo (op bepaalde sites)

A=admin
M=mod
D=disabled

(voeg hier nog maar een reets toe)

en dan gewoon filteren

if (eregi([a],$var)) { echo "Admin"; )


enz....

[Verwijderd]

Op donderdag 20 december 2001 10:10 schreef hvdberg het volgende:

Amen, maar zelfs VB kent enumerators (Set of enumerator is me nog niet gelukt). Ik meen ergens gelezen te hebben dat C ook een enumerator kon doen.

Inderdaad, ook C, C++, C#, Java etc. kennen enums, maar allen kennen geen SET's.

PS: Hou draai jij Delphi op de NEC V20? (En welke versie!?)

Op m'n nec v20 systeem deed ik voornamelijk TP4.0 en ik heb ook met TP5.5 gewerkt
En Turbo Pascal for Windows moest ik niets van hebben, want we vonden Windows toen een slecht programma

Op donderdag 20 december 2001 12:26 schreef kvdveer het volgende:
[...]Maar, heb je wel eens gekeken naar de performance van zo'n set?

Dat ligt natuurlijk aan de compiler. Als ik compiler was, zou ik gewoon bitmasks gebruiken. En als je dan meer dan 32/64 elementen in je enum hebt, kun je gemakkelijk een arraytje aanleggen.

Als je hier in C++ en klasse voor maakt, heb je het probleem van de bovengrens van 32 ook niet

[Verwijderd]

Op donderdag 20 december 2001 12:31 schreef dynom het iets met eregi

Dat kan ook wel met strpos, scheelt weer cpu

[Verwijderd]

jah kan.. mar dan word het lastiger als je zoiets doet:

PHP:

<?
if (eregi("[atm]",$var) { echo "you are admin technician and moderator"; )
?>

atm hoeft nl niet in die volgorde te blijven nl

[mbravenboer]

Doekman: Inderdaad, ook C, C++, C#, Java etc. kennen enums, maar allen kennen geen SET's.

Java kent juist geen enums. In de standaard library wordt dit vaak opgelost door constante integers, wat uitermate ranzig werkt. Gelukkig kan je heel fraai type-safe enumeraties maken met OO. In de nieuwe libs wordt dit gelukkig ook steeds vaker gedaan.

Ook bitmasks worden ranzig veel gebruikt in Java . Zelfs voor het instellen van de status van een Frame in 1.4.0 moet je een ranzige bitmask gebruiken .

[drm]

mbravenboer:
Ook bitmasks worden ranzig veel gebruikt in Java . Zelfs voor het instellen van de status van een Frame in 1.4.0 moet je een ranzige bitmask gebruiken .

Waarom vind je een bitmask zo ranzig, dan

dynom:
jah kan.. mar dan word het lastiger als je zoiets doet:

PHP:

<?
if (eregi("[atm]",$var) { echo "you are admin technician and moderator"; )
?>

atm hoeft nl niet in die volgorde te blijven nl

*kuch*

[Verwijderd]

Op donderdag 20 december 2001 12:26 schreef kvdveer het volgende:

Sets zijn in delphi best mooie dingen, het geeft je de mogelijkheid om eenvoudig aanpasbare code te maken, bovendien kun je met een combinatie van een enum en een set en wat arrays heel snel een selectiestatement maken in een paar regels (declaratie van constanten niet meegerekend).
Maar, heb je wel eens gekeken naar de performance van zo'n set?

Ja, ik heb inderdaad naar de perfomance gekeken en die is gelijk aan bitmasks. De compiler (delphi) zal dit optimaliseren. Voor de zekerheid ga ik nog even middels de CPU-view in Delphi debuggen om te kijken hoeveel het scheelt.

De opdracht 'if tb_setitem in bset then ...' is een O(n)
Een loopje 'for t:=tb_eersteitem to tb_laatsteitem do array[t]:=waarde;' is zelfs O(n log n).

Dit zal gewoon lopen van 0 tot n-1 waarbij n het aantal elementen uit een Enum is. Voordeel van Low() to High() tellen is dat bij uitbreiding je for-loop nog gewoon werkt. Als je bijv. gaat tellen vanaf de laagste constante naar de hoogste en je voegt een hogere constante toe, zul je al je for-lusjes langs moeten en aanpassen.

Toevoegen van x items aan een set met n mogelijkheden is
'x := set1 + set2;' O(n^2);

Daar hebben we nou de volgende procedure voor:

code:

Include(var S: set of T; I:T);

En dat terwijl je als je met bitmasks werkt hele snelle code kunt maken.
(zoeken in een set is O(1), loopje is O(n), toevoegen O(n)).

Idd. waarschijnlijk sneller.

Een nadeel van zo'n bitmask is dat je enum beperkt is tot 32 items, of 64 items als je in een 64 bits integer werkt.

En waarschijnlijk stap je dan over op een array[0..n-1] of boolean en doe je hetzelfde als een enumset. En op zo'n moment ben ik blij dat de Delphi-compiler hier al in voorziet!

PS: ik gebruik zelf ook heel vaak constanten omdat je dan heel eenvoudig met shl, shr, or en xor leuke dingen kan bewerkstelligen.

SET's zijn mijns inziens leesbaarder en supersimpel uit te breiden.

[Creepy]

Bitmaps ranzig? Tja... Het is natuurlijk maar net wat je ranzig vind. Bitmaps hebben wel het laagste geheugen verbruik t.o.v. enum's en set's o.i.d.

Ok.. nou is dat tegenwoordig bijna geen issue meer.. maar toch.

[drm]

Op donderdag 20 december 2001 14:26 schreef Creepy het volgende:
Bitmaps ranzig? Tja... Het is natuurlijk maar net wat je ranzig vind. Bitmaps hebben wel het laagste geheugen verbruik t.o.v. enum's en set's o.i.d.

Ok.. nou is dat tegenwoordig bijna geen issue meer.. maar toch.

Vraag ik me af, hoor. Ik denk dat dat redelijk uitgeoptimaliseerd wordt, in de meeste compilers.

[Verwijderd]

Op donderdag 20 december 2001 14:35 schreef drm het volgende:

[..]

Vraag ik me af, hoor. Ik denk dat dat redelijk uitgeoptimaliseerd wordt, in de meeste compilers.

Ik heb het zo juist even bekeken en het maakt als je op assembler niveau gaat kijken zowaar geen moer uit!

Ter illustratie de volgende twee stukjes code met de assembler equilivant (gehaald uit Delphi 5 compiler) ervan.

code:

program Project1;
{$APPTYPE CONSOLE}
uses SysUtils;

type
  TEnum = (te1, te2, te3, te4, te5, te6);
  TSetOfEnum = set of TEnum;

var
  SON: TSetOfEnum;
  I: Integer;
begin
  SON:=[te1, te3, te5, te6];
  for I:=Ord(Low(TEnum)) to Ord(High(TEnum)) do
    if TEnum(I) in SON then
    WriteLn(inttostr(I));
  ReadLn;
end.
// Wordt in assembler:
// Delphi: begin
push ebp
mov ebp, esp
add esp,-$10
push ebx
push esi
xor eax,eax
mov [ebp-$10],eax
mov eax,[$00409394]
mov byte ptr [eax],$01
mov eax,$004086bc
call @InitExe
xor eax,eax
push ebp
push $00408782
push dword ptr fs:[eax]
mov fs:[eax],esp
// Delphi: SON:=[te1, te3, te5, te6];
mov bl, [project1 + $A0]
// Delphi: for I:=Ord(Low(TEnum)) to Ord(High(TEnum)) do
xor esi,esi
// Delphi: if TEnum(I) in SON then
mov eax,esi
cmp al,$07
jnbe Project1 + $41
and eax,$7f
bt ebx,eax
jnb Project1 + $64
// Delphi: WriteLn(inttostr(I));
lea edx,[ebp-$10]
mov eax,esi
call IntToStr
mov edx,[ebp-$10]
mov eax,[$004092ec]
call @WriteOLString
call @WriteLn
call @ IOTest
inc esi
// Delphi: for I:=Ord(Low(TEnum)) to Ord(High(TEnum)) do
cmp esi,$06
jnz Project1 + $35
// En zo gaan we nog even door!

Dan volgt nu de app met Constanten:

code:

program Project1;
{$APPTYPE CONSOLE}
uses SysUtils;

const
  te1=$01;
  te2=$02;
  te3=$04;
  te4=$08;
  te5=$10;
  te6=$20;

var
  Cons: Integer;
  I: Integer;
begin
  Cons:=te1+te3+te5+te6;
  for I:=0 to 5 do
    if (cons and (1 shl I))>0 then
    WriteLn(inttostr(I+1));
  ReadLn;
end.
// En dit wordt in assembler
// Delphi: begin
push ebp
mov ebp, esp
add esp,-$10
push ebx
push esi
xor eax,eax
mov [ebp-$10],eax
mov eax,[$00409394]
mov byte ptr [eax],$01
mov eax,$004086bc
call @InitExe
xor eax,eax
push ebp
push $00408782
push dword ptr fs:[eax]
mov fs:[eax],esp
// Delphi: Cons:=te1+te3+te5+te6;
mov esi,$00000035
// Delphi: for I:=0 to 5 do
xor ebx,ebx
// Delphi: if (cons and (1 shl I))>0 then
mov ecx,ebx
mov eax,$00000001
shl eax,cl
test eax,esi
jle Project1 + $63
// Delphi: WriteLn(inttostr(I+1));
lea edx,[ebp-$10]
lea eax,[ebx+$01]
call IntToStr
mov edx,[ebp-$10]
mov eax,[$004092ec]
call @WriteOLString
call @WriteLn
call @ IOTest
inc ebx
// Delphi: for I:=0 to 5 do
cmp ebx,$06
jnz Project1 + $34
// And so on...

Zoals je kunt zien zit er wel verschil in maar zal dit qua snelheid echt geen merkbaar verschil opleveren.

[moe-modus]Dat was een pokke eind typen zeg...[/moe-modus]

[.oisyn]

duh, gebruik van sets resulteert in vrijwel dezelfde code als zelf met bitmasks gaan werken... ik zou ook niet weten hoe de compiler het anders zou moeten doen

als je met een enum zou werken en je hebt ergens iets als (even in C)

code:

enum bla_t
{
    BLA_BLA,
    BLA_BLEEH,
    BLA_FRITUUR,
    BLA_KROKET
};

bla_t bla;

if (bla == BLA_FRITUUR)
   zetTemperatuurHoger ();

ofzoiets
Dan wordt die if gewoon vertaald naar

code:

if ((int)bla == 3)

het enige verschil is dat de ene methode leesbaar is en de andere wat minder
De declaratie van de enum zelf genereert totaal geen code, het is er alleen voor de compiler om verschillende waardes uit elkaar te houden... van al die BLA_* symbolen is na het compilen ook totaal niets terug te vinden

[Verwijderd]

Op donderdag 20 december 2001 12:46 schreef mbravenboer het volgende:

[..]

Java kent juist geen enums.

Genadeloos afgestraft. Ik ging er even vanuit dat dit logisch was. Weer wat geleerd.

Ken jij de reden, waarom java geen enums heeft? Ik vind het wel een handige optie.

Enums worden ook wel raar geimplementeerd. Aan de ene kant is het een ongeordende verzameling, aan de andere kant kun je ze vaak een integer-waarde geven, maar je hebt geen (taal) operator om de eerste en de laatste aan te wijzen (pascal en mutaties positief uitgezonderd).

Ook bitmasks worden ranzig veel gebruikt in Java . Zelfs voor het instellen van de status van een Frame in 1.4.0 moet je een ranzige bitmask gebruiken .

Ik vind bitmasks ook meer iets voor C en assembler. Ik verwacht van talen als java, vb en/of javascript dat ze hier andere manieren voor aanbieden. Die set-implementatie van Pascal vind ik echt wel handig.

Nog een laatste mijmering over enums: Laatst baalde ik er enorm van dat ik een COM-enums (eigenlijk gewoon int constanten) niet in SQL kon gebruiken. Ik heb het maar opgelost door de enum ook in een tabel te zetten. En omdat we als programmeur tegenwoordig in een tekst-wereld leven (xml, http etc.) had ik ook bedacht dat een enum naar een string geconverteerd moet worden en weer terug. Simpel: gewoon twee functie's, en in de database een veldje in de enumeratie-tabel.

Nu maar hopen dat je T-SQL gewoon .NET enums kunt gebruiken (of zijn er geen enums meer).

[mbravenboer]

Doekman: Genadeloos afgestraft. Ik ging er even vanuit dat dit logisch was. Weer wat geleerd.

Hehe . Sorry.

Ken jij de reden, waarom java geen enums heeft? Ik vind het wel een handige optie.

Ik vermoed 'overbodigheid' das een neiging die ze meer hadden bij het ontwerp van Java ( voor anderen ).

In de standaard Java API's hebben ze er toen helaas maar voor gekozen om met constant String of ints te gaan werken. Dat levert dus een uitermate ranzig resultaat op.

Ik is wel een RFE (Request For Enhancement) die behoorlijk wat stemmen heeft.

http://developer.java.sun.com/developer/bugParade/bugs/4401321.html

Het commentaar van Sun bij de bug zegt zegt genoeg

Enums are just one more form of syntactic sugar that contribute no expressive power to the language. However, creaping featurism is the way of the world, and very few people really appreciate the maxim that "less is more". Many
programmers think that "more is more" (ok, so it is intuitive).
Those who want to throw everything including the kitchen sink into Java can vote for this RFE.

Hij zal in ieder geval nooit toegevoegd worden omdat je het uitermate fraai, type-safe en efficient kan oplossen:

code:

public class Orientation
{
    public static final Orientation HORIZONTAL = new Orientation();
    public static final Orientation VERTICAL   = new Orientation();
    
    protected Orientation()
    {
        super();
    }
}

Als je hem ook nog als verzameling of combinatie wilt gebruiken zorgen geparameterizeerde typen ervoor dat het nog mooi blijft ook .

Ik vind bitmasks ook meer iets voor C en assembler. Ik verwacht van talen als java, vb en/of javascript dat ze hier andere manieren voor aanbieden.

Precies stompzinnig genoeg gebruiken ze in 1.4.0 zelfs voor het maximaliseren van een Frame bitmasks. Het is werkelijk een hele rare oplossing, zeker als je het vergelijkt met de methode in een JInternalFrame. Ik heb een bug report ingestuurd maar die is gesloten omdat de API al fixed is . Das een lekkere reden.

Zie hier voor de ranzigheid van bitmasks als je een duidelijke taal als Java gewend bent:

http://developer.java.sun.com/developer/bugParade/bugs/4485360.html

[.oisyn]

hmm hoewel dat een mooie oplossing is is het wel ongelooflijk memory-consuming. Voor elke enum-waarde wordt er een object gealloceerd. Nou zou dit op zich niet zo veel zijn, maar als je een programma/lib hebt met superveel enumeraties dan loopt dit aardig op... om nog maar te zwijgen van de overhead tijdens het starten (al die enums uit de runtime die je helemaal niet gebruikt worden tenslotte ook geinstantieerd)

Maar dat zal wel de optimalisatie-freak in mij zijn die er zo over denkt

[mbravenboer]

OiSyN: hmm hoewel dat een mooie oplossing is is het wel ongelooflijk memory-consuming.

Vergeleken met pure integers inderdaad wel ja....

Maar ik denk dat deze oplossing toch vaak voldoet: het gaat meestal maar om enkele waarden en de objecten worden maar 1x aangemaakt. In sommige gevallen zou je dit zelfs nog wel lazy kunnen doen als je echt gek wilt doen. Vergelijken kan erg snel gedaan worden met == .

Maar dat zal wel de optimalisatie-freak in mij zijn die er zo over denkt

Ach als je ziet hoe de gemiddelde Java programmeur met objecten-gooit . Ik denk dat in heel veel gevallen dit een prima en duidelijke oplossing kan zijn setOrientation(int) is tenslotte een stuk onderduidelijker dan setOrientation(Orientation). Bovendien moet je in het eerste geval ook nog foute invoer gaan opvongen .

Zeker als je ziet dan soms in de Java libs zelfs Strings gebruikt worden ( BorderLayout.NORTH, SOUTH etc bijvoorbeeld ) is dit helemaal een veel betere oplossing .

[Verwijderd]

Op vrijdag 21 december 2001 00:22 schreef mbravenboer het volgende:

Ik vermoed 'overbodigheid' das een neiging die ze meer hadden bij het ontwerp van Java ( voor anderen ).

Maar wat is er tegen de enum/set constructie van Pascal/modula-2 etc. Heb je die bitmasks ook niet nodig

(maar veel programmeurs hebben veel moeite gedaan om dat bitmask goed te leren, dus dan zullen ze het gebruiken ook)

[drm]

mbravenboer vond bitmaps ranzig

Nou, imo is het gewoon een kwestie van goed documenteren en goed lezen. Ik vind er echt helemaal niets ranzigs aan...
ik vind het zelfs wel een beetje mooi

Een computer hangt aan elkaar van bits, waarom zou je daar dan niet een beetje mee freubelen?

_edit
maar, je moet er wel consequent in zijn.
Met strings is natuurlijk te debiel voor woorden, en in Java heb je nou eenmaal het voordeel van goede OO, dus dan kan je er net zo goed ook gebruik van maken.

Maar in PHP is bitmasken imo toch het beste

[roelio]

inderdaad, bitmasken is gewoon mooi!! maar goed, in Java is het eigenlijk een beetje back to assembly & C etc.

[Verwijderd]

Op vrijdag 21 december 2001 11:01 schreef limoentje het volgende:
inderdaad, bitmasken is gewoon mooi!! maar goed, in Java is het eigenlijk een beetje back to assembly & C etc.

Eigenlijk zou het dus handig zijn als je beide methodes (bitmasks/enum sets) kon toepassen. Hiermee doel ik op 2 zaken:
1) Beetje programmeur zou het beide moeten kunnen lezen/schrijven.
2) Beetje programmeertaal zou het beide moeten kunnen ondersteunen.

Bij gebruik van enum sets zal immers toch de compiler de zaak optimaliseren en vanuit een RAD oogpunt, gebruik makend van Code Completion etc, is enums en enum sets toch wel heel erg makkelijk.

[drm]

hvdberg:
Eigenlijk zou het dus handig zijn als je beide methodes (bitmasks/enum sets) kon toepassen. Hiermee doel ik op 2 zaken:
1) Beetje programmeur zou het beide moeten kunnen lezen/schrijven.
2) Beetje programmeertaal zou het beide moeten kunnen ondersteunen.

mbravenboer:
Java kent geen enums

*oeioeioei*

Bij gebruik van enum sets zal immers toch de compiler de zaak optimaliseren en vanuit een RAD oogpunt, gebruik makend van Code Completion etc, is enums en enum sets toch wel heel erg makkelijk.

Dat denk ik ook jah.

[Verwijderd]

code:

a = a + 2

is irritant en ranzig, dus gebruik je

code:

a+=2

code:

if(a and x == x)

is irritant, dus ik wil

code:

if(x in a)

[Verwijderd]

Op vrijdag 21 december 2001 12:15 schreef Doekman het volgende:

code:

a = a + 2

is irritant en ranzig, dus gebruik je

code:

a+=2

En die wil ik nu ook in Delphi! Maar dan wil ik ook meteen:

code:

for(int i=0;i<j;i++)

code:

if(a and x == x)

is irritant, dus ik wil

code:

if(x in a)

En gelukkig hebben we die in Delphi (werkt op arrays en sets). Let wel: in het geval van array werkt het alleen in het volgende voorbeeld:

code:

  if (Key in ['0'..'9', 'A'..'Z']) then
    ... bla bla

[/code]
Iets als

code:

  A[0]:='A';
  A[1]:='B';
  A[2]:='C';
  if ('A' in A) then
    ... bla

werkt niet!

[mbravenboer]

limoentje: inderdaad, bitmasken is gewoon mooi!! maar goed, in Java is het eigenlijk een beetje back to assembly & C etc.

Ze hebben inderdaad iets fraais, maar juist om je laatste zin vind ik ze misplaatst als constructie in Java als de goede performance van bitmasks niet relevant is.

[drm]

mbravenboer:
Ze hebben inderdaad iets fraais, maar juist om je laatste zin vind ik ze misplaatst als constructie in Java als de goede performance van bitmasks niet relevant is.

Ben ik het wel mee eens.

[roelio]

Op vrijdag 21 december 2001 15:17 schreef mbravenboer het volgende:
Ze hebben inderdaad iets fraais, maar juist om je laatste zin vind ik ze misplaatst als constructie in Java als de goede performance van bitmasks niet relevant is.

couldn't agree more

hoewel er natuurlijk ook iets te zeggen valt voor zo breed mogelijke ondersteuning in een taal (dus enums EN bitmasks )

[roelio]

Op vrijdag 21 december 2001 12:15 schreef Doekman het volgende:
a = a + 2
is irritant en ranzig, dus gebruik je
a += 2

valt toch wel mee? ik vind a = a + 2 juist heel duidelijk, net als a += 2, eigenlijk vind ik beide wel mooi

[Verwijderd]

Op vrijdag 21 december 2001 13:20 schreef hvdberg het volgende:
En gelukkig hebben we die in Delphi (werkt op arrays en sets). Let wel: in het geval van array werkt het alleen in het volgende voorbeeld:

code:

  if (Key in ['0'..'9', 'A'..'Z']) then
    ... bla bla

[/code]

Let wel. is geen array maar een set (in het Nederlands: een verzameling.

En ja, daarom is Object Pascal (Delphi) best fijn!

Op zaterdag 22 december 2001 11:15 schreef limoentje het volgende:
valt toch wel mee? ik vind a = a + 2 juist heel duidelijk, net als a += 2, eigenlijk vind ik beide wel mooi

a = a + 2 leest voor mij: a krijgt een nieuwe waarde, het wordt de waarde van a plus 2.

Bij a += 2 geef je de compiler ook nog eens de hint dat er iets bij opgeteld moet worden. Want bij a = a + 1 moet minder gebeuren dan bij a = b + 1

[.oisyn]

Op zondag 23 december 2001 23:57 schreef Doekman het volgende:
Bij a += 2 geef je de compiler ook nog eens de hint dat er iets bij opgeteld moet worden. Want bij a = a + 1 moet minder gebeuren dan bij a = b + 1

ligt er maar net aan op wat voor processor je werkt... bij een RISC processor maakt het dus niets uit, aangezien je altijd een waarde moet loaden, dan 1 erbij optellen, dan weer saven

[mbravenboer]

OiSyN: ligt er maar net aan op wat voor processor je werkt... bij een RISC processor maakt het dus niets uit, aangezien je altijd een waarde moet loaden, dan 1 erbij optellen, dan weer saven

Ik vermoed eerlijk het op een CISC ook niet uitmaakt? CISC instructie-set is veel meer gericht op het daadwerkelijk schrijven in die instructie-set. Ik vermoed dat de optellings-operatie uiteindelijk op een CISC niet minder tijd in beslag zal nemen dan een gewone optelling. Bij compilatie naar CISC code moet je ook terdege rekening houden met de kosten van operaties: minder instructies voor een berekening betekent niet direct kortere executie. Bij RISC processoren geldt dit een stuk minder dacht ik...

Als m'n idee klopt zijn ++ en += dus pure syntaxtische suiker. Overigens denk ik dat compilers dit sowieso al wel als syntaxtische suiker zullen toepassen: het is vrij triviaal om in een latere fase alle operaties zo uit te drukken als dat zinvol is: x = x + 1 kan dan in een latere fase in de compiler wordt omgezet van x += 1. Dit kan uiteraard een nog betere optimalisatie opleveren (als het als nut zou hebben...)

[Verwijderd]

Op maandag 24 december 2001 13:29 schreef mbravenboer het volgende:
Als m'n idee klopt zijn ++ en += dus pure syntaxtische suiker. Overigens denk ik dat compilers dit sowieso al wel als syntaxtische suiker zullen toepassen: het is vrij triviaal om in een latere fase alle operaties zo uit te drukken als dat zinvol is: x = x + 1 kan dan in een latere fase in de compiler wordt omgezet van x += 1. Dit kan uiteraard een nog betere optimalisatie opleveren (als het als nut zou hebben...)

+= is inderdaad syntaxtisch suiker. C# kun je de += operator niet overloaden. Als je de + operator overload, werkt += ook (assign mag niet overloaded worden).

Sommige compilers zijn echter slecht geoptimaliseerd. VB bijv. met strings. Als je s = s + "hoi" doet, wordt er een nieuwe string aangemaakt. += heeft VB niet. En als je als taal geen += hebt, moet je bij de assign operator checken of de eerste operand dezelfde is als de doel-operand...

En bovendien, ik vindt += gewoon prettiger lezen.

Da's best belangrijk. In VB is het Select statement (de c-switch variant) ook gewoon syntaxtische suiker, er wordt echt geen sprong-tabel gemaakt. Toch leest het een stuk prettiger.

[.oisyn]

Op maandag 24 december 2001 13:29 schreef mbravenboer het volgende:

[..]

Ik vermoed eerlijk het op een CISC ook niet uitmaakt? CISC instructie-set is veel meer gericht op het daadwerkelijk schrijven in die instructie-set. Ik vermoed dat de optellings-operatie uiteindelijk op een CISC niet minder tijd in beslag zal nemen dan een gewone optelling. Bij compilatie naar CISC code moet je ook terdege rekening houden met de kosten van operaties: minder instructies voor een berekening betekent niet direct kortere executie. Bij RISC processoren geldt dit een stuk minder dacht ik...

nope, bijvoorbeeld bij een x86 machine wordt het dit:

code:

mov eax, [a]
inc eax
mov [a], eax

ten eerste verneuk je hier een van de toch al weinig registers die je tot je beschikking hebt, wat er voor zorgt dat andere waarden die je evt in eax kon opslaan nu niet in eax kan opslaan, dus moeten die uit het geheugen (cache) gehaald worden.

Punt 2 is dat dit stukje code (even afgezien van geheugen/cache latency) 3 clocks is, terwijl een

code:

inc dword ptr [a]

slechts 1 clock is

Dan komen we op punt 3: de pipelines. Bij het eerste stukje code kan dit niet gepiped worden, aangezien elke instructie afhankelijk is van de uitkomst van de vorige. Nou kun je de instructies natuurlijk wel tussen een ander stukje code proppen, maar je kunt veel beter gewoon die inc dword ptr [a] ergens tussen stoppen, aangezien die volledig onafhankelijk is van andere instructies, en kan daarom ook prima gepiped worden

Dus het maakt wel degelijk wat uit, ook al is het niet veel

[mbravenboer]

Ah, bedankt voor de goede uitleg .

Ik moet nog een hoop leren over deze stuff .