Doctrine 2 also allows you to provide the ORM metadata in the form of plain 
PHP code using the `ClassMetadata` API. You can write the code in PHP files or 
inside of a static function named `loadMetadata($class)` on the entity class itself.

++ PHP Files

If you wish to write your mapping information inside PHP files that are named 
after the entity and included to populate the metadata for an entity you can do 
so by using the `PHPDriver`:

    [php]
    $driver = new PHPDriver('/path/to/php/mapping/files');
    $em->getConfiguration()->setMetadataDriverImpl($driver);

Now imagine we had an entity named `Entities\User` and we wanted to write a mapping
file for it using the above configured `PHPDriver` instance:

    [php]
    namespace Entities;
    
    class User
    {
        private $id;
        private $username;
    }

To write the mapping information you just need to create a file named 
`Entities.User.php` inside of the `/path/to/php/mapping/files` folder:

    [php]
    // /path/to/php/mapping/files/Entities.User.php

    $metadata->mapField(array(
       'id' => true,
       'fieldName' => 'id',
       'type' => 'integer'
    ));
    
    $metadata->mapField(array(
       'fieldName' => 'username',
       'type' => 'string'
    ));

Now we can easily retrieve the populated `ClassMetadata` instance where the `PHPDriver`
includes the file and the `ClassMetadataFactory` caches it for later retrieval:

    [php]
    $class = $em->getClassMetadata('Entities\User');
    // or
    $class = $em->getMetadataFactory()->getMetadataFor('Entities\User');


++ Static Function

In addition to the PHP files you can also specify your mapping information inside
of a static function defined on the entity class itself. This is useful for cases
where you want to keep your entity and mapping information together but don't want
to use annotations. For this you just need to use the `StaticPHPDriver`:

    [php]
    $driver = new StaticPHPDriver('/path/to/entities');
    $em->getConfiguration()->setMetadataDriverImpl($driver);

Now you just need to define a static function named `loadMetadata($metadata)` on your entity:

    [php]
    namespace Entities;
    
    use Doctrine\ORM\Mapping\ClassMetadata;
    
    class User
    {
        // ...

        public static function loadMetadata(ClassMetadata $metadata)
        {
            $metadata->mapField(array(
               'id' => true,
               'fieldName' => 'id',
               'type' => 'integer'
            ));

            $metadata->mapField(array(
               'fieldName' => 'username',
               'type' => 'string'
            ));
        }
    }

++ ClassMetadataInfo API

The `ClassMetadataInfo` class is the base data object for storing the mapping
metadata for a single entity. It contains all the getters and setters you need 
populate and retrieve information for an entity.

+++ General Setters

 * `setTableName($tableName)`
 * `setPrimaryTable(array $primaryTableDefinition)`
 * `setCustomRepositoryClass($repositoryClassName)`
 * `setIdGeneratorType($generatorType)`
 * `setIdGenerator($generator)`
 * `setSequenceGeneratorDefinition(array $definition)`
 * `setChangeTrackingPolicy($policy)`
 * `setIdentifier(array $identifier)`

+++ Inheritance Setters

 * `setInheritanceType($type)`
 * `setSubclasses(array $subclasses)`
 * `setParentClasses(array $classNames)`
 * `setDiscriminatorColumn($columnDef)`
 * `setDiscriminatorMap(array $map)`

+++ Field Mapping Setters

 * `mapField(array $mapping)`
 * `mapOneToOne(array $mapping)`
 * `mapOneToMany(array $mapping)`
 * `mapManyToOne(array $mapping)`
 * `mapManyToMany(array $mapping)`

+++ Lifecycle Callback Setters

 * `addLifecycleCallback($callback, $event)`
 * `setLifecycleCallbacks(array $callbacks)`

+++ Versioning Setters

 * `setVersionMapping(array &$mapping)`
 * `setVersioned($bool)`
 * `setVersionField()`
 
+++ General Getters

 * `getTableName()`
 * `getTemporaryIdTableName()`

+++ Identifier Getters

 * `getIdentifierColumnNames()`
 * `usesIdGenerator()`
 * `isIdentifier($fieldName)`
 * `isIdGeneratorIdentity()`
 * `isIdGeneratorSequence()`
 * `isIdGeneratorTable()`
 * `isIdentifierNatural()`
 * `getIdentifierFieldNames()`
 * `getSingleIdentifierFieldName()`
 * `getSingleIdentifierColumnName()`

+++ Inheritance Getters

 * `isInheritanceTypeNone()`
 * `isInheritanceTypeJoined()`
 * `isInheritanceTypeSingleTable()`
 * `isInheritanceTypeTablePerClass()`
 * `isInheritedField($fieldName)`
 * `isInheritedAssociation($fieldName)`
 
+++ Change Tracking Getters

 * `isChangeTrackingDeferredExplicit()`
 * `isChangeTrackingDeferredImplicit()`
 * `isChangeTrackingNotify()`

+++ Field & Association Getters

 * `isUniqueField($fieldName)`
 * `isNullable($fieldName)`
 * `getColumnName($fieldName)`
 * `getFieldMapping($fieldName)`
 * `getAssociationMapping($fieldName)`
 * `getAssociationMappings()`
 * `getFieldName($columnName)`
 * `hasField($fieldName)`
 * `getColumnNames(array $fieldNames = null)`
 * `getTypeOfField($fieldName)`
 * `getTypeOfColumn($columnName)`
 * `hasAssociation($fieldName)`
 * `isSingleValuedAssociation($fieldName)`
 * `isCollectionValuedAssociation($fieldName)`

+++ Lifecycle Callback Getters

 * `hasLifecycleCallbacks($lifecycleEvent)`
 * `getLifecycleCallbacks($event)`

++ ClassMetadata API

The `ClassMetadata` class extends `ClassMetadataInfo` and adds the runtime functionality
required by Doctrine. It adds a few extra methods related to runtime reflection
for working with the entities themselves.

 * `getReflectionClass()`
 * `getReflectionProperties()`
 * `getReflectionProperty($name)`
 * `getSingleIdReflectionProperty()`
 * `getIdentifierValues($entity)`
 * `setIdentifierValues($entity, $id)`
 * `setFieldValue($entity, $field, $value)`
 * `getFieldValue($entity, $field)`