Returns a map associating the annotation title to an array of objects representing the annotation.

@var array("annotationClass"=>array($annotationObjects))
427042
public function getAllAnnotations() {
		$retArray = array();
		if (!$this->annotationsArrayAsString) {
			return array();
		}
		foreach ($this->annotationsArrayAsString as $key=>$value) {
			$retArray[$key] = $this->getAnnotations($key);
		}
		return $retArray;
	}
1088612
private function getReferenceMapping() : array
    {
        $this->requiresCurrentField();
        assert($this->currentField !== null);

        try {
            return $this->class->getFieldMapping($this->currentField);
        } catch (MappingException $e) {
            if (empty($this->class->discriminatorMap)) {
                throw $e;
            }
            $mapping = null;
            $foundIn = null;
            foreach ($this->class->discriminatorMap as $child) {
                $childClass = $this->dm->getClassMetadata($child);
                if (! $childClass->hasAssociation($this->currentField)) {
                    continue;
                }

                if ($foundIn !== null && $mapping !== null && $mapping !== $childClass->getFieldMapping($this->currentField)) {
                    throw MappingException::referenceFieldConflict($this->currentField, $foundIn->name, $childClass->name);
                }
                $mapping = $childClass->getFieldMapping($this->currentField);
                $foundIn = $childClass;
            }
            if ($mapping === null) {
                throw MappingException::mappingNotFoundInClassNorDescendants($this->class->name, $this->currentField);
            }

            return $mapping;
        }
    }
787527
public function asArray()
    {
        $array = [];
        $properties = (new \ReflectionClass($this))
            ->getProperties(ReflectionProperty::IS_PUBLIC);

        foreach ($properties as $object) {
            $value = $object->getValue($this);
            if (!isset($value)) {
                continue;
            }
            $property = $object->getName();

            if (!empty($this->mappings)
                && isset($this->mappings[$property])) {
                $property = $this->mappings[$property];
            }

            $array[$property] = $value;
        }

        return new \ArrayIterator($array);
    }
1299765
protected function loadClassAnnotations()
    {
        if (empty($this->targetClass)) {
            throw new \RuntimeException("Runtime Error: Any class was defined as target to annotations handling.");
        }

        $annotationsObjects = array();
        $this->annotations['_class_'] = $this->getClassAnnotationsObjects($this->targetClass);
    }
415443
public function toArray()
    {
        $attribute_values = [ self::OBJECT_TYPE => $this->getType()->getPrefix() ];

        foreach ($this->value_holder_map as $attribute_name => $value_holder) {
            $attribute_value = $value_holder->getValue();

            if (is_object($attribute_value) && is_callable([ $attribute_value, 'toArray' ])) {
                $attribute_values[$attribute_name] = $attribute_value->toArray();
            } else {
                $attribute_values[$attribute_name] = $value_holder->toNative();
            }
        }

        return $attribute_values;
    }
147554
public function getAdapterAlias()
    {
        if ('__undefined__' == $this->adapterAlias) {
            $this->adapterAlias = null;
            $annotations = $this->inspector->getClassAnnotations();
            if ($annotations->hasAnnotation('@adapter')) {
                $this->adapterAlias = $annotations
                    ->getAnnotation('@adapter')
                    ->getValue();
            }
        }
        return $this->adapterAlias;
    }
359951
function dataMap()
    {
        // Retrieve the indexed information collection attributes
        $informationCollectionAttributes = $this->informationCollectionAttributes();

        $retArray = array();

        // Loop through each attribute hashing the array with the
        // class attribute identifier associated with the information
        // collection attribute
        foreach ( $informationCollectionAttributes as $informationAttribute )
        {
            $contentClassAttribute = $informationAttribute->attribute( 'contentclass_attribute' );
            $id = $contentClassAttribute->attribute( 'identifier' );
            $retArray[$id] = $informationAttribute;
        }

        return $retArray;
    }
1336450
public static function getPropertyMap()
    {
        if (self::$property_map !== null) {
            return self::$property_map;
        }

        /** @var array<string, array<string, string>> */
        $property_map = require_once(__DIR__ . '/../PropertyMap.php');

        self::$property_map = [];

        foreach ($property_map as $key => $value) {
            $cased_key = strtolower($key);
            self::$property_map[$cased_key] = $value;
        }

        return self::$property_map;
    }
379115
public function toJson() {
    	$result = array();
    	$result['name'] = $this->getName();
    	$result['comment'] = $this->getMoufPhpDocComment()->getJsonArray();
    	
    	/*$properties = $this->getAnnotations("Property");
    		if (!empty($properties)) {
    	$result['moufProperty'] = true;*/
    	
    	try {
    		$result['default'] = $this->getDefault();
    		
	    	// TODO: is there a need to instanciate a  MoufPropertyDescriptor?
	    	$moufPropertyDescriptor = new MoufPropertyDescriptor($this);
	    	$types = $moufPropertyDescriptor->getTypes();
	    	$result['types'] = $types->toJson();
	    	 
	    	if ($types->getWarningMessage()) {
	    		$result['classinerror'] = $types->getWarningMessage();
	    	}
	    		    	
    	} catch (\Exception $e) {
    		$result['classinerror'] = $e->getMessage();
    	}
    	/*if ($moufPropertyDescriptor->isAssociativeArray()) {
    		$result['keytype'] = $moufPropertyDescriptor->getKeyType();
    	}
    	if ($moufPropertyDescriptor->isArray()) {
    		$result['subtype'] = $moufPropertyDescriptor->getSubType();
    	}*/
    	//}
    
    	return $result;
    }
716878
final public static function getAnnotation($object)
    {
        $funReflec = new FuncoesReflections();
        
        $output = array();
        
        $pattern = '/@+_+[A-z]\w+=\w+/';
        
        $fullComments = $funReflec->retornaComentariosAtributos($object);
        $attribuites   = $funReflec->pegaAtributosDoObjeto($object);
        
        $annotationsList = [];
        
        $limit    = count($attribuites);
        $iterator = 0;
        for ($iterator; $iterator < $limit; $iterator++) {
            
            preg_match_all(
                $pattern,
                $fullComments[$attribuites[$iterator]],
                $output
            );

            $annotationsList[ $attribuites[$iterator] ] = $output[0];
        }

        return $annotationsList;
    }
665464
public static function getClassAnnotations($className, $annotationClassName = null)
    {
        if(!isset(static::$annotations[$className]['Class']))
        {
            return [];
        }
        if(null === $annotationClassName)
        {
            return static::$annotations[$className]['Class'];
        }
        else
        {
            $result = [];
            foreach(static::$annotations[$className]['Class'] as $annotation)
            {
                if($annotation instanceof $annotationClassName)
                {
                    $result[] = $annotation;
                }
            }
            return $result;
        }
    }
1041060
private ObjectMapper getObjectMapper() {
		ObjectMapper mapper = new ObjectMapper();
		AnnotationIntrospector primary = new JacksonAnnotationIntrospector();
		AnnotationIntrospector secondary = new JaxbAnnotationIntrospector();
		AnnotationIntrospector pair = new AnnotationIntrospectorPair(primary, secondary);

		mapper.setAnnotationIntrospector(pair);
		mapper.setSerializationInclusion(Include.NON_NULL);

		return mapper;
	}
1305565
public function getClassMap()
    {
        $classMap   = new ClassMap();
        $duplicates = array();

        foreach ($this->validators as $validator) {
            $validatorName   = $validator->getName();
            $partialClassMap = $validator->getClassMap();
            foreach ($partialClassMap as $class => $file) {
                try {
                    $classMap->add($class, $file);
                    $duplicates[$class][$validatorName] = $file;
                } catch (ClassAlreadyRegisteredException $exception) {
                    $duplicates[$class][$validatorName] = $file;
                }
            }
        }

        foreach ($duplicates as $class => $files) {
            if (count($files) === 1) {
                continue;
            }
            $this->report->error(
                new ClassAddedMoreThanOnceViolation(
                    implode(', ', array_keys($files)),
                    $class,
                    $files
                )
            );
        }

        return $classMap;
    }
531274
public Annotation[] getAnnotations() {
		final XAnnotation<?>[] xannotations = getXAnnotations();
		final Annotation[] annotations = new Annotation[xannotations.length];
		for (int index = 0; index < xannotations.length; index++) {
			annotations[index] = xannotations[index].getResult();
		}
		return annotations;
	}
709153
public function getJSONObject()
    {
        $r = new \stdClass();
        $r->name = $this->getCollectionName() !== '' ? $this->getCollectionName() : t('(No Title)');
        if ($this->isAliasPage()) {
            $r->cID = $this->getCollectionPointerOriginalID();
        } else {
            $r->cID = $this->getCollectionID();
        }
        if ($this->isExternalLink()) {
            $r->url = $this->getCollectionPointerExternalLink();
        } else {
            $r->url = (string) $this->getCollectionLink();
        }

        return $r;
    }
281603
public function process() {
        $className = new $this->_annotation['class'];
        $class = new $className();

        foreach ($this->_annotation['properties'] as $property => $value) {
            $class->$property = $value;
        }

        return $class;
    }
25543
public function istantiateObjects()
    {
        $this->validateObjectClassName();

        $objects_iterator = new ArrayIterator;

        $this->appendObjectDataToIterator($objects_iterator);

        $this->objects_istantiated = $objects_iterator;
        return $this->objects_istantiated;
    }