<?php

/**

 * @file

 * Field Info API, providing information about available fields and field types.

 */

/**

 * Retrieves the FieldInfo object for the current request.

 *

 * @return FieldInfo

 *   An instance of the FieldInfo class.

 */

function _field_info_field_cache() {

  // Use the advanced drupal_static() pattern, since this is called very often.

  static $drupal_static_fast;

  if (!isset($drupal_static_fast)) {

    $drupal_static_fast['field_info_field_cache'] = &drupal_static(__FUNCTION__);

  }

  $field_info = &$drupal_static_fast['field_info_field_cache'];

  if (!isset($field_info)) {

    // @todo The registry should save the need for an explicit include, but not

    // a couple upgrade tests (DisabledNodeTypeTestCase,

    // FilterFormatUpgradePathTestCase...) break in a strange way without it.

    include_once dirname(__FILE__) . '/field.info.class.inc';

    $field_info = new FieldInfo();

  }

  return $field_info;

}

/**

 * @defgroup field_info Field Info API

 * @{

 * Obtain information about Field API configuration.

 *

 * The Field Info API exposes information about field types, fields,

 * instances, bundles, widget types, display formatters, behaviors,

 * and settings defined by or with the Field API.

 *

 * See @link field Field API @endlink for information about the other parts of

 * the Field API.

 */

/**

 * Clears the field info cache without clearing the field data cache.

 *

 * This is useful when deleted fields or instances are purged.  We

 * need to remove the purged records, but no actual field data items

 * are affected.

 */

function field_info_cache_clear() {

  drupal_static_reset('field_view_mode_settings');

  drupal_static_reset('field_available_languages');

  // @todo: Remove this when field_attach_*_bundle() bundle management

  // functions are moved to the entity API.

  entity_info_cache_clear();

  _field_info_collate_types(TRUE);

  _field_info_field_cache()->flush();

}

/**

 * Collates all information on existing fields and instances.

 *

 * Deprecated. This function is kept to ensure backwards compatibility, but has

 * a serious performance impact, and should be absolutely avoided.

 * See http://drupal.org/node/1915646.

 *

 * Use the regular field_info_*() API functions to access the information, or

 * field_info_cache_clear() to clear the cached data.

 */

function _field_info_collate_fields($reset = FALSE) {

  if ($reset) {

    _field_info_field_cache()->flush();

    return;

  }

  $cache = _field_info_field_cache();

  // Collect fields, and build the array of IDs keyed by field_name.

  $fields = $cache->getFields();

  $field_ids = array();

  foreach ($fields as $id => $field) {

    if (!$field['deleted']) {

      $field_ids[$field['field_name']] = $id;

    }

  }

  // Collect extra fields for all entity types.

  $extra_fields = array();

  foreach (field_info_bundles() as $entity_type => $bundles) {

    foreach ($bundles as $bundle => $info) {

      $extra_fields[$entity_type][$bundle] = $cache->getBundleExtraFields($entity_type, $bundle);

    }

  }

  return array(

    'fields' => $fields,

    'field_ids' => $field_ids,

    'instances' => $cache->getInstances(),

    'extra_fields' => $extra_fields,

  );

}

/**

 * Collates all information on field types, widget types and related structures.

 *

 * @param $reset

 *   If TRUE, clear the cache. The information will be rebuilt from the database

 *   next time it is needed. Defaults to FALSE.

 *

 * @return

 *   If $reset is TRUE, nothing.

 *   If $reset is FALSE, an array containing the following elements:

 *   - 'field types': Array of hook_field_info() results, keyed by field_type.

 *     Each element has the following components: label, description, settings,

 *     instance_settings, default_widget, default_formatter, and behaviors

 *     from hook_field_info(), as well as module, giving the module that exposes

 *     the field type.

 *   - 'widget types': Array of hook_field_widget_info() results, keyed by

 *     widget_type. Each element has the following components: label, field

 *     types, settings, weight, and behaviors from hook_field_widget_info(),

 *     as well as module, giving the module that exposes the widget type.

 *   - 'formatter types': Array of hook_field_formatter_info() results, keyed by

 *     formatter_type. Each element has the following components: label, field

 *     types, and behaviors from hook_field_formatter_info(), as well as

 *     module, giving the module that exposes the formatter type.

 *   - 'storage types': Array of hook_field_storage_info() results, keyed by

 *     storage type names. Each element has the following components: label,

 *     description, and settings from hook_field_storage_info(), as well as

 *     module, giving the module that exposes the storage type.

 *   - 'fieldable types': Array of hook_entity_info() results, keyed by

 *     entity_type. Each element has the following components: name, id key,

 *     revision key, bundle key, cacheable, and bundles from hook_entity_info(),

 *     as well as module, giving the module that exposes the entity type.

 */

function _field_info_collate_types($reset = FALSE) {

  global $language;

  static $info;

  // The _info() hooks invoked below include translated strings, so each

  // language is cached separately.

  $langcode = $language->language;

  if ($reset) {

    $info = NULL;

    // Clear all languages.

    cache_clear_all('field_info_types:', 'cache_field', TRUE);

    return;

  }

  if (!isset($info)) {

    if ($cached = cache_get("field_info_types:$langcode", 'cache_field')) {

      $info = $cached->data;

    }

    else {

      $info = array(

        'field types' => array(),

        'widget types' => array(),

        'formatter types' => array(),

        'storage types' => array(),

      );

      // Populate field types.

      foreach (module_implements('field_info') as $module) {

        $field_types = (array) module_invoke($module, 'field_info');

        foreach ($field_types as $name => $field_info) {

          // Provide defaults.

          $field_info += array(

            'settings' => array(),

            'instance_settings' => array(),

          );

          $info['field types'][$name] = $field_info;

          $info['field types'][$name]['module'] = $module;

        }

      }

      drupal_alter('field_info', $info['field types']);

      // Populate widget types.

      foreach (module_implements('field_widget_info') as $module) {

        $widget_types = (array) module_invoke($module, 'field_widget_info');

        foreach ($widget_types as $name => $widget_info) {

          // Provide defaults.

          $widget_info += array(

            'settings' => array(),

          );

          $info['widget types'][$name] = $widget_info;

          $info['widget types'][$name]['module'] = $module;

        }

      }

      drupal_alter('field_widget_info', $info['widget types']);

      uasort($info['widget types'], 'drupal_sort_weight');

      // Populate formatter types.

      foreach (module_implements('field_formatter_info') as $module) {

        $formatter_types = (array) module_invoke($module, 'field_formatter_info');

        foreach ($formatter_types as $name => $formatter_info) {

          // Provide defaults.

          $formatter_info += array(

            'settings' => array(),

          );

          $info['formatter types'][$name] = $formatter_info;

          $info['formatter types'][$name]['module'] = $module;

        }

      }

      drupal_alter('field_formatter_info', $info['formatter types']);

      // Populate storage types.

      foreach (module_implements('field_storage_info') as $module) {

        $storage_types = (array) module_invoke($module, 'field_storage_info');

        foreach ($storage_types as $name => $storage_info) {

          // Provide defaults.

          $storage_info += array(

            'settings' => array(),

          );

          $info['storage types'][$name] = $storage_info;

          $info['storage types'][$name]['module'] = $module;

        }

      }

      drupal_alter('field_storage_info', $info['storage types']);

      // Set the cache if we can acquire a lock.

      if (lock_acquire("field_info_types:$langcode")) {

        cache_set("field_info_types:$langcode", $info, 'cache_field');

        lock_release("field_info_types:$langcode");

      }

    }

  }

  return $info;

}

/**

 * Prepares a field definition for the current run-time context.

 *

 * The functionality has moved to the FieldInfo class. This function is kept as

 * a backwards-compatibility layer. See http://drupal.org/node/1915646.

 *

 * @see FieldInfo::prepareField()

 */

function _field_info_prepare_field($field) {

  $cache = _field_info_field_cache();

  return $cache->prepareField($field);

}

/**

 * Prepares an instance definition for the current run-time context.

 *

 * The functionality has moved to the FieldInfo class. This function is kept as

 * a backwards-compatibility layer. See http://drupal.org/node/1915646.

 *

 * @see FieldInfo::prepareInstance()

 */

function _field_info_prepare_instance($instance, $field) {

  $cache = _field_info_field_cache();

  return $cache->prepareInstance($instance, $field['type']);

}

/**

 * Adapts display specifications to the current run-time context.

 *

 * The functionality has moved to the FieldInfo class. This function is kept as

 * a backwards-compatibility layer. See http://drupal.org/node/1915646.

 *

 * @see FieldInfo::prepareInstanceDisplay()

 */

function _field_info_prepare_instance_display($field, $display) {

  $cache = _field_info_field_cache();

  return $cache->prepareInstanceDisplay($display, $field['type']);

}

/**

 * Prepares widget specifications for the current run-time context.

 *

 * The functionality has moved to the FieldInfo class. This function is kept as

 * a backwards-compatibility layer. See http://drupal.org/node/1915646.

 *

 * @see FieldInfo::prepareInstanceWidget()

 */

function _field_info_prepare_instance_widget($field, $widget) {

  $cache = _field_info_field_cache();

  return $cache->prepareInstanceWidget($widget, $field['type']);

}

/**

 * Prepares 'extra fields' for the current run-time context.

 *

 * The functionality has moved to the FieldInfo class. This function is kept as

 * a backwards-compatibility layer. See http://drupal.org/node/1915646.

 *

 * @see FieldInfo::prepareExtraFields()

 */

function _field_info_prepare_extra_fields($extra_fields, $entity_type, $bundle) {

  $cache = _field_info_field_cache();

  return $cache->prepareExtraFields($extra_fields, $entity_type, $bundle);

}

/**

 * Determines the behavior of a widget with respect to an operation.

 *

 * @param $op

 *   The name of the operation. Currently supported: 'default value',

 *   'multiple values'.

 * @param $instance

 *   The field instance array.

 *

 * @return

 *   One of these values:

 *   - FIELD_BEHAVIOR_NONE: Do nothing for this operation.

 *   - FIELD_BEHAVIOR_CUSTOM: Use the widget's callback function.

 *   - FIELD_BEHAVIOR_DEFAULT: Use field.module default behavior.

 */

function field_behaviors_widget($op, $instance) {

  $info = field_info_widget_types($instance['widget']['type']);

  return isset($info['behaviors'][$op]) ? $info['behaviors'][$op] : FIELD_BEHAVIOR_DEFAULT;

}

/**

 * Returns information about field types from hook_field_info().

 *

 * @param $field_type

 *   (optional) A field type name. If omitted, all field types will be

 *   returned.

 *

 * @return

 *   Either a field type description, as provided by hook_field_info(), or an

 *   array of all existing field types, keyed by field type name.

 */

function field_info_field_types($field_type = NULL) {

  $info = _field_info_collate_types();

  $field_types = $info['field types'];

  if ($field_type) {

    if (isset($field_types[$field_type])) {

      return $field_types[$field_type];

    }

  }

  else {

    return $field_types;

  }

}

/**

 * Returns information about field widgets from hook_field_widget_info().

 *

 * @param $widget_type

 *   (optional) A widget type name. If omitted, all widget types will be

 *   returned.

 *

 * @return

 *   Either a single widget type description, as provided by

 *   hook_field_widget_info(), or an array of all existing widget types, keyed

 *   by widget type name.

 */

function field_info_widget_types($widget_type = NULL) {

  $info = _field_info_collate_types();

  $widget_types = $info['widget types'];

  if ($widget_type) {

    if (isset($widget_types[$widget_type])) {

      return $widget_types[$widget_type];

    }

  }

  else {

    return $widget_types;

  }

}

/**

 * Returns information about field formatters from hook_field_formatter_info().

 *

 * @param $formatter_type

 *   (optional) A formatter type name. If omitted, all formatter types will be

 *   returned.

 *

 * @return

 *   Either a single formatter type description, as provided by

 *   hook_field_formatter_info(), or an array of all existing formatter types,

 *   keyed by formatter type name.

 */

function field_info_formatter_types($formatter_type = NULL) {

  $info = _field_info_collate_types();

  $formatter_types = $info['formatter types'];

  if ($formatter_type) {

    if (isset($formatter_types[$formatter_type])) {

      return $formatter_types[$formatter_type];

    }

  }

  else {

    return $formatter_types;

  }

}

/**

 * Returns information about field storage from hook_field_storage_info().

 *

 * @param $storage_type

 *   (optional) A storage type name. If omitted, all storage types will be

 *   returned.

 *

 * @return

 *   Either a storage type description, as provided by

 *   hook_field_storage_info(), or an array of all existing storage types,

 *   keyed by storage type name.

 */

function field_info_storage_types($storage_type = NULL) {

  $info = _field_info_collate_types();

  $storage_types = $info['storage types'];

  if ($storage_type) {

    if (isset($storage_types[$storage_type])) {

      return $storage_types[$storage_type];

    }

  }

  else {

    return $storage_types;

  }

}

/**

 * Returns information about existing bundles.

 *

 * @param $entity_type

 *   The type of entity; e.g. 'node' or 'user'.

 *

 * @return

 *   An array of bundles for the $entity_type keyed by bundle name,

 *   or, if no $entity_type was provided, the array of all existing bundles,

 *   keyed by entity type.

 */

function field_info_bundles($entity_type = NULL) {

  $info = entity_get_info();

  if ($entity_type) {

    return isset($info[$entity_type]['bundles']) ? $info[$entity_type]['bundles'] : array();

  }

  $bundles = array();

  foreach ($info as $type => $entity_info) {

    $bundles[$type] = $entity_info['bundles'];

  }

  return $bundles;

}

/**

 * Returns a lightweight map of fields across bundles.