How to use

NCNameResourceCodec

in

org.geoserver.wcs2_0.util

/**
 * Returns the coverage backed by the provided datasetId
 *
 * @param datasetId
 * @return the coverage, or null if not found, or if not a coverage
 */
public CoverageInfo getDatasetCoverage(String datasetId) {
  if (!datasetId.endsWith(DATASET_SUFFIX)) {
    LOGGER.fine(
        "Invalid dataset id " + datasetId + " it does not end with " + DATASET_SUFFIX);
    return null;
  }
  String coverageName = datasetId.substring(0, datasetId.length() - DATASET_SUFFIX.length());
  LayerInfo layer = NCNameResourceCodec.getCoverage(catalog, coverageName);
  if (layer == null) {
    LOGGER.fine(
        "Invalid dataset id " + datasetId + " does not match any published dataset");
    return null;
  }
  CoverageInfo ci = (CoverageInfo) layer.getResource();
  if (!isValidDataset(ci)) {
    LOGGER.fine(
        "Invalid dataset id " + datasetId + " does not match any published dataset");
    return null;
  }
  return ci;
}

/** Builds the identifier for a granule inside a coverage */
public String getGranuleId(CoverageInfo coverage, String featureId) {
  return NCNameResourceCodec.encode(coverage) + GRANULE_SEPARATOR + featureId;
}

List<MapEntry<String, String>> decodedList = decode(encodedResourceId);
if (decodedList.isEmpty()) {
  LOGGER.info("Could not decode id '" + encodedResourceId + "'");

  LayerInfo layer = NCNameResourceCodec.getCoverage(catalog, newCoverageID);
  if (layer != null) {
    coverages.add((CoverageInfo) layer.getResource());
for (CoverageInfo ci : coverages) {
  try {
    String encodedId = NCNameResourceCodec.encode(ci);
    CoverageInfo ciNew = ci;
    String newCoverageID = covIds.get(coverageIndex);

public static LayerInfo getCoverage(Catalog catalog, String encodedCoverageId)
    throws WCS20Exception {
  List<LayerInfo> layers = NCNameResourceCodec.getLayers(catalog, encodedCoverageId);
  if (layers == null) return null;
  LayerInfo ret = null;
  for (LayerInfo layer : layers) {
    if (layer != null && layer.getType() == PublishedType.RASTER) {
      if (ret == null) {
        ret = layer;
      } else {
        LOGGER.warning(
            "Multiple coverages found for NSName '"
                + encodedCoverageId
                + "': "
                + ret.prefixedName()
                + " is selected, "
                + layer.prefixedName()
                + " will be ignored");
      }
    }
  }
  return ret;
}

@Test
public void testBasicKVP() throws Exception {
    List<LayerInfo> list0 = NCNameResourceCodec.getLayers(getCatalog(), "pippo_topo");
    assertNotNull(list0);
    assertEquals(0, list0.size());
    List<LayerInfo> list1 = NCNameResourceCodec.getLayers(getCatalog(), "pippo__topo");
    assertNotNull(list1);
    assertEquals(0, list1.size());
    List<LayerInfo> list = NCNameResourceCodec.getLayers(getCatalog(), "wcs__BlueMarble");
    assertNotNull(list);
    assertEquals(1, list.size());
    WorkspaceInfo oldWs = LocalWorkspace.get();
    LocalWorkspace.set(ws);
    List<LayerInfo> list = NCNameResourceCodec.getLayers(getCatalog(), "BlueMarble");
    assertNotNull(list);
    assertEquals(1, list.size());
    List<LayerInfo> list = NCNameResourceCodec.getLayers(getCatalog(), "BlueMarble");
    assertNotNull(list);
    assertEquals(1, list.size());

/**
 * Returns the coverage containing the specified coverage, or null if the syntax is incorrect,
 * the coverage does not exist, or it's not a dataset
 */
public CoverageInfo getGranuleCoverage(String granuleId) {
  // does it have the expected lexical structure?
  if (!granuleId.contains(GRANULE_SEPARATOR)) {
    return null;
  }
  String[] splitted = granuleId.split(GRANULE_SEPARATOR);
  if (splitted.length != 2) {
    return null;
  }
  // do we have the coverage?
  LayerInfo li = NCNameResourceCodec.getCoverage(catalog, splitted[0]);
  if (li == null) {
    return null;
  }
  // is it a EO dataset?
  CoverageInfo ci = (CoverageInfo) li.getResource();
  if (isValidDataset(ci)) {
    return ci;
  } else {
    return null;
  }
}

public String getDatasetName(CoverageInfo ci) {
  if (!isValidDataset(ci)) {
    throw new IllegalArgumentException(
        "Specified covearge " + ci.prefixedName() + " is not a valid EO dataset");
  }
  return NCNameResourceCodec.encode(ci) + DATASET_SUFFIX;
}

@Test
public void testDecode01() {
  String qualifiedName = "ws__name";
  List<MapEntry<String, String>> decode = NCNameResourceCodec.decode(qualifiedName);
  assertEquals(1, decode.size());
  assertEquals("ws", decode.get(0).getKey());
  assertEquals("name", decode.get(0).getValue());
}

if (geoserver != null) {
  Catalog gsCatalog = geoserver.getCatalog();
  LayerInfo info = NCNameResourceCodec.getCoverage(gsCatalog, coverageId);
  if (info != null) {
    map = info.getResource().getMetadata();

/**
 * Base constructor which only deals with timeDimension. It is used by WCS-EO classes which
 * deals with up to timeDimensions
 *
 * @param timeDimension
 * @param reader
 * @param coverageId
 * @throws IOException
 */
public WCSDimensionsHelper(CoverageInfo ci) throws IOException {
  this.coverageId = NCNameResourceCodec.encode(ci);
  this.accessor =
      new ReaderDimensionsAccessor(
          (GridCoverage2DReader) ci.getGridCoverageReader(null, null));
  Map<String, DimensionInfo> dimensions = new HashMap<String, DimensionInfo>();
  for (Map.Entry<String, Serializable> entry : ci.getMetadata().entrySet()) {
    if (entry.getValue() instanceof DimensionInfo) {
      dimensions.put(entry.getKey(), (DimensionInfo) entry.getValue());
    }
  }
  if (!dimensions.isEmpty()) {
    initDimensions(dimensions);
  }
}

  @Test // (expected=IllegalArgumentException.class)
  public void testDecodeBad() {
    String qualifiedName = "bad_qualified_name";
    List<MapEntry<String, String>> decode = NCNameResourceCodec.decode(qualifiedName);
    assertEquals(1, decode.size());
    assertNull(decode.get(0).getKey());
    assertEquals("bad_qualified_name", decode.get(0).getValue());
  }
}

if (geoserver != null) {
  Catalog gsCatalog = geoserver.getCatalog();
  LayerInfo info = NCNameResourceCodec.getCoverage(gsCatalog, coverageId);
  if (info != null) {
    map = info.getResource().getMetadata();

public static String encode(ResourceInfo resource) {
  return encode(resource.getNamespace().getPrefix(), resource.getName());
}

@Test
public void testDecode03() {
  String qualifiedName = "s1___s2";
  List<MapEntry<String, String>> decode = NCNameResourceCodec.decode(qualifiedName);
  assertEquals(2, decode.size());
  assertEquals("s1_", decode.get(0).getKey());
  assertEquals("s2", decode.get(0).getValue());
  assertEquals("s1", decode.get(1).getKey());
  assertEquals("_s2", decode.get(1).getValue());
}

LayerInfo layer = NCNameResourceCodec.getCoverage(catalog, newCoverageID);
if (layer == null) {
  badCoverageIds.add(encodedCoverageId);

/** Test of encode method, of class CoverageIdConverter. */
@Test
public void testEncode() {
  String result = NCNameResourceCodec.encode("ws", "name");
  assertEquals("ws__name", result);
}

@Test
public void testDecode02() {
  String qualifiedName = "s1__s2__s3";
  List<MapEntry<String, String>> decode = NCNameResourceCodec.decode(qualifiedName);
  assertEquals(2, decode.size());
  assertEquals("s1__s2", decode.get(0).getKey());
  assertEquals("s3", decode.get(0).getValue());
  assertEquals("s1", decode.get(1).getKey());
  assertEquals("s2__s3", decode.get(1).getValue());
}

  /**
   * Extracts the NetCDF encoding settings from the coverage identifier
   *
   * @param coverageId
   * @return
   */
  static NetCDFLayerSettingsContainer getSettings(String coverageId) {
    GeoServer geoserver = GeoServerExtensions.bean(GeoServer.class);
    MetadataMap map = null;
    if (geoserver != null) {
      Catalog gsCatalog = geoserver.getCatalog();
      LayerInfo info = NCNameResourceCodec.getCoverage(gsCatalog, coverageId);
      if (info != null) {
        map = info.getResource().getMetadata();
      }
    }
    if (map != null
        && !map.isEmpty()
        && map.containsKey(NetCDFSettingsContainer.NETCDFOUT_KEY)) {
      NetCDFLayerSettingsContainer settings =
          (NetCDFLayerSettingsContainer)
              map.get(
                  NetCDFSettingsContainer.NETCDFOUT_KEY,
                  NetCDFLayerSettingsContainer.class);
      return settings;
    }

    return null;
  }
}

private void handleCoverageSummary(CoverageInfo cv) throws Exception {
  start("wcs:CoverageSummary");
  String covId = NCNameResourceCodec.encode(cv);
  element("wcs:CoverageId", covId);
  element("wcs:CoverageSubtype", "RectifiedGridCoverage"); // TODO make this parametric
  handleWGS84BoundingBox(cv.getLatLonBoundingBox());
  handleBoundingBox(cv.boundingBox());
  end("wcs:CoverageSummary");
}