Returns saved only references (allowed by specs).

@param identifier
String
@return List of PropertyImpl
@throws RepositoryException
if error

@see javax.jcr.Node#getReferences
516163
public List<PropertyImpl> getReferences(String identifier) throws RepositoryException
   {
      List<PropertyData> refDatas = transactionableManager.getReferencesData(identifier, true);
      List<PropertyImpl> refs = new ArrayList<PropertyImpl>(refDatas.size());
      for (int i = 0, length = refDatas.size(); i < length; i++)
      {
         PropertyData data = refDatas.get(i);
         ItemState state = changesLog.getItemState(data.getIdentifier());
         if (state != null)
         {
            if (state.isDeleted())
            {
               // if the Property was deleted skip it for now
               continue;
            }

            // otherwise use transient data
            data = (PropertyData)state.getData();
         }

         NodeData parent = (NodeData)getItemData(data.getParentIdentifier());
         // if parent exists check for read permissions, otherwise the parent was deleted in another session.
         if (parent != null)
         {
            // skip not permitted
            if (accessManager.hasPermission(parent.getACL(), new String[]{PermissionType.READ}, session.getUserState()
               .getIdentity()))
            {
               PropertyImpl item = (PropertyImpl)readItem(data, parent, true, false);

               refs.add(item);
               session.getActionHandler().postRead(item);
            }
         }
      }
      return refs;
   }
1191044
public PropertyDefinitionDatas getPropertyDefinitions(final InternalQName propertyName,
      final InternalQName... nodeTypeNames) throws RepositoryException
   {

      PropertyDefinitionDatas propertyDefinitions =
         this.nodeTypeRepository.getPropertyDefinitions(propertyName, nodeTypeNames);

      // Try super
      if (propertyDefinitions == null)
      {
         for (int i = 0; i < nodeTypeNames.length && propertyDefinitions == null; i++)
         {
            final InternalQName[] supers =
               this.nodeTypeRepository.getNodeType(nodeTypeNames[i]).getDeclaredSupertypeNames();
            propertyDefinitions = getPropertyDefinitions(propertyName, supers);

         }
      }

      // try residual def
      if (propertyDefinitions == null && !propertyName.equals(Constants.JCR_ANY_NAME))
      {
         propertyDefinitions = getPropertyDefinitions(Constants.JCR_ANY_NAME, nodeTypeNames);
      }

      return propertyDefinitions;
   }
699893
public static List<RepositoryDefinition> getRepositoryDefinitions() {
        if (null == repositoryDefinitions) {
            try {
                initRepositoryDefinitions();
            } catch (final Exception e) {
                LOGGER.log(Level.ERROR, "Init repository definitions failed", e);
            }
        }

        return repositoryDefinitions;
    }
179359
public List getObjectReferenceDescriptors(boolean withInherited)
    {
        if(withInherited && getSuperClassDescriptor() != null)
        {
            List result = new ArrayList(m_ObjectReferenceDescriptors);
            result.addAll(getSuperClassDescriptor().getObjectReferenceDescriptors(true));
            return result;
        }
        else
        {
            return m_ObjectReferenceDescriptors;
        }
    }
376525
@Override
    public String getExternalIdentifier() {
        try {
            LOGGER.debug("getExternalIdentifier for property {} ", property().getName());
            return property().getValue().getString();
        } catch (final RepositoryException e) {
            throw new RepositoryRuntimeException(e);
        }
    }
1069435
public function readScopeIdentifiers(string $identifier): array
    {
        try {
            $schema = $this->getDatabaseSchema();
            return $this->readBelongsToManyRelationshipIdentifiers(
                $identifier,
                $schema->getClientsScopesTable(),
                $schema->getClientsScopesClientIdentityColumn(),
                $schema->getClientsScopesScopeIdentityColumn()
            );
        } catch (RepositoryException $exception) {
            $message = 'Reading client scope identifiers failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
727399
@Programmatic
    public DocumentType findByReference(
            final String reference) {
        return queryResultsCache.execute(
                () -> repositoryService.firstMatch(
                    new QueryDefault<>(DocumentType.class,
                            "findByReference",
                            "reference", reference)),
                DocumentTypeRepository.class,
                "findByReference", reference);

    }
467579
@Override
    public ITypedReferenceableInstance getEntityDefinition(String guid) throws AtlasException {
        guid = ParamChecker.notEmpty(guid, "entity id");

        final ITypedReferenceableInstance instance = repository.getEntityDefinition(guid);
        return instance;
    }
906978
public Entity getEntity_ref() {
    if (EntityMention_Type.featOkTst && ((EntityMention_Type)jcasType).casFeat_entity_ref == null)
      jcasType.jcas.throwFeatMissing("entity_ref", "de.julielab.jules.types.ace.EntityMention");
    return (Entity)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((EntityMention_Type)jcasType).casFeatCode_entity_ref)));}
347845
public List<BeanId> getReference(final String propertyName) {
        List<BeanId> values = references.get(propertyName);
        if (values == null) {
            return null;
        }
        return values;
    }
991732
public static Reference getReference(Serializable object) throws NamingException
    {
        ByteArrayOutputStream outStream;
        try
        {
            outStream = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(outStream);
            out.writeObject(object);
            out.close();
        }
        catch (IOException e)
        {
            throw new NamingException(e.getMessage());
        }

        BinaryRefAddr handle = new BinaryRefAddr("com.impetus.kundera.persistence.jta", outStream.toByteArray());
        Reference ret = new Reference(object.getClass().getName(), handle, UserTransactionFactory.class.getName(), null);
        return ret;
    }
1307865
public Collection<HierarchicalProperty> getProperties(String name) throws RepositoryException
   {

      ArrayList<HierarchicalProperty> props = new ArrayList<HierarchicalProperty>();
      if ("jcr:primaryType".equals(name) || "jcr:mixinTypes".equals(name))
         return null;

      if (content != null && content.getProperty(name) != null)
      {
         props.addAll(content.getProperties(name));
      }

      try
      {
         String ns = ((ExtendedSession)node.getSession()).getLocationFactory().parseJCRName(name).getNamespace();
         Property p = node.getProperty(name);
         if (p.getDefinition().isMultiple())
         {
            Value[] v = p.getValues();
            for (int i = 0; i < v.length; i++)
            {
               props.add(new HierarchicalProperty(name, v[i].getString(), ns));
            }
         }
         else
         {
            props.add(new HierarchicalProperty(name, p.getString(), ns));
         }

         //      PropertyIterator iter = node.getProperties(name);
         //      while (iter.hasNext()) {
         //        Property prop = iter.nextProperty();
         //        props.add(new HierarchicalProperty(name, prop.getString(), ns));
         //      }
      }
      catch (PathNotFoundException e)
      {
         if (LOG.isTraceEnabled())
         {
            LOG.trace("An exception occurred: " + e.getMessage());
         }
      }
      return props;
   }
433161
public function readRedirectUriStrings(string $identifier): array
    {
        try {
            $schema = $this->getDatabaseSchema();
            return $this->readHasManyRelationshipColumn(
                $identifier,
                $schema->getRedirectUrisTable(),
                $schema->getRedirectUrisValueColumn(),
                $schema->getRedirectUrisClientIdentityColumn()
            );
        } catch (RepositoryException $exception) {
            $message = 'Reading client redirect URIs failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
692920
public static List<FieldDefinition> getKeys(final String repositoryName) {
        final List<RepositoryDefinition> repositoryDefs = getRepositoryDefinitions();
        for (final RepositoryDefinition repositoryDefinition : repositoryDefs) {
            if (StringUtils.equals(repositoryName, repositoryDefinition.getName())) {
                return repositoryDefinition.getKeys();
            }
        }

        return null;
    }
661221
private Object getReferencedEntity(int propertyIndex) {
		Object referencedEntity = null;

		GridType propertyType = persister.getGridPropertyTypes()[propertyIndex];
		Serializable id = (Serializable) propertyType.hydrate(
				resultset, persister.getPropertyColumnNames( propertyIndex ), session, null
		);

		if ( id != null ) {
			EntityPersister hostingEntityPersister = session.getFactory().getMetamodel().entityPersister(
					propertyType.getReturnedClass()
			);

			// OGM-931 Loading the entity through Session#get() to make sure it is fetched from the store if it is
			// detached atm. but also to benefit from 2L caching etc.
			Class<?> entityType = hostingEntityPersister.getMappedClass();
			referencedEntity = ( (Session) session ).get( entityType, id );

			// In case the entity is scheduled for deletion, obtain it from the PC
			if ( referencedEntity == null ) {
				referencedEntity = session.getPersistenceContext().getEntity(
					session.generateEntityKey( id, hostingEntityPersister )
				);
			}
		}

		return referencedEntity;
	}
810291
public ReferenceSpec[] referencesTo(EntitySpec entitySpec) {
        if (entitySpec == null) {
            throw new IllegalArgumentException("entitySpec cannot be null");
        }

        List<ReferenceSpec> result = new ArrayList<>();
        String entitySpecName = entitySpec.name;
        for (ReferenceSpec refSpec : this.referenceSpecs) {
            if (refSpec.getEntityName().equals(entitySpecName)) {
                result.add(refSpec);
            }
        }
        return result.toArray(new ReferenceSpec[result.size()]);
    }
1206504
public List<NodeDataIndexing> getNodesAndProperties(String lastNodeId, int offset, int limit)
      throws RepositoryException, IllegalStateException
   {
      List<NodeDataIndexing> result = new ArrayList<NodeDataIndexing>();

      checkIfOpened();
      try
      {
         startTxIfNeeded();
         ResultSet resultSet = findNodesAndProperties(lastNodeId, offset, limit);
         int processed = 0;

         try
         {
            TempNodeData tempNodeData = null;

            while (resultSet.next())
            {
               if (tempNodeData == null)
               {
                  tempNodeData = new TempNodeData(resultSet);
                  processed++;
               }
               else if (!resultSet.getString(COLUMN_ID).equals(tempNodeData.cid))
               {
                  if (!needToSkipOffsetNodes() || processed > offset)
                  {
                     result.add(createNodeDataIndexing(tempNodeData));
                  }

                  tempNodeData = new TempNodeData(resultSet);
                  processed++;
               }

               if (!needToSkipOffsetNodes() || processed > offset)
               {
                  String key = resultSet.getString("P_NAME");

                  SortedSet<TempPropertyData> values = tempNodeData.properties.get(key);
                  if (values == null)
                  {
                     values = new TreeSet<TempPropertyData>();
                     tempNodeData.properties.put(key, values);
                  }

                  values.add(new ExtendedTempPropertyData(resultSet));
               }
            }

            if (tempNodeData != null && (!needToSkipOffsetNodes() || processed > offset))
            {
               result.add(createNodeDataIndexing(tempNodeData));
            }
         }
         finally
         {
            try
            {
               resultSet.close();
            }
            catch (SQLException e)
            {
               LOG.error("Can't close the ResultSet: " + e.getMessage());
            }
         }
      }
      catch (IOException e)
      {
         throw new RepositoryException(e);
      }
      catch (IllegalNameException e)
      {
         throw new RepositoryException(e);
      }
      catch (SQLException e)
      {
         throw new RepositoryException(e);
      }
      if (LOG.isTraceEnabled())
      {
         LOG.trace("getNodesAndProperties(%s, %s, %s) = %s elements", lastNodeId, offset, limit, result.size());
      }

      return result;
   }