array constants? how and where to define?

sneakyimp

So I have a variety of classes that extend one central class. Each of these classes deals with a particular variety of data file: images, audio, video, etc.

So each class is going to have a validateMedia() method which checks the MIME type of the file and returns true ONLY IF that MIME type is in a list. This brings me to the list.

It seems natural to me to try and define a constant which contains all the valid mime types but you can't define array constants in PHP. It occurred to me to try and define a semicolon-delimited list like this but I'd need to be sure that no mimetype ever contained a semicolon and also would have to parse/explode/patternmatch this list every time I want to check a mime type. Something like this:

define('VALID_MIME_TYPES', 'image/jpeg;image/gif;image/png');
function is_valid_mime($mime_type) {
  $valid_mimes = explode(';', VALID_MIME_TYPES); // not crazy about this part
  if (!in_array($mime_type, $valid_mimes)) {
    return false;
  }
  return true;
}

Also, where might I put this? Seems to me that it would be helpful for a site admin to have it in a master config or INI file somewhere in case they choose to start supporting PNG images when the new browser releases come out.

On the other hand, defining it as a class constant might be better because then we don't have a MASSIVE site-wide config file. Something like this:

class Image {
  const VALID_MIME_TYPES = 'image/jpeg;image/gif;image/png';

  function isValidMimeType($mimeType) {
    $valid_mimes = explode(';', self::VALID_MIME_TYPES); // still not crazy about this part
    if (!in_array($mimeType, $valid_mimes)) {
      return false;
    }
    return true;
  }
}

Any suggestions?

NogDog

I would just go ahead and use an array, making it static and probably private.

Horizon88

I take it the obvious

define('VALID_MIME_TYPES', array('image/jpg','image/png'));

won't work for some reason or another, right? 😃

NogDog

Horizon88 wrote:
I take it the obvious
define('VALID_MIME_TYPES', array('image/jpg','image/png'));
won't work for some reason or another, right? 😃

Right, it won't work, since an array is not a scalar value.

See the manual entry for [man]define/man:

value

The value of the constant; only scalar and null values are allowed. Scalar values are integer, float, string or boolean values.

mpb001

A bit more code... But these things you should only ever need to write once so it is worth the effort.


abstract class MimeType
{
    abstract static function Validate( $type );
}

class ImageMimeType extends MimeType
{
    const JPEG = 'image/jpeg'; //remove all need to use loose strings to refer to them again.
    const GIF  = 'image/gif';
    const PNG  = 'image/png';

static function Validate( $type )
{
    //switch is easier to read and add to then an if/else chain
    switch( $type )
    {
        case self::JPEG;    
        case self::GIF;    
        case self::PNG; 
            return true;

        default:
            return false;
    }
}


//Is methods are pretty useful. 
static function IsJPEG( $type )
{
    return self::JPEG  == $type;
}
}

echo ImageMimeType::Validate( 'image/gif' ) . "<br/>\n";
echo ImageMimeType::IsJPEG( 'image/jpeg' );

sneakyimp

Thanks mpb. Being the lazy jerk I am, I was looking for shortcuts and ended up using an array variable in my image class like Nog suggested. I am curious though about how you retrieve the MIME type of a thread. I've been posting to supposedly resolved thread [http://phpbuilder.com/board/showthread.php?t=10345852]here[/url] about MIME_Type and PECL's Fileinfo packages.

I suppose putting it right in my Image class as opposed to some centralized config is not the end of the world.

NogDog

The one thing I'm not crazy about is that if you want to add another image mime-type, you have to modify the class in two places, adding another constant and another switch case. If you use an array of types, then your validate method only needs to do a simple in_array() call.

If you make the mime-type array private and have no method for altering it, then functionally it is a constant, so you do not gain anything special by using constants instead (other than gaining more complexity in your class).

mpb001

The constant at the top would laso be used for all manual external references to a mime type. I see loose strings almost as as bad as magic numbers and it stops me having to ever put

if( $type == 'image/jpeg' )

anywhere else ever again. I also like fatal errors and manually mistyping a mime type would not cause one( $type == 'image/jpg' ) but calling a bad class constant would. So even though my way looks more complicated it is more multi faceted and has other benefits. I would also use this list http://www.w3schools.com/media/media_mimeref.asp on creation of the class as it should be as complete as possible at first use. Anyone else who then calls it can kick me if it isn't.

Now deciding what is an invalid valid image type is something else.

mpb001

The other thing you can do is build a code generator to handle changes


class MimeTypeObjectBuilder
{
    private $types        = array();
    private $content_type = '';

function SetContentType( $content_type )
{
    $this->content_type = $content_type;
}


function AddType( $mime_type , $constant )
{
    $this->types[] = array( $mime_type , $constant  );
}


function Build()
{
    $constants   = '';
    $validators  = '';
    $switch      = '';

    foreach ( $this->types AS $type )
    {
        list( $mime_type , $constant   ) = $type;

        $constants  .= "\tconst " . $constant . "\t= '" . $mime_type . "';\n";

        $switch     .= "\t\t\tcase self::" .$constant . ":\n";

        $validators .= "\n\n\tstatic function Is" . $constant . '( $type )' . "\n"
                     . "\t{\n"
                     . "\t\t" . "return self::" . $constant . ' == $type;' . "\n"
                     . "\t}\n";

    }   

    return '<?php'. "\n" 
          . 'class ' . ucwords( $this->content_type ) . 'MimeType // extends MimeType' . "\n"
          . "{\n"
          . $constants
          . "\n\n"
          . "\t"  . 'static function Validate( $type )' . "\n"
          . "\t{\n"  
          . "\t\t"   . 'switch ( $type ) ' . "\n"
          . "\t\t{\n"
          . $switch
          . "\t\t\t\treturn true; \n\n"
          . "\t\t\tdefault :\n"
          . "\t\t\t\t return false;\n"
          . "\t\t}\n" 
          . "\t}"
          . "\n"
          . $validators
          . "}\n"
          . '?>'; 
}
}


$builder = new MimeTypeObjectBuilder();
$builder->SetContentType('Image');
$builder->AddType( 'image/bmp'  , 'BMP' );
$builder->AddType( 'image/jpeg' , 'JPEG'  );
$builder->AddType( 'image/tiff' , 'TIFF'  );
$builder->AddType( 'image/gif'  , 'GIF' );
$builder->AddType( 'image/png'  , 'PNG' );

echo $builder->Build();

builds


class ImageMimeType // extends MimeType
{
	const BMP	= 'image/bmp';
	const JPEG	= 'image/jpeg';
	const TIFF	= 'image/tiff';
	const GIF	= 'image/gif';
	const PNG	= 'image/png';


static function Validate( $type )
{
	switch ( $type ) 
	{
		case self::BMP:
		case self::JPEG:
		case self::TIFF:
		case self::GIF:
		case self::PNG:
			return true; 

		default :
			 return false;
	}
}


static function IsBMP( $type )
{
	return self::BMP == $type;
}


static function IsJPEG( $type )
{
	return self::JPEG == $type;
}


static function IsTIFF( $type )
{
	return self::TIFF == $type;
}


static function IsGIF( $type )
{
	return self::GIF == $type;
}


static function IsPNG( $type )
{
	return self::PNG == $type;
}
}

I'll keep that after I clean it up a bit.

sourav123

NogDog wrote:
Right, it won't work, since an array is not a scalar value.

See the manual entry for [man]define/man:

Hello guys it seems to be you guys are little disappointed with the fact that PHP don't allow you guys to declare an array as an constant

Now I have come up with a simple solution for this problem 🙂 . You can declare an array as an constant as described in the following code:

[COLOR="Navy"] include('arrConst.inc.php');

 $myArray= array(1,'2',array(‘three’,'four'), '5'); [COLOR="DarkGreen"]// now have an array[/COLOR]

 arrConst::set(‘CONSTARRAY',$myArray);


echo '<pre>';
print_r(arrConst::get(CONSTARRAY'));		/[COLOR="DarkGreen"]/ printing the array from the Constant[/COLOR]
echo '</pre>';[/COLOR]

You can down load the arrConst.inc.php from www.phpclasses.org/browse/package/4226.html

lampmaster

I have written a class to contain constants of all types in a global static.

see: http://lampmaster.blogspot.com/2009/06/using-arrays-in-php-constants.html

mpb001

"arrConst::set(‘CONSTARRAY',$myArray);"

and

" I have written a class to contain constants of all types in a global static.

see: http://lampmaster.blogspot.com/2009/...constants.html"

Really are forms of registry
http://www.sitepoint.com/forums/showthread.php?t=305737&highlight=registry+pattern+PHP5 which is just another version of $_GLOBALS. Different use.

The values if objects can change due to the fact they are returned by reference so the callee can change them. Constants are things that can be defined before run time such as types.

Normal constants are only trustable when directly referenced and lose the ability to be trusted when passed if all the code that exists is not your own/ you can't trust yourself to never hard code a value.
Constants such as mime types/alignment types can be used and shared between projects keeping the DRY principle.

There is the
"Replace type code with subclasses" refactor( in java ) that is relevant
http://sourcemaking.com/refactoring/replace-type-code-with-subclasses

The key is the objects the it creates are child classes and the parent class has a creation method for them and a private constructor so the child objects cannot

(Creation method in employee)
 static Employee create(int type) {
        switch (type) {
            case ENGINEER:
               return new Engineer();
            case SALESMAN:
               return new Salesman();
            case MANAGER:
               return new Manager();
            default:
               throw new IllegalArgumentException("Incorrect type code value");
        }
    }


(Child object creation method creates)
class Engineer extends Employee {
    int getType() {
        return Employee.ENGINEER;
    }
  }

PHP Variation

<?php
//Replace type code with Subclasses designed for mime types, alignments types etc
abstract class Alignment{
    const TOP       = "Top";
    const BOTTOM    = "Bottom";
    const LEFT      = "Left";
    const RIGHT     = "Right";

private $type;

protected function __construct( $type ) {
    $this->type = $type;
}

public static function create( $alignmentConstantType ){

    switch( $alignmentConstantType ){
        case self::TOP :
            return new TopAlignment($alignmentConstantType);

        case self::BOTTOM :
            return new BottomAlignment($alignmentConstantType);

        case self::LEFT :
            return new LeftAlignment($alignmentConstantType);

        case self::RIGHT :
            return new RightAlignment($alignmentConstantType);
    }

    throw new Exception("Invalid alignment constant exception");
} 


function getType(){
    return $this->type;   
}  


}


class TopAlignment extends Alignment{
    protected function __construct( $type ){
        parent::__construct( $type );   

    }
    //Constructor can be skipped in php as it automatically calls the parent if there is one
    //personal choice, usually i do as it makes inherant dependancies more clear without opening parent
}


class BottomAlignment extends Alignment{}
class LeftAlignment extends Alignment{}

class RightAlignment extends Alignment{
    protected function __construct( $type ){
        parent::__construct( $type );   

    }
}


/**
 * To compare what type it is in logic use instance of. When the actual value is needed use getType
 * Normal constants can not be trusted as actually being constant when passed.
 * @param Alignment $alignment
 */
function TestAlignmentConstant( Alignment $alignment ){

echo "value is equal to ". $alignment->getType() . ' and is a constant class of :-<br/>';
    switch(true){
        case $alignment instanceof TopAlignment :
            echo "TopAlignment";
            break;

        case $alignment instanceof BottomAlignment  :
            echo "BottomAlignment";
            break;

        case $alignment instanceof LeftAlignment :
            echo "LeftAlignment";
            break;

        case $alignment instanceof RightAlignment:
            echo "RightAlignment";
            break;
    };


echo "<br>";
}



//only the creation method can create instances of TopAlignment etc.
TestAlignmentConstant( Alignment::create( Alignment::TOP  ) );
TestAlignmentConstant( Alignment::create( Alignment::BOTTOM  ) );
TestAlignmentConstant( Alignment::create( Alignment::LEFT   ) );
TestAlignmentConstant( Alignment::create( Alignment::RIGHT ) );


?>

themarty

Perhaps this is a better implementation of the concept of 'constant arrays':

http://devshed.excudo.net/scripts/php/example/constant+arrays

It generates errors when you try to define an already existing constant or try to access a non-existing one, just like php does with normal constants.