<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.34 $ -->
 <reference id="ref.classobj">
  <title>Class/Object Functions</title>
  <titleabbrev>Classes/Objects</titleabbrev>

  <partintro>
   <sect1 id="classobj.partintro">
    <title>Introduction</title>
    <sect2 id="classobj.intro">
     <title>About</title>
     <para>
      These functions allow you to obtain information about classes
      and instance objects. You can obtain the name of the class to
      which a object belongs, as well as its member properties and 
      methods. Using these functions, you can find out not only the
      class membership of an object, but also its parentage (i.e.
      what class is the object class extending).
     </para>
    </sect2>
    <sect2 id="classobj.example">
     <title>An example of use</title>
     <para>
      In this example, we first define a base class and an extension
      of the class. The base class describes a general vegetable,
      whether it is edible or not and what is its color. The subclass
      <varname>Spinach</varname> adds a method to cook it and another to
      find out if it is cooked.
     </para>
     <para>
      <example>
       <title>classes.inc</title>
       <programlisting role="php">
<![CDATA[
<?php

// base class with member properties and methods
class Vegetable {

    var $edible;
    var $color;

    function Vegetable( $edible, $color="green" ) {
        $this->edible = $edible;
        $this->color = $color;
    }

    function is_edible() {
        return $this->edible;
    }

    function what_color() {
        return $this->color;
    }
    
} // end of class Vegetable


// extends the base class
class Spinach extends Vegetable {

    var $cooked = false;

    function Spinach() {
        $this->Vegetable( true, "green" );
    }

    function cook_it() {
        $this->cooked = true;
    }

    function is_cooked() {
        return $this->cooked;
    }
    
} // end of class Spinach

?>
]]>
       </programlisting>
      </example>
     </para>
     <para>
     We then instantiate 2 objects from these classes and print out
     information about them, including their class parentage.
     We also define some utility functions, mainly to have a nice printout
     of the variables.
     </para>
     <para>
      <example>
       <title>test_script.php</title>
       <programlisting role="php">
<![CDATA[
<pre>
<?php

include "classes.inc";

// utility functions

function print_vars($obj) {
    $arr = get_object_vars($obj);
    while (list($prop, $val) = each($arr))
        echo "\t$prop = $val\n";
}

function print_methods($obj) {
    $arr = get_class_methods(get_class($obj));
    foreach ($arr as $method)
        echo "\tfunction $method()\n";
}

function class_parentage($obj, $class) {
    global $$obj;
    if (is_subclass_of($$obj, $class)) {
        echo "Object $obj belongs to class ".get_class($$obj);
        echo " a subclass of $class\n";
    } else {
        echo "Object $obj does not belong to a subclass of $class\n";
    }
}

// instantiate 2 objects

$veggie = new Vegetable(true,"blue");
$leafy = new Spinach();

// print out information about objects
echo "veggie: CLASS ".get_class($veggie)."\n";
echo "leafy: CLASS ".get_class($leafy);
echo ", PARENT ".get_parent_class($leafy)."\n";

// show veggie properties
echo "\nveggie: Properties\n";
print_vars($veggie);

// and leafy methods
echo "\nleafy: Methods\n";
print_methods($leafy);

echo "\nParentage:\n";
class_parentage("leafy", "Spinach");
class_parentage("leafy", "Vegetable");
?>
</pre>
]]>
       </programlisting>
      </example>
     </para>
     <para>
      One important thing to note in the example above is that
      the object <varname>$leafy</varname> is an instance of the class
      <classname>Spinach</classname> which is a subclass of 
      <classname>Vegetable</classname>,
      therefore the last part of the script above will output:
     </para>
     <para>
      <informalexample>
       <programlisting>
<![CDATA[
       [...]
Parentage:
Object leafy does not belong to a subclass of Spinach
Object leafy belongs to class spinach a subclass of Vegetable
]]>
       </programlisting>
      </informalexample>
     </para>
    </sect2>
   </sect1>
  </partintro>
   
  <refentry id="function.call-user-method-array">
   <refnamediv>
    <refname>call_user_method_array</refname>
    <refpurpose>
     Call a user method given with an array of parameters
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>mixed</type><methodname>call_user_method_array</methodname>
      <methodparam><type>string</type><parameter>method_name</parameter></methodparam>
      <methodparam><type>object</type><parameter>obj</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter>paramarr</parameter></methodparam>
     </methodsynopsis>
    <para>
     Calls a the method referred by <parameter>method_name</parameter> from
     the user defined <parameter>obj</parameter> object, using the parameters
     in <parameter>paramarr</parameter>.
    </para>
    <para>
     See also:
     <function>call_user_func_array</function>,
     <function>call_user_func</function>,
     <function>call_user_method</function>.
    </para>
    <note>
     <para>
      This function was added to the CVS code after release of PHP 4.0.4pl1
     </para>
    </note>
   </refsect1>
  </refentry>
 
  <refentry id="function.call-user-method">
   <refnamediv>
    <refname>call_user_method</refname>
    <refpurpose>
     Call a user method on an specific object
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>mixed</type><methodname>call_user_method</methodname>
      <methodparam><type>string</type><parameter>method_name</parameter></methodparam>
      <methodparam><type>object</type><parameter>obj</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>parameter</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Calls a the method referred by <parameter>method_name</parameter> from
     the user defined <parameter>obj</parameter> object. An example of usage
     is below, where we define a class, instantiate an object and use
     <function>call_user_method</function> to call indirectly its
     <varname>print_info</varname> method.
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php
class Country {
    var $NAME;
    var $TLD;
    
    function Country($name, $tld) {
        $this->NAME = $name;
        $this->TLD = $tld;
    }

    function print_info($prestr="") {
        echo $prestr."Country: ".$this->NAME."\n";
        echo $prestr."Top Level Domain: ".$this->TLD."\n";
    }
}

$cntry = new Country("Peru","pe");

echo "* Calling the object method directly\n";
$cntry->print_info();

echo "\n* Calling the same method indirectly\n";
call_user_method ("print_info", $cntry, "\t");
?>
]]>
      </programlisting>
     </informalexample>
    </para>
    <simpara>
     See also <function>call_user_func_array</function>,
     <function>call_user_func</function>,
     <function>call_user_method_array</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.class-exists">
   <refnamediv>
    <refname>class_exists</refname>
    <refpurpose>Checks if the class has been defined</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>bool</type><methodname>class_exists</methodname>
      <methodparam><type>string</type><parameter>class_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns &true; if the class given by
     <parameter>class_name</parameter> has been defined,
     &false; otherwise.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.get-class">
   <refnamediv>
    <refname>get_class</refname>
    <refpurpose>Returns the name of the class of an object</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>get_class</methodname>
      <methodparam><type>object</type><parameter>obj</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns the name of the class of which the
     object <parameter>obj</parameter> is an instance. Returns
     &false; if <parameter>obj</parameter> is not an object.
    </para>
    <note>
     <simpara>
      <function>get_class</function> returns a user defined class name
      in lowercase.  A class defined in a PHP extension is returned 
      in its original notation.
     </simpara>
    </note>
    <simpara>
     See also <function>get_parent_class</function>,
     <function>get_type</function>, and 
     <function>is_subclass_of</function>
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.get-class-methods">
   <refnamediv>
    <refname>get_class_methods</refname>
    <refpurpose>Returns an array of class methods' names</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>get_class_methods</methodname>
      <methodparam><type>string</type><parameter>class_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns an array of method names defined for the
     class specified by <parameter>class_name</parameter>.
    </para>
    <note>
     <para>
      As of PHP 4.0.6, you can specify the object itself instead of
      <parameter>class_name</parameter>.  For example:
      <informalexample>
       <programlisting>
<![CDATA[
$class_methods = get_class_methods($my_class);
]]>
       </programlisting>
      </informalexample>
     </para>
    </note>
    <para>
     <example>
      <title><function>get_class_methods</function> example</title> 
      <programlisting role="php">
<![CDATA[
<?php

class myclass {
    // constructor
    function myclass() {
        return(true);
    }
    
    // method 1
    function myfunc1() {
        return(true);
    }

    // method 2
    function myfunc2() {
        return(true);
    }
}

$my_class = new myclass();

$class_methods = get_class_methods(get_class($my_class));

foreach ($class_methods as $method_name) {
    echo "$method_name\n";
}

?>      
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Will produce:
     <informalexample>
      <programlisting>
<![CDATA[
myclass
myfunc1
myfunc2
]]>
      </programlisting>
     </informalexample>
    </para>
    <simpara>
     See also <function>get_class_vars</function>,
     <function>get_object_vars</function>
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.get-class-vars">
   <refnamediv>
    <refname>get_class_vars</refname>
    <refpurpose>
     Returns an array of default properties of the class
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>get_class_vars</methodname>
      <methodparam><type>string</type><parameter>class_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function will return an associative array of default
     properties of the class.  The resulting array elements are in the
     form of <parameter>varname => value</parameter>.
    </para>
    <note>
     <para>
      Uninitialized class variables will not be reported by
      <function>get_class_vars</function>. 
     </para>
    </note>
    <para>
     <example>
      <title><function>get_class_vars</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php

class myclass {

    var $var1; // this has no default value...
    var $var2 = "xyz";
    var $var3 = 100;
    
    // constructor
    function myclass() {
        return(true);
    }

}

$my_class = new myclass();

$class_vars = get_class_vars(get_class($my_class));

foreach ($class_vars as $name => $value) {
    echo "$name : $value\n";
}

?>      
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Will produce:
     <informalexample>
      <programlisting>
<![CDATA[
var2 : xyz
var3 : 100
]]>
      </programlisting>
     </informalexample>
    </para>
    <simpara>
     See also <function>get_class_methods</function>,
     <function>get_object_vars</function>
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.get-declared-classes">
   <refnamediv>
    <refname>get_declared_classes</refname>
    <refpurpose>Returns an array with the name of the defined classes</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>get_declared_classes</methodname>
      <void/>
     </methodsynopsis>
    <para>
     This function returns an array of the names of the declared classes
     in the current script.
    </para>
    <note>
     <para>
      In PHP 4.0.1pl2, three extra classes are returned at the beginning of
      the array: <classname>stdClass</classname> (defined in 
      <filename>Zend/zend.c</filename>),
      <classname>OverloadedTestClass</classname> (defined in
      <filename>ext/standard/basic_functions.c</filename>) 
      and <classname>Directory</classname>
      (defined in <filename>ext/standard/dir.c</filename>).
     </para>
     <para>
      Also note that depending on what libraries you have compiled
      into PHP, additional classes could be present.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.get-object-vars">
   <refnamediv>
    <refname>get_object_vars</refname>
    <refpurpose>Returns an associative array of object properties</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>get_object_vars</methodname>
      <methodparam><type>object</type><parameter>obj</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns an associative array of defined object properties 
     for the specified object <parameter>obj</parameter>. If variables
     declared in the class of which the <parameter>obj</parameter> is an
     instance, have not been assigned a value, those will not be returned 
     in the array.
     <example>
      <title>Use of <function>get_object_vars</function></title>
      <programlisting role="php">
<![CDATA[
<?php
class Point2D {
    var $x, $y;
    var $label;

    function Point2D($x, $y) {
        $this->x = $x;
        $this->y = $y;
    }

    function setLabel($label) {
        $this->label = $label;
    }

    function getPoint() {
        return array("x" => $this->x,
                     "y" => $this->y,
                     "label" => $this->label);
    }
}

$p1 = new Point2D(1.233, 3.445);
print_r(get_object_vars($p1));
// "$label" is declared but not defined
// Array
// (
//     [x] => 1.233
//     [y] => 3.445
// )

$p1->setLabel("point #1");
print_r(get_object_vars($p1));
// Array
// (
//     [x] => 1.233
//     [y] => 3.445
//     [label] => point #1
// )

?>
]]>
      </programlisting>
     </example>
    </para>
    <simpara>
     See also <function>get_class_methods</function>,
     <function>get_class_vars</function>
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.get-parent-class">
   <refnamediv>
    <refname>get_parent_class</refname>
    <refpurpose>Retrieves the parent class name for object or class</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>get_parent_class</methodname>
      <methodparam><type>mixed</type><parameter>obj</parameter></methodparam>
     </methodsynopsis>
    <para>
     If <parameter>obj</parameter> is an object, returns the name of the
     parent class of the class of which <parameter>obj</parameter> is an
     instance.
    </para>
    <para>
     If <parameter>obj</parameter> is a string, returns the name of the parent
     class of the class with that name. This functionality was added in PHP
     4.0.5.
    </para>
    <simpara>
     See also <function>get_class</function> and
     <function>is_subclass_of</function>
    </simpara>
   </refsect1>
  </refentry>

 <refentry id="function.is-a">
   <refnamediv>
    <refname>is_a</refname>
    <refpurpose>
     Returns true if the object is of this class or has this class as 
     one of its parents
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>bool</type><methodname>is_a</methodname>
      <methodparam><type>object</type><parameter>object</parameter></methodparam>
      <methodparam><type>string</type><parameter>class_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns &true; if the object is of this class or 
     has this class as one of its parents, &false; otherwise.
    </para>
    <simpara>
     See also <function>get_class</function>, 
     <function>get_parent_class</function> and 
     <function>is_subclass_of</function>.
    </simpara>
   </refsect1>
  </refentry>

 <refentry id="function.is-subclass-of">
   <refnamediv>
    <refname>is_subclass_of</refname>
    <refpurpose>
     Returns true if the object has this class as one of its parents
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>bool</type><methodname>is_subclass_of</methodname>
      <methodparam><type>object</type><parameter>object</parameter></methodparam>
      <methodparam><type>string</type><parameter>class_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns &true; if the object 
     <parameter>object</parameter>, belongs to a class which is a 
     subclass of <parameter>class_name</parameter>, &false; otherwise.
    </para>
    <simpara>
     See also <function>get_class</function>, 
     <function>get_parent_class</function> and 
     <function>is_a</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.method-exists">
   <refnamediv>
    <refname>method_exists</refname>
    <refpurpose>Checks if the class method exists</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>bool</type><methodname>method_exists</methodname>
      <methodparam><type>object</type><parameter>object</parameter></methodparam>
      <methodparam><type>string</type><parameter>method_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     This function returns &true; if the method given by
     <parameter>method_name</parameter> has been defined for the given
     <parameter>object</parameter>, &false; otherwise.
    </para>
   </refsect1>
  </refentry>

 </reference>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->