com.marklogic.client.impl.QueryOptionsManagerImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of marklogic-client-api Show documentation
The official MarkLogic Java client API.
The newest version!
/*
 * Copyright © 2024 MarkLogic Corporation. All Rights Reserved.
 */
package com.marklogic.client.impl;

import com.marklogic.client.DatabaseClientFactory.HandleFactoryRegistry;
import com.marklogic.client.FailedRequestException;
import com.marklogic.client.ForbiddenUserException;
import com.marklogic.client.ResourceNotFoundException;
import com.marklogic.client.ResourceNotResendableException;
import com.marklogic.client.admin.QueryOptionsManager;
import com.marklogic.client.io.Format;
import com.marklogic.client.io.marker.ContentHandle;
import com.marklogic.client.io.marker.QueryOptionsListReadHandle;
import com.marklogic.client.io.marker.QueryOptionsReadHandle;
import com.marklogic.client.io.marker.QueryOptionsWriteHandle;

public class QueryOptionsManagerImpl
  extends AbstractLoggingManager
  implements QueryOptionsManager
{
  final static private String QUERY_OPTIONS_BASE = "/config/query";
  private RESTServices          services;
  private HandleFactoryRegistry handleRegistry;

  public QueryOptionsManagerImpl(RESTServices services) {
    this.services = services;
  }

  HandleFactoryRegistry getHandleRegistry() {
    return handleRegistry;
  }
  void setHandleRegistry(HandleFactoryRegistry handleRegistry) {
    this.handleRegistry = handleRegistry;
  }

  @Override
  public void deleteOptions(String name)
    throws ResourceNotFoundException, ForbiddenUserException, FailedRequestException {
    services.deleteValue(null, QUERY_OPTIONS_BASE, name);
  }

  @Override
  public  T readOptionsAs(String name, Format format, Class as)
    throws ResourceNotFoundException, ForbiddenUserException, FailedRequestException {
    ContentHandle handle = getHandleRegistry().makeHandle(as);
    if (!QueryOptionsReadHandle.class.isAssignableFrom(handle.getClass())) {
      throw new IllegalArgumentException(
        "Handle "+handle.getClass().getName()+
          " cannot be used to read resource service source as "+as.getName()
      );
    }

    Utilities.setHandleStructuredFormat(handle, format);

    readOptions(name, (QueryOptionsReadHandle) handle);

    return handle.get();
  }
  @Override
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public  T readOptions(String name, T queryOptionsHandle)
    throws ResourceNotFoundException, ForbiddenUserException, FailedRequestException {
    if (name == null) {
      throw new IllegalArgumentException(
        "Cannot read options for null name");
    }

    HandleImplementation queryOptionsBase = HandleAccessor.checkHandle(
      queryOptionsHandle, "query options");

    Format queryOptionsFormat = queryOptionsBase.getFormat();
    switch (queryOptionsFormat) {
      case UNKNOWN:
        queryOptionsFormat = Format.XML;
        break;
      case JSON:
      case XML:
        break;
      default:
        throw new UnsupportedOperationException(
          "Only JSON and XML query options are possible.");
    }

    String mimetype = queryOptionsFormat.getDefaultMimetype();
    queryOptionsBase.receiveContent(services.getValue(
      requestLogger, QUERY_OPTIONS_BASE, name, false, mimetype,
      queryOptionsBase.receiveAs()));

    return queryOptionsHandle;
  }

  @Override
  public void writeOptionsAs(String name, Format format, Object queryOptions)
    throws ResourceNotFoundException, ResourceNotResendableException, ForbiddenUserException, FailedRequestException {
    if (queryOptions == null) {
      throw new IllegalArgumentException("no options to write");
    }

    Class as = queryOptions.getClass();

    QueryOptionsWriteHandle queryOptionsHandle = null;
    if (QueryOptionsWriteHandle.class.isAssignableFrom(as)) {
      queryOptionsHandle = (QueryOptionsWriteHandle) queryOptions;
    } else {
      ContentHandle handle = getHandleRegistry().makeHandle(as);
      if (!QueryOptionsWriteHandle.class.isAssignableFrom(handle.getClass())) {
        throw new IllegalArgumentException(
          "Handle "+handle.getClass().getName()+
            " cannot be used to write query options as "+as.getName()
        );
      }
      Utilities.setHandleContent(handle, queryOptions);
      Utilities.setHandleStructuredFormat(handle, format);
      queryOptionsHandle = (QueryOptionsWriteHandle) handle;
    }

    writeOptions(name, queryOptionsHandle);
  }
  @SuppressWarnings("rawtypes")
  @Override
  public void writeOptions(String name, QueryOptionsWriteHandle queryOptionsHandle)
    throws ResourceNotFoundException, ResourceNotResendableException, ForbiddenUserException, FailedRequestException {
    HandleImplementation queryOptionsBase = HandleAccessor.checkHandle(
      queryOptionsHandle, "query options");

    if (queryOptionsBase == null)
      throw new IllegalArgumentException("Could not write null options: "
        + name);

    Format queryOptionsFormat = queryOptionsBase.getFormat();
    switch (queryOptionsFormat) {
      case UNKNOWN:
        queryOptionsFormat = Format.XML;
        break;
      case JSON:
      case XML:
        break;
      default:
        throw new UnsupportedOperationException(
          "Only JSON and XML query options are possible.");
    }

    String mimetype = queryOptionsFormat.getDefaultMimetype();

    services.putValue(requestLogger, QUERY_OPTIONS_BASE, name, mimetype, queryOptionsBase);
  }

  @Override
  public  T optionsListAs(Format format, Class as)
    throws ForbiddenUserException, FailedRequestException {
    ContentHandle handle = getHandleRegistry().makeHandle(as);
    if (!QueryOptionsListReadHandle.class.isAssignableFrom(handle.getClass())) {
      throw new IllegalArgumentException(
        "Handle "+handle.getClass().getName()+
          " cannot be used to list query options as "+as.getName()
      );
    }

    Utilities.setHandleStructuredFormat(handle, format);

    optionsList((QueryOptionsListReadHandle) handle);

    return handle.get();
  }
  @SuppressWarnings({ "unchecked", "rawtypes" })
  @Override
  public  T optionsList(T optionsHandle)
    throws ForbiddenUserException, FailedRequestException {
    HandleImplementation optionsBase = HandleAccessor.checkHandle(optionsHandle, "optionslist");

    Format optionsFormat = optionsBase.getFormat();
    switch(optionsFormat) {
      case UNKNOWN:
        optionsFormat = Format.XML;
        break;
      case JSON:
      case XML:
        break;
      default:
        throw new UnsupportedOperationException("Only XML and JSON options list results are possible.");
    }

    String mimetype = optionsFormat.getDefaultMimetype();

    optionsBase.receiveContent(services.optionsList(optionsBase.receiveAs(), mimetype, null));
    return optionsHandle;
  }
}