With the function you’re supposedly writing, let’s say you wanted to make sure a argument you’re accepting via the PHP call is an integer. Well you could perform and is_int() function call by yourself, but thats not the point. The point of functions is to reduce tedious/repeated code. I made a class that has a function inside it that does all the testing for you depending on what  you, as a coder, is expecting. So passing “hi” into the validator when you specify you’re looking for an integer wouldn’t pass. It would pass if you stated you were looking for a string, though.

What’s also nifty is that i wrote it to accommodate for the event of expecting multiple kinds of datatypes. Like let’s say you want either an integer or a double (a decimal), you can simple combine them when you call the validator. If the value you give the validator is an integer or a double, it’ll spit back the datatype.

Okay, how do I have it check for datatypes? Every datatype that I could look for is assigned a number in base 2 (1, 2, 4, 8, 16, 32, etc) . I assign them base 2 values in hex, simple because I felt like it.

define(“SCRAPBOOK_DATATYPE_STR”, 0×01); // STRING
define(“SCRAPBOOK_DATATYPE_ARR”, 0×02); // ARRAY
define(“SCRAPBOOK_DATATYPE_INT”, 0×04); // INTEGER
define(“SCRAPBOOK_DATATYPE_DOUBLE”, 0×08); // DOUBLE

SCRAPBOOK_DATATYPE_STR is set to 1, _ARR is 2, etc etc. You get the point. When I call the function, the first argument/parameter is the value I need to test. The second is the (possible) datatype(s) I’m expecting. What you may or may not know about bit addition is that its very easy to figure out what bits are included. For example, the value of 6 is ONLY made up of 2 and 4, which in  this are the bits that are assigned to _ARR and _INT. Using this logic, we can pass multiple datatypes we might get (for example, we want a number which might be an integer or a decimal) and the function can check to see if the datatype of the value I’m checking for matches one of the datatypes I’m looking for.

Here is an example of looking for one datatype and then two datatypes:

//first instantiate the object
$validate = new Validator();

//would return SCRAPBOOK_DATATYPE_ARR
print $validate->validateDatatype(array(), SCRAPBOOK_DATATYPE_ARR).”\n”;

//would return SCRAPBOOK_DATATYPE_INT
print $validate->validateDatatype(5, SCRAPBOOK_DATATYPE_INT|SCRAPBOOK_DATATYPE_DOUBLE).”\n”;
//would return SCRAPBOOK_DATATYPE_DOUBLE
print $validate->validateDatatype(5.3, SCRAPBOOK_DATATYPE_INT|SCRAPBOOK_DATATYPE_DOUBLE).”\n”;

As you can see, the pipe (|) is used to add multiple of these bits together. The function would return the bit of the dataype found. this way if you’re expecting two datatypes, you can validate it and then see the exact type that was actually sent in.

Now how do i actually do the tests? well in the function I have something like this:

function validateDatatype($value = NULL, $expectedtypes = SCRAPBOOK_DATATYPE_STR)
{
//are we testing if this datatype exists?  ||   now we test!
if ( ($expectedtypes & SCRAPBOOK_DATATYPE_STR) && (is_string($value)) )
return SCRAPBOOK_DATATYPE_STR;
if ( ($expectedtypes & SCRAPBOOK_DATATYPE_ARR) &&  (is_array($value)) )
return SCRAPBOOK_DATATYPE_ARR;
if ( ($expectedtypes & SCRAPBOOK_DATATYPE_INT) &&  (is_int($value)) )
return SCRAPBOOK_DATATYPE_INT;
if ( ($expectedtypes & SCRAPBOOK_DATATYPE_OBJECT) &&  (is_object($value)) )
return SCRAPBOOK_DATATYPE_OBJECT;

Essentially, i’m testing to see if we’re asking for each datatype, if we are asking for that datatype, i perform a function call to see if it actually is. If it’s not it keeps going until it returns something. if  it gets to the end of the function, that means it didn’t validate, so false is returned. The (x &  y) test basically checks to see if bit y exists within value x. So again,  for example, lets say you have a number 13. The only way to get a number 13 through this method is  with numbers 8, 4 and 1 (8+4+1 = 13). So if you did (13 & 4) it’d return true.  So on and so forth.

Ok, now that I gave you little snippets, check out the entire script so you can see how it all blends together.

Related posts:

1. PHP Powered IRC Services? So. For awhile, I’ve been thinking of doing something. I probably really won’t have the time to do it, but...

Then I realized something. For some reason when certain functions of the website posted things to the database that involved time, it was off.  When the database entries did not have hours,minutes,seconds and just the date, it’d always push the date to be the previous day. This was strange and very annoying. You would post a news entry, and it’d be displayed as if it were posted the day previous. If you posted a sports schedule, the game listing would be off a day (this could cause definite issues).

After investigating this further, it turned out that database entries with hours,minutes,seconds did display the time as 23 seconds behind. Always 23 seconds. Always. This makes sense, because on date fields that don’t have the hourly time written, it’s internally notated as midnight (00:00:00).  So, if you take 23 seconds away from midnight, it’s the previous day. What could cause this? PHP (the programming language that’s calling the data from the database) and mySQL is running off the same machine with the same clock, so it’s not like it’s desync’d.

After even further investigation, I traced down the issue. Apparently the international time committee decided to implement leap seconds in the UTC time standard. These leap seconds are implemented to compensate for the gradual slowing of the earth’s rotation due to the tidal effect. mySQL accounts for the leap seconds. PHP doesn’t. Or maybe vice versa. I don’t know. I would think if leap seconds are added, it’d be 23 seconds ahead. Perhaps I’m just thinking backwards about this.

Apparently these people don’t think of the consequences of their decisions in regards to hardware and software where time precision is required. Especially when midnight is used for the baseline in setting times. Right now I’m going to investigate the possibility of changing the mySQL timezone in favor of a “time standard” that doesn’t reflect leap seconds. Perhaps GMT-5.  instead of UTC-6. Or whatever.

Regardless, this just shows why UTC should not be used when consistency is required.

Today I decided to stay home because I was feeling really under the weather, pretty much all weekend. But I eventually went in (like at 4, which is really late, but meh) and got some work in. Then my friend, Michelle, who now works for the district too wanted to work out, so both of us went down to weight room and of course it’s locked. Can’t I just unlock it? No, of course not. I don’t even have a key to my office. And of course, there were no custodians around. I don’t even know if they would’ve let us in. So we’re gonna try again tomorrow, and probably a lot earlier. Like.. I dunno maybe 2 or 3?

So, instead. We went to the pool room and just hung out with two other kids. Then she drove me to Wawa. I had to get cigarettes for my dad. He needs to quit. Don’t you think so? So, I left wawa and she drove me home. Then like.. I was like. here at my like computer. Totally.

Anyway.

I’m the network manager for Universium IRC network. It’s pretty cool. If you have an IRC client, you should probably point it to irc.universium.net and join #Universium because all the cool people are doing it. I’ll hook y’all with a java applet one of these days. Anyway.. I’ve been working on a PHP powered bot that connects to the network. The bot sits in the staff log channel and takes those logs and saves them to a database. Like so:

This is what the database looks like from a PHPMyAdmin viewer. I then take the data and read from it, so I can review staff actions.. This way, I can check for abuse.

So anyway, I can take that data and format so I can make a webpage to display the logs for review.

Then those flags change the status of the respective entry. If I click a red flag, it highlights the respective entry. This way it stands out.. and also, a flagged entry cannot be deleted until it’s unflagged (or.. green flagged).

It makes my life easier.. also for anyone that is hired to review the logs.