Return the Pod information for the specified taxonomy, or null if the taxonomy isn't a Pod

@return array|bool|mixed|null
10589
private function get_pod_info() {

		$pod_info = null;

		if ( pods_api()->pod_exists( $this->taxonomy ) ) {

			// Load the taxonomy Pod
			$params   = array(
				'name'       => $this->taxonomy,
				'table_info' => true,
			);
			$pod_info = pods_api()->load_pod( $params, false );
		}

		return $pod_info;

	}
820586
public function getDescription()
        {
            return isset($this->_data[self::PROFILE][self::DESCRIPTION]) ? $this->_data[self::PROFILE][self::DESCRIPTION] : null;
        }
566106
public function getLabel()
    {
        $label = false;
        if (isset($this->options['label_callback'])
            && is_callable($this->options['label_callback'])) {
            $label = call_user_func($this->options['label_callback']);
        }

        if (!$label) {
            $label = isset($this->options['label']) ? $this->options['label'] : null;
        }

        return $label;
    }
357564
public function terms($taxonomy = null, array $arguments = [])
    {
        if (isset($taxonomy)) {
            return $this->model->getTerms($this, $taxonomy, $arguments);
        }

        return $this->model->getAllTerms($this);
    }
611222
public function taxonomy()
    {
        if ($this->_taxonomy === null) {
            $this->_taxonomy = $this->taxonomyFactory->create($this->base['taxonomy']);
        }

        return $this->_taxonomy;
    }
856334
public function getContentType()
    {
        if (isset($this->responseInfo['content_type'])) {
            $contentType = $this->responseInfo['content_type'];
        } else {
            $contentType = isset($this->responseHeaders['Content-Type']) ? $this->responseHeaders['Content-Type'] : null;
        }
        
        if ($contentType) {
            $contentTypeParts = preg_split('/\s*[;,]\s*/', $contentType);
            return strtolower($contentTypeParts[0]);
        }
        
        return null;
    }
646514
public function get_data() {
		$data = null;
		if ( ! empty( $this->struct['value'] ) ) {
			$data[ $this->slug ] = $this->struct['value'];
		}

		return $data;
	}
752671
public function cache_pods() {

		self::$advanced_content_types = pods_api()->load_pods( array( 'type' => 'pod', 'refresh' => true ) );
		self::$post_types             = pods_api()->load_pods( array( 'type' => 'post_type', 'refresh' => true ) );
		self::$taxonomies             = pods_api()->load_pods( array( 'type' => 'taxonomy', 'refresh' => true ) );
		self::$media                  = pods_api()->load_pods( array( 'type' => 'media', 'refresh' => true ) );
		self::$user                   = pods_api()->load_pods( array( 'type' => 'user', 'refresh' => true ) );
		self::$comment                = pods_api()->load_pods( array( 'type' => 'comment', 'refresh' => true ) );
		self::$settings               = pods_api()->load_pods( array( 'type' => 'settings', 'refresh' => true ) );
	}
1348793
protected function getCurrentTaxonomy()
	{
		if (!isset($this->args['taxonomies']) || empty($this->args['taxonomies']))
		{
			$this->args['taxonomies'] = $this->getDefaultTaxonomies();
		}

		foreach ($this->args['taxonomies'] as $tax)
		{
			if ($tax = get_term_by('slug', get_query_var($tax), $tax))
			{
				return $tax;
				break;
			}
		}

		return null;
	}
259543
public function getCategoriesAttribute()
    {
        // Request category only if post type uses categories
        $getPostType = getPostType($this->getTable());

        if($getPostType->hasCategories) {
            return $this->getRelationValue('categories');
        }
        return null;
    }
260557
public function get_meta( $object_type, $_null = null, $object_id = 0, $meta_key = '', $single = false ) {

		// Enforce boolean as it can be a string sometimes
		$single = filter_var( $single, FILTER_VALIDATE_BOOLEAN );

		$meta_type = $object_type;

		if ( in_array( $meta_type, array( 'post_type', 'media' ) ) ) {
			$meta_type = 'post';
		} elseif ( 'taxonomy' == $meta_type ) {
			$meta_type = 'term';
		}

		if ( empty( $meta_key ) ) {
			if ( ! defined( 'PODS_ALLOW_FULL_META' ) || ! PODS_ALLOW_FULL_META ) {
				return $_null; // don't cover get_post_meta( $id )
			}

			$single = false;
		}

		if ( 'user' === $object_type && 'locale' === $meta_key ) {
			return $_null; // don't interfere with locale
		}

		$object = $this->get_object( $object_type, $object_id );

		if ( empty( $object_id ) || empty( $object ) ) {
			return $_null;
		}

		$no_conflict = pods_no_conflict_check( $meta_type );

		if ( ! $no_conflict ) {
			pods_no_conflict_on( $meta_type );
		}

		$meta_cache = array();

		if ( ! $single && isset( $GLOBALS['wp_object_cache'] ) && is_object( $GLOBALS['wp_object_cache'] ) ) {
			$meta_cache = wp_cache_get( $object_id, 'pods_' . $meta_type . '_meta' );

			if ( empty( $meta_cache ) ) {
				$meta_cache = wp_cache_get( $object_id, $meta_type . '_meta' );

				if ( empty( $meta_cache ) ) {
					$meta_cache = update_meta_cache( $meta_type, array( $object_id ) );
					$meta_cache = $meta_cache[ $object_id ];
				}
			}
		}

		if ( empty( $meta_cache ) || ! is_array( $meta_cache ) ) {
			$meta_cache = array();
		}

		if ( ! is_object( self::$current_field_pod ) || self::$current_field_pod->pod != $object['name'] ) {
			self::$current_field_pod = pods( $object['name'], $object_id );
		} elseif ( self::$current_field_pod->id() != $object_id ) {
			self::$current_field_pod->fetch( $object_id );
		}

		$pod = self::$current_field_pod;

		$meta_keys = array( $meta_key );

		if ( empty( $meta_key ) ) {
			$meta_keys = array_keys( $meta_cache );
		}

		$key_found = false;

		foreach ( $meta_keys as $meta_k ) {
			if ( ! empty( $pod ) ) {
				if ( isset( $pod->fields[ $meta_k ] ) ) {
					$key_found = true;

					$meta_cache[ $meta_k ] = $pod->field( array(
						'name'     => $meta_k,
						'single'   => $single,
						'get_meta' => true
					) );

					if ( ( ! is_array( $meta_cache[ $meta_k ] ) || ! isset( $meta_cache[ $meta_k ][0] ) ) ) {
						if ( empty( $meta_cache[ $meta_k ] ) && ! is_array( $meta_cache[ $meta_k ] ) && $single ) {
							$meta_cache[ $meta_k ] = array();
						} else {
							$meta_cache[ $meta_k ] = array( $meta_cache[ $meta_k ] );
						}
					}

					if ( in_array( $pod->fields[ $meta_k ]['type'], PodsForm::tableless_field_types() ) && isset( $meta_cache[ '_pods_' . $meta_k ] ) ) {
						unset( $meta_cache[ '_pods_' . $meta_k ] );
					}
				} elseif ( false !== strpos( $meta_k, '.' ) ) {
					$key_found = true;

					$first = current( explode( '.', $meta_k ) );

					if ( isset( $pod->fields[ $first ] ) ) {
						$meta_cache[ $meta_k ] = $pod->field( array(
							'name'     => $meta_k,
							'single'   => $single,
							'get_meta' => true
						) );

						if ( ( ! is_array( $meta_cache[ $meta_k ] ) || ! isset( $meta_cache[ $meta_k ][0] ) ) && $single ) {
							if ( empty( $meta_cache[ $meta_k ] ) && ! is_array( $meta_cache[ $meta_k ] ) && $single ) {
								$meta_cache[ $meta_k ] = array();
							} else {
								$meta_cache[ $meta_k ] = array( $meta_cache[ $meta_k ] );
							}
						}

						if ( in_array( $pod->fields[ $first ]['type'], PodsForm::tableless_field_types() ) && isset( $meta_cache[ '_pods_' . $first ] ) ) {
							unset( $meta_cache[ '_pods_' . $first ] );
						}
					}
				}
			}
		}

		if ( ! $no_conflict ) {
			pods_no_conflict_off( $meta_type );
		}

		unset( $pod ); // memory clear

		if ( ! $key_found ) {
			return $_null;
		}

		if ( ! $single && isset( $GLOBALS['wp_object_cache'] ) && is_object( $GLOBALS['wp_object_cache'] ) ) {
			wp_cache_set( $object_id, $meta_cache, 'pods_' . $meta_type . '_meta' );
		}

		if ( empty( $meta_key ) ) {
			return $meta_cache;
		} elseif ( isset( $meta_cache[ $meta_key ] ) ) {
			$value = $meta_cache[ $meta_key ];
		} else {
			$value = '';
		}

		if ( ! is_numeric( $value ) && empty( $value ) ) {
			if ( $single ) {
				$value = '';
			} else {
				$value = array();
			}
		} // get_metadata requires $meta[ 0 ] to be set for first value to be retrieved
		elseif ( ! is_array( $value ) ) {
			$value = array( $value );
		}

		return $value;
	}
111189
public function auto_pods() {

		/**
		 * Filter to override all settings for which templates are used.
		 *
		 * Note: If this filter does not return null, all back-end settings are ignored. To add to settings with a filter, use 'pods_pfat_auto_pods';
		 *
		 * @param array $auto_pods Array of parameters to use instead of those from settings.
		 *
		 * @return array Settings arrays for each post type.
		 *
		 * @since 2.4.5
		 */
		$auto_pods = apply_filters( 'pods_pfat_auto_pods_override', null );
		if ( ! is_null( $auto_pods ) ) {
			return $auto_pods;
		}

		// try to get cached results of this method
		$key       = '_pods_pfat_auto_pods';
		$auto_pods = pods_transient_get( $key );

		// check if we already have the results cached & use it if we can.
		if ( $auto_pods === false ) {
			// get possible pods
			$the_pods = $this->the_pods();

			// start output array empty
			$auto_pods = array();

			// get pods api class
			$api = pods_api();

			// loop through each to see if auto templates is enabled
			foreach ( $the_pods as $the_pod => $the_pod_label ) {
				// get this Pods' data.
				$pod_data = $api->load_pod( array( 'name' => $the_pod ) );

				// if auto template is enabled add info about Pod to array
				if ( 1 == pods_v( 'pfat_enable', $pod_data['options'] ) ) {
					// check if pfat_single and pfat_archive are set
					$single           = pods_v( 'pfat_single', $pod_data['options'], false, true );
					$archive          = pods_v( 'pfat_archive', $pod_data['options'], false, true );
					$single_append    = pods_v( 'pfat_append_single', $pod_data['options'], true, true );
					$archive_append   = pods_v( 'pfat_append_archive', $pod_data['options'], true, true );
					$single_filter    = pods_v( 'pfat_filter_single', $pod_data['options'], 'the_content', true );
					$archive_filter   = pods_v( 'pfat_filter_archive', $pod_data['options'], 'the_content', true );
					$run_outside_loop = pods_v( 'pfat_run_outside_loop', $pod_data['options'], false, true );
					$type             = pods_v( 'type', $pod_data, false, true );
					// check if it's a post type that has an archive
					if ( $type === 'post_type' && $the_pod !== 'post' || $the_pod !== 'page' ) {
						$has_archive = pods_v( 'has_archive', $pod_data['options'], false, true );
					} else {
						$has_archive = true;
					}

					if ( empty( $single_filter ) ) {
						$single_filter = 'the_content';
					}

					if ( empty( $archive_filter ) ) {
						$archive_filter = 'the_content';
					}

					// build output array
					$auto_pods[ $the_pod ] = array(
						'name'             => $the_pod,
						'label'            => $the_pod_label,
						'single'           => $single,
						'archive'          => $archive,
						'single_append'    => $single_append,
						'archive_append'   => $archive_append,
						'has_archive'      => $has_archive,
						'single_filter'    => $single_filter,
						'archive_filter'   => $archive_filter,
						'run_outside_loop' => $run_outside_loop,
						'type'             => $type,
					);
				}//end if
			}//end foreach

			// cache the results
			pods_transient_set( $key, $auto_pods );
		}//end if

		/**
		 * Add to or change settings.
		 *
		 * Use this filter to change or add to the settings set in the back-end for this plugin. Has no effect if 'pods_pfat_auto_pods_override' filter is being used.
		 *
		 * @param array $auto_pods Array of parameters to use instead of those from settings.
		 *
		 * @return array Settings arrays for each post type.
		 *
		 * @since 2.4.5
		 */
		$auto_pods = apply_filters( 'pods_pfat_auto_pods', $auto_pods );

		return $auto_pods;

	}
1105136
public function getSchema()
    {
        $result = null;

        if ($this->isConnected()){
            $result = $this->getAdapter()->getTableSchema($this->getBase());
        }

        return $result;
    }
479792
public function register( $type, $pod ) {

		$pod_type = $type;

		if ( 'post_type' == $type ) {
			$type = 'post_types';
		} elseif ( 'taxonomy' == $type ) {
			$type = 'taxonomies';
		} elseif ( 'pod' == $type ) {
			$type = 'advanced_content_types';
		}

		if ( ! isset( self::$queue[ $type ] ) ) {
			self::$queue[ $type ] = array();
		}

		if ( is_array( $pod ) && ! empty( $pod ) && ! isset( $pod['name'] ) ) {
			$data = array();

			foreach ( $pod as $p ) {
				$data[] = $this->register( $type, $p );
			}

			return $data;
		}

		$pod['type'] = $pod_type;
		$pod         = pods_api()->save_pod( $pod, false, false );

		if ( ! empty( $pod ) ) {
			self::$object_identifier --;

			self::$queue[ $type ][ $pod['name'] ] = $pod;

			return $pod;
		}

		return false;
	}
501364
public function getMetadata($key = null)
    {
        if (!$key) {
            return $this['metadata'];
        }

        if (isset($this->definition['metadata'][$key])) {
            return $this->definition['metadata'][$key];
        }

        return null;
    }
1359116
protected function NextItem()
	{
		/**
		 * @var \XBRL $taxonomy
		 */
		$taxonomy = $this->context->xbrlTaxonomy;

		$memberPathPartsCount = count( explode( "/", $this->memberPath ) );

		while ( true )
		{
			if ( is_null( $this->candidates ) || ! is_array( $this->candidates ) || $this->index >= count( $this->candidates ) )
			{
				return null;
			}

			$candidaterPath = $this->candidates[ $this->index++ ];
			$candidaterPathParts = explode( "/", $candidaterPath );

			if ( $this->axis == "DRS-child" )
			{
				// The member at the index can only be child.
				// That is, the count of parts can only be the same as $memberPathPartsCount or just one greater
				if ( count( $candidaterPathParts ) > $memberPathPartsCount + 1 )
				{
					continue;
				}
			}

			$member = $candidaterPathParts[ count( $candidaterPathParts ) - 1 ];
			$memTaxonomy = $taxonomy->getTaxonomyForXSD( $member );
			$memberId = trim( strrchr( $member, "#"), "#" );
			$memElement = $memTaxonomy->getElementById( $memberId );
			$result = QNameValue::fromNCName( "{$memTaxonomy->getPrefix()}:{$memElement['name']}", $this->context->NamespaceManager );

			return $result;

		}

		return null;
	}
378124
public function info(String $info = NULL)
    {
        if( ! empty($_FILES[$this->file]) )
        {
            $datas = 
            [
                'name'       => $_FILES[$this->file]['name'],
                'type'       => $_FILES[$this->file]['type'],
                'size'       => $_FILES[$this->file]['size'],
                'tmpName'    => $_FILES[$this->file]['tmp_name'],
                'error'      => $_FILES[$this->file]['error'],
                'path'       => $this->path,
                'encodeName' => $this->encodeName
            ];

            $values = [];

            if( ! is_array($_FILES[$this->file]['name']) ) foreach( $datas as $key => $val )
            {
                $values[$key] = $val;
            }
            else
            {
                foreach( $datas as $key => $val )
                {
                    if( ! empty($datas[$key]) )
                    {
                        foreach( (array) $datas[$key] as $v )
                        {
                            $values[$key][] = $v;
                        }
                    }
                }
            }
        }
        else
        {
            return false;
        }

        if( ! empty($values[$info]) )
        {
            return $values[$info];
        }

        return (object) $values;
    }