1
2
3
4
5
6
7
8
9
10
11
12

function is_ssl()
{
    $secure_connection = false;
 
    if (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off'
        || $_SERVER['SERVER_PORT'] == 443) 
    {
        $secure_connection = true;
    }
 
    return $secure_connection;
}

I found this little nifty function on StackOverflow

1
2
3
4

function is_multi_array( array $arr )
{
    return is_array($arr[key($arr)]);
}

This can easily be used in the following context:

6
7
8
9
10

$a = array("dimension1" => array("dimension2" => "I like it") );
if( is_multi_array( $a ) )
{
    echo $a['dimension1']['dimension2'];
}

    <input type="hidden" name="group1" value="" />
    <input type="radio" name="group1.1" value="1" tabindex="10" /> Radio 1
    <input type="radio" name="group1.2" value="2" tabindex="11" /> Radio 2
    <input type="radio" name="group1.3" value="3" tabindex="12" /> Radio 3

Now add a little bit of code that will parse once the DOM is ready:

    <script type="text/javascript">
        $(document).ready( function() {
            rt = new RadioTabs();
            rt.init( "group1", ["group1.1", "group1.2", "group1.3"], ["click"] );
        });
    </script>

All this does is tell the RadioTabs class (coming next) which tabs will be in the group. Finally, add this somewhere on you page. Preferably on a separate page.

	/* Create Tabable Radio Boxes */
	function RadioTabs() {
		/* Declare Private Members and Methods */
		var hidden = '';
		var group = [];
		var events = [];
 
		/* void Bind Events to each individual Radio Box */
		var bindEvents = function () {
			//Loop through Events
			for( var e = 0; e < events.length; e++ ) {
				//Loop through Radio Buttons
				for( var g = 0; g < group.length; g++ ) {
					//Add a Rel value to each group box - to be used in the bind
					$('input:radio[name="' + group[g] + '"]').attr('rel', g);
					//Bind actual events to each radio box
					$('input:radio[name="' + group[g] + '"]').bind(events[e], function( event ) {
						var n = $(this).attr('rel');
						$('[name="' + hidden + '"]').val( $('[name=' + group[n] + ']').val() );
						//Step through radio group and set to false
						for( var i = 0; i < group.length; i++ ) {
							if( group[i] != group[n] ) {
								$('input:radio[name="' + group[i] + '"]:checked').attr( 'checked', false );
							}
						};
					});
				}
			}
		};
 
		/* Declare Public Members and Methods */
		return {
			/* string Set the Hidden Input Element */
			setHidden    : function ( value ) {
				hidden = value;
			},
			/* array Set the Radio Group Elements */
			setGroup    : function ( values ) {
				group = values;
			},
			/* array Set the Events to bind to */
			setEvents    : function ( values ) {
				events = values;
			},
			/* void Init the script */
			init            : function ( hid, grp, evt ) {
				this.setHidden( hid );
				this.setGroup( grp );
				this.setEvents( evt );
				bindEvents();
			}
		};
	};

All the above piece of code does is it will allow you to tab through the radio boxes, and then set the hidden elements value to that of the selected radio box. You might have to tweak a little bit with CSS in IE7 and 8 (I don’t support 6 anymore) to make it show that the box is selected. This should do the trick

    input[type=radio]:focus {
        outline:#000 dotted thin;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

    /**
     * Do a Safe Redirect
     *
     * This function will first try to do a server-side redirect, if it is not possible, if will fall back to a
     * Javascript redirect, if that fails, it will try a HTML redirect.
     * @param $url
     */
    function safe_redirect($url, $method = 'PHP')
    {
        try
        {
            if (!headers_sent())
            {
                //If headers are not sent yet... then do a php redirect
                @header('Location: '.$url);
                exit;
            } else throw new Exception();
        }
        catch( Exception $ex )
        {
            //If headers are sent... do a JavaScript redirect...
            //if javascript disabled, do html redirect.
            echo '<script type="text/javascript">';
            echo 'window.location.href="'.$url.'";';
            echo '</script>';
            echo '<noscript>';
            echo '<meta http-equiv="refresh" content="0;url='.$url.'" />';
            echo '</noscript>';
            exit;
        }
    }

Basically, this will check to see if headers were sent, if not, it will allow for a PHP header redirect, If output were set, it will make use of JavaScript, and, as a backup if JavaScript is not installed, it will cause a meta redirect.

One example where I found this useful was to get the fully qualified domain name of a server. I could do something like:

1

$fqdn = shell_exec('hostname --fqdn');

or using backticks, I can so something like:

1

$fqdn = `hostname --fqdn`;

Notice that I am using backticks (`) and not single quotes (‘)

1
2
3
4

    function is_serial($data)
    {
        return (@unserialize($data) !== false);
    }

unserialize will return FALSE if you pass a value that is not serialized, BUT, it will also throw an E_NOTICE error at the same time. To get around that, I add the suppressor (@) and then I attempt to unserialize the data.

About add_feed
This function takes two parameters: Feed Name, and Callback Function. The callback function will handle the feed template, and will have access to Loop.

Timing matters The add_feed function MUST be called after WordPress is completely initialized. In my tests. I found it to work in the init action hook.

The code

1
2
3
4
5
6
7
8
9
10

function custom_rss_feed()
{
     add_feed('custom-rss', 'custom_rss_feed_template');
}
add_action('init', 'custom_rss_feed');
 
function custom_rss_feed_template()
{
     load_template( TEMPLATEPATH . 'custom_rss_feed.php');
}

The code explained
First, we add an action to call the custom rss function during the init. Then, we define the new custom rss feed using add_feed. This feed will then give use a ‘custom-rss’ feed. The custom_rss_feed_template is called when feed=custom-rss is specified. The custom_rss_feed_template function calls your template file.

Creating the template
At this point, all you still need to do is to create the custom template. The easiest way to go about this is to copy the wordpress/wp-includes/feed-rss2.php template to your theme directory. rename it to custom_rss_feed.php and start modifying the file to your needs. All of the WordPress functions will still work, because you are still in the Loop.

Afterthought
You can then take it a step further and create rewrite rules so that you don’t need the query string feed=custom-rss but instead something like feed/custom-rss/

1
2
3
4
5
6
7
8
9
10
11

    function add()
    {  
        $total  = 0;
        $args = func_get_args();  
 
        foreach ($args as $key => $val)
        {  
            $total += $val;  
        }  
        return $total;
    }

You can then call the function with as many arguments as you want.

1

    echo add( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );

#yum clean all
#mkdir /usr/src/centos
#cd /usr/src/centos
#wget http://mirror.centos.org/centos/RPM-GPG-KEY-CentOS-5
#wget http://mirror.centos.org/centos/5/os/i386/CentOS/centos-release-5-5.el5.centos.i386.rpm
#wget http://mirror.centos.org/centos/5/os/i386/CentOS/centos-release-notes-5.5-0.i386.rpm
#wget http://mirror.centos.org/centos/5/os/i386/CentOS/yum-3.2.22-26.el5.centos.noarch.rpm
#wget http://mirror.centos.org/centos/5/os/i386/CentOS/yum-updatesd-0.9-2.el5.noarch.rpm
#wget http://mirror.centos.org/centos/5/os/i386/CentOS/yum-fastestmirror-1.1.16-14.el5.centos.1.noarch.rpm
#rpm --import RPM-GPG-KEY-CentOS-5
#/bin/rpm -e --nodeps redhat-release
#/bin/rpm -e --nodeps rhn-client-tools
#/bin/rpm -e --nodeps yum-rhn-plugin
#rpm -Uvh --force *.rpm
#yum upgrade
#reboot

That should do the trick!

When to use Interfaces?
Interfaces allow you to specify which methods a class must provide, without having to know how they are handled.
Methods specified in an interface MUST be implemented in a class.

1
2
3
4

interface SomeInterface
{
  public function doSomething( $variable );
}

When to use Abstract classes?
An abstract class provides structure. It usually defines default implementations.
Methods specified in an abstract class can be ignored in a subclass.

1
2
3
4
5
6
7

abstract class SomeInterface
{
  abstract protected function doSomething( $variable )
  {
    //Put some code here if you like
  }
}

This table attempts to define the difference between Interfaces and Abstract classes.

Updated: Dec-05-2011: Added visibility to the table.