Return a reference to the globals to be documented.

@return FieldDoc[]
166682
function &globals()
    {
        $globals = array();
        $packages = $this->packages(); // not by reference so as not to move the internal array pointer
        foreach ($packages as $name => $package) {
            $packageGlobals = $this->_packages[$name]->globals(); // not by reference so as not to move the internal array pointer
            if ($packageGlobals) {
                foreach ($packageGlobals as $key => $pack) {
                    $globals[$name.'.'.$key] =& $packageGlobals[$key];
                }
            }
        }
        ksort($globals);

        return $globals;
    }
1065628
def get_globals(self):
        """"""
        if self.shell:
            globals_ = dict(_initial_globals)
        else:
            globals_ = dict(self.current_frame.f_globals)
        globals_['_'] = self.db.last_obj
        if cut is not None:
            globals_.setdefault('cut', cut)
        # For meta debuging purpose
        globals_['___wdb'] = self.db
        # Hack for function scope eval
        globals_.update(self.current_locals)
        for var, val in self.db.extra_vars.items():
            globals_[var] = val
        self.db.extra_items = {}
        return globals_
193009
public function primaryFields()
    {
        $result = [];
        foreach ($this->indexes as $index) {
            if (!$index->isPrimary()) {
                continue;
            }

            foreach ($index->fields() as $field) {
                $result[] = $this->field($field);
            }
        }

        return $result;
    }
1187344
protected function getStaticFields()
	{
		$fields = [];
		foreach ($this->info as $info)
		{
			if (is_array($info))
			{
				foreach ($info as $value)
				{
					if ($value instanceof AbstractDto)
					{
						$fields += $value->getStaticFields();
					}
				}
			}
			if ($info instanceof AbstractDto)
			{
				$fields += $info->getStaticFields();
			}
		}

		return $fields;
	}
1264990
public function getAllCodeFields()
    {
        static $fields = false; // Using static so it will be refreshed once per request

        if ($fields === false) {
            $fields = array();
            $model  = $this->createTrackClass('Model\\FieldMaintenanceModel');
            $rows   = $model->load(array('gtf_field_code IS NOT NULL'), array('gtf_field_code' => SORT_ASC));

            if ($rows) {
                foreach ($rows as $row) {
                    $key = FieldsDefinition::makeKey($row['sub'], $row['gtf_id_field']);
                    $fields[$key] = $row['gtf_field_code'];
                }
            }
        }

        return $fields;
    }
410092
public function getExtendedFields()
    {
        $result = [];
        $fields = $this->getEntities(
            [
                'filter'         => [
                    'where' => [
                        [
                            'expr' => 'orX',
                            'val'  => [
                                ['column' => 'f.object', 'expr' => 'eq', 'value' => 'extendedField'],
                                ['column' => 'f.object', 'expr' => 'eq', 'value' => 'extendedFieldSecure'],
                            ],
                        ],
                    ],
                ],
                'hydration_mode' => 'HYDRATE_ARRAY',
            ]
        );
        foreach ($fields as $field) {
            $result[$field['alias']] = $field;
        }

        return $result;
    }
141652
public function getGlobals() {
		$globals = [
			'post' => get_post( get_the_ID() )
		];

		/**
		 * Modify globals or add custom.
		 *
		 * @param array $globals
		 */
		$globals = apply_filters( 'digster/globals', $globals );
		$globals = is_array( $globals ) ? $globals : [];

		return $globals;
	}
544046
public function getAll() : array
    {
        $fieldOptions = call_user_func($this->fieldOptionsLoader);
        TypeMismatchException::verifyAllInstanceOf(__METHOD__, '<return>', $fieldOptions, IFieldOption::class);
        return $fieldOptions;
    }
184504
public function getCMSFields()
    {
        $fields = parent::getCMSFields();
        $fields->addFieldsToTab(
            'Root.Main',
            array(
                CurrencySelectField::create(
                    'CurrenciesAccepted',
                    _t('SchemaLocalBusiness.CURRENCIESACCEPTED', 'Currencies accepted')
                ),
                TextField::create(
                    'PaymentAccepted',
                    _t('SchemaLocalBusiness.PAYMENTACCEPTED', 'Payment accepted')
                ),
                TextField::create(
                    'PriceRange',
                    _t('SchemaLocalBusiness.PRICERANGE', 'Price range')
                ),
                TextField::create(
                    'OpenHours',
                    _t('SchemaLocalBusiness.OPENHOURS', 'Open hours')
                )
            )
        );
        return $fields;
    }
366490
protected function getFieldsAsArrays()
    {
        $fields = [];

        foreach ($this->getFields() as $field) {
            $fields[] = $field->toArray();
        }

        return $fields;
    }
772120
public function getFieldNames()
    {
        $names = [];

        for ($i = 0; $i < $this->countFields(); $i++) {
            $names[] = $this->getFieldName($i);
        }

        return $names;
    }
461955
public function getFieldsConfig()
    {
        if (null === $this->fieldsConfigList) {
            $this->fieldsConfigList = [];

            foreach ($this->getFields() as $field) {
                $reflectionProperty = $this->getReflector()->getProperty($field);
                $docBlock = $reflectionProperty->getDocComment();
                preg_match('/@var\s([a-z]*).*/', $docBlock, $matches);

                $this->fieldsConfigList[$field] = [
                    'type' => isset($matches[1]) ? $matches[1] : null
                ];
            }

        }

        return $this->fieldsConfigList;
    }
645847
protected function getDefaultFields(): array
    {
        $result = [];
        $types = Options::getBasicSearchFieldTypes();

        foreach ($this->searchFields as $field => $properties) {
            if (in_array($properties['type'], $types)) {
                $result[] = $field;
            }
        }

        return $result;
    }
792270
public function getFieldTypeCallbacks()
    {
        $types = array();

        $numFields = $this->numFields();
        for( $i = 0; $i < $numFields; $i++ ) {
            $types[pg_field_name( $this->resource, $i )] = TypeConversionFactory::get(
                pg_field_type( $this->resource, $i ),
                $this
            );
        }

        return $types;
    }
1212150
public function getFieldsTranslations()
    {
        $fieldList = parent::getFieldsTranslations();

        // Add the key values (so organization id is present)
        $keys = array_combine(array_values($this->_targetModel->getKeys()), array_values($this->_targetModel->getKeys()));
        $fieldList = $fieldList + $keys;

        $fieldList['grs_email'] = 'gr2o_email';

        return $fieldList;
    }
1187120
private function getFieldsForEdit() {
        global $editors, $field_editors, $translator;
        
        if ($this->fields_def) return;
		
		ob_start();
        
        $fields = $this->objectDefinition->getFields($this->catalog);
        
        $this->fields_def = array();   
        
        foreach ($fields as $id => $f) {         

            if (!$f['shw'] &&  $f['name'] != 'alias') continue;
    
            $this->fields_def[$id] = $f;
          
        	$_editor = (int)$f['editor'];
          
        	if ($f['pseudo_type']) 
                $f['type'] = $f['pseudo_type'];
              
        	if (isset($editors[EDITOR_HIDDEN])) 
                $this->fields_def[$id]['editor_str'] = $editors[EDITOR_HIDDEN];
              
        	if (is_array($field_editors[$f['type']])) {
          
        	    if (!in_array($_editor, $field_editors[$f['type']])) 
        			   $_editor = $field_editors[$f['type']][0];
                 
        		  if ($_editor == EDITOR_USER) {
        		      if (file_exists(PLUGIN_MATH_DIR.'/'.$f['editor_user'].'.php')) {
        				      $this->fields_def[$id]['editor_str'] = $f['editor_user'];
        				      include_once(PLUGIN_MATH_DIR.'/'.$f['editor_user'].'.php');	        
        		      } 
					  else {
						  $_editor = $field_editors[$f['type']][0];
					  }
        	    }
        
            	if ( isset($editors[$_editor]) ) {
            	    $this->fields_def[$id]['editor_str'] = $editors[$_editor];
            	    if ( file_exists('editors/'.$editors[$_editor].'.php') ) 
                        include_once('editors/'.$this->fields_def[$id]['editor_str'].'.php');
            	}
        	}
        }
		
		$this->initData = ob_get_contents();
		ob_end_clean();		
    }
1030528
public function getFlattenedFields()
    {
        if (!isset($this->flatFields)) {
            $this->flatFields = [];

            foreach ($this->fields as $field) {
                if (isset($field['fields']) && is_array($field['fields'])) {
                    $this->flatFields += $this->flattenCollection($field);
                } else {
                    $this->flatFields[$field['name']] = $field;
                }
            }
        }

        return $this->flatFields;
    }