How to use

GMLReference

in

org.deegree.commons.tom.gml

@Override
public String requireObject( GMLReference<?> ref, GmlXlinkOptions resolveState ) {
  if ( ref.isLocal() ) {
    return remoteXlinkTemplate.replace( "{}", ref.getId() );
  }
  return ref.getURI();
}

private boolean isResolvable( GMLReference<?> ref ) {
  try {
    ref.getReferencedObject();
    return true;
  } catch ( ReferenceResolvingException e ) {
    return false;
  }
}

/**
 * Resolves all local references that have been added before against the added objects.
 *
 * @throws ReferenceResolvingException
 *             if a local reference cannot be resolved
 */
public void resolveLocalRefs()
            throws ReferenceResolvingException {
  for ( GMLReference<?> ref : localRefs ) {
    String id = ref.getURI().substring( 1 );
    LOG.debug( "Resolving reference to object '" + id + "'" );
    if ( ref.getReferencedObject() == null ) {
      String msg = "Cannot resolve reference to object with id '" + id
             + "'. There is no object with this id in the document.";
      throw new ReferenceResolvingException( msg );
    }
  }
}

@Override
public String handleReference( GMLReference<?> ref ) {
  String uri = ref.getURI();
  LOG.debug( "Encountered reference to object {}.", uri );
  if ( !isGmlIdBasedUri( uri ) ) {
    LOG.debug( "Reference to object {} considered non-rewritable.", uri );
    return uri;
  }
  if ( localReferencesPossible ) {
    LOG.debug( "Exporting potential forward reference to object {} which may or may not be exported later.",
          ref.getURI() );
    try {
      xmlStream.activateBuffering();
    } catch ( XMLStreamException e ) {
      throw new RuntimeException( e.getMessage(), e );
    }
    return "{" + ref.getId() + "}";
  }
  LOG.debug( "Exporting reference to object {} as remote reference.", ref.getId() );
  return remoteXlinkTemplate.replace( "{}", ref.getId() );
}

@Override
public String requireObject( GMLReference<?> ref, GmlXlinkOptions resolveState ) {
  LOG.debug( "Exporting forward reference to object {} which must be included in the output.", ref.getId() );
  objectIdToRef.put( ref.getId(), ref );
  return "#" + ref.getId();
}

@Override
public String requireObject( GMLReference<?> ref, GmlXlinkOptions resolveState ) {
  String uri = ref.getURI();
  LOG.debug( "Exporting forward reference to object {} which must be included in the output.", uri );
  uriToRef.put( uri, ref );
  refToResolveState.put( ref, resolveState );
  return uri;
}

GMLReference<TimeSlice> refObject = null;
if ( specialResolver != null ) {
  refObject = new GMLReference<TimeSlice>( specialResolver, href, xmlStream.getSystemId() );
} else {
  refObject = new GMLReference<TimeSlice>( idContext, href, xmlStream.getSystemId() );

@Override
public String handleReference( GMLReference<?> ref ) {
  if ( localReferencesPossible ) {
    LOG.debug( "Exporting potential forward reference to object {} which may or may not be exported later.",
          ref.getId() );
    // try {
    // xmlStream.activateBuffering();
    // } catch ( XMLStreamException e ) {
    // throw new RuntimeException( e.getMessage(), e );
    // }
    return "{" + ref.getId() + "}";
  }
  LOG.debug( "Exporting reference to object {} as remote reference.", ref.getId() );
  return remoteXlinkTemplate.replace( "{}", ref.getId() );
}

/**
 * Adds a new {@link GMLReference} that has been encountered during the parsing of the GML document.
 *
 * @param ref
 *            GML reference, must not be <code>null</code>
 */
public void addReference( GMLReference<?> ref ) {
  refs.add( ref );
  if ( ref.getURI().startsWith( "#" ) ) {
    localRefs.add( ref );
  }
}

@Override
public String handleReference( GMLReference<?> ref ) {
  if ( ref.isLocal() ) {
    return remoteXlinkTemplate.replace( "{}", ref.getId() );
  }
  return ref.getURI();
}

@Override
public synchronized Feature getReferencedObject()
            throws ReferenceResolvingException {
  try {
    return super.getReferencedObject();
  } catch ( ReferenceResolvingException e ) {
    if ( internalResolver == null )
      throw e;
    return resolveInternalFeature( e );
  }
}

protected void writeAdditionalObjects( GMLStreamWriter gmlStream, WfsXlinkStrategy additionalObjects,
                    QName featureMemberEl, Version requestVersion )
            throws XMLStreamException, UnknownCRSException, TransformationException {
  Collection<GMLReference<?>> nextLevelObjects = additionalObjects.getAdditionalRefs();
  XMLStreamWriter xmlStream = gmlStream.getXMLStream();
  boolean wroteStartSection = false;
  while ( !nextLevelObjects.isEmpty() ) {
    Map<GMLReference<?>, GmlXlinkOptions> refToResolveState = additionalObjects.getResolveStates();
    additionalObjects.clear();
    for ( GMLReference<?> ref : nextLevelObjects ) {
      if ( isResolvable( ref ) && !isObjectAlreadySerialized( gmlStream, ref.getId() ) ) {
        GmlXlinkOptions resolveState = refToResolveState.get( ref );
        Feature feature = (Feature) ref;
        if ( !wroteStartSection ) {
          writeAdditionalObjectsStart( xmlStream, requestVersion );
          wroteStartSection = true;
        }
        writeMemberFeature( feature, gmlStream, xmlStream, resolveState, featureMemberEl );
      }
    }
    nextLevelObjects = additionalObjects.getAdditionalRefs();
  }
  if ( wroteStartSection ) {
    writeAdditionalObjectsEnd( xmlStream, requestVersion );
  }
}

  @Override
  public List<Property> getProperties( QName propName ) {
    return getReferencedObject().getProperties( propName );
  }
}

@Override
public GMLObjectType getType() {
  return getReferencedObject().getType();
}

@Override
public List<Property> getProperties() {
  return getReferencedObject().getProperties();
}