final IActivePivotInstanceDescription cubeDescription =
    StartBuilding.cube("Cube")
        .withSingleLevelDimension("id")
        .withDimension("dimension")
        .withAnalysisHierarchy("analysisHierarchy_example", StringAnalysisHierarchy.PLUGIN_KEY)
        .build();

final IActivePivotInstanceDescription cubeTwoDescription =
    StartBuilding.cube("Cube2")
        .withSingleLevelDimension("id")
        .withDimension("dimension")
        .withAnalysisHierarchy("stringAH", StringAnalysisHierarchy.PLUGIN_KEY)
        .withCustomizations(
            desc -> {
              desc.setName("Customized Hierarchy"); // Renames the AH
              desc.setAllMembersEnabled(false); // Makes the AH slicing
              desc.putProperty("PropertyName", "PropertyValue");
              // Adds the PropertyName:PropertyValue pair to the AH's properties
            })
        .build();

@AtotiExtendedPluginValue(intf = IAnalysisHierarchy.class, key = AHForPnLExtract.PLUGIN_KEY)
public static class AHForPnLExtract extends AAnalysisHierarchy {
  protected Collection<String> SCENARIOS =
      List.of("SCENARIO 1", "SCENARIO 2", "SCENARIO 3", "SCENARIO 1 EDITED");
  public static final String PLUGIN_KEY = "scenarioHierarchy";
  /**
   * Constructor.
   *
   * @param info the info about the hierarchy
   * @param levelInfos the info about the levels
   * @param levelDictionaries the levels' dictionaries
   */
  public AHForPnLExtract(
      final IAnalysisHierarchyInfo info,
      final List<ILevelInfo> levelInfos,
      final IDictionary<Object>[] levelDictionaries) {
    super(info, levelInfos, levelDictionaries);
  }
  @Override
  public String getType() {
    return PLUGIN_KEY;
  }
  @Override
  protected Iterator<Object[]> buildDiscriminatorPathsIterator(final IDatabaseVersion database) {
    return SCENARIOS.stream().map(scenarioName -> new Object[] {null, scenarioName}).iterator();
  }
}

@AtotiPluginValue(intf = IAnalysisHierarchyDescriptionProvider.class)
public static class AHDescProviderForPnlExtract extends AAnalysisHierarchyDescriptionProvider {
  public AHDescProviderForPnlExtract() {
    super();
  }
  @Override
  public String key() {
    return AHForPnLExtract.PLUGIN_KEY;
  }
  @Override
  public IAnalysisHierarchyDescription getDescription() {
    final IAnalysisHierarchyDescription description =
        new AnalysisHierarchyDescription(AHForPnLExtract.PLUGIN_KEY, "Scenario", true);
    description.addLevel(new AxisLevelDescription("Scenario", null));
    return description;
  }
}

Copper.sum("SimulatedPnLs")
    .map(
        (v, cell) ->
            cell.writeDouble(v.readVector(0).sumDouble() / v.readVector(0).size()),
        ILiteralType.DOUBLE)
    .as("averaged simulated pnL")

@AtotiExtendedPluginValue(intf = IPostProcessor.class, key = pnlExtractorPP.PLUGIN_KEY)
public static class pnlExtractorPP extends ADynamicAggregationPostProcessor {
  public static final String PLUGIN_KEY = "plnExtractor";
  /** Constructor. */
  public pnlExtractorPP(final String name, final IPostProcessorCreationContext creationContext) {
    super(name, creationContext);
  }
  @Override
  protected void evaluateLeaf(
      final ILocation leafLocation,
      final IRecordReader underlyingValues,
      final IWritableCell resultCell) {
    final int scenarioLevelCoordinate = pivot.getHierarchicalMapping().getCoordinate(4, 1);
    final ILevelInfo levelInfo =
        pivot.getHierarchicalMapping().getLevelInfo(scenarioLevelCoordinate);
    if (LocationUtil.isAtOrBelowLevel(leafLocation, levelInfo)) {
      // The scenario level is expressed
      final String scenarioValue = (String) LocationUtil.getCoordinate(leafLocation, levelInfo);
      switch (scenarioValue) {
        case "SCENARIO 1":
          resultCell.write(((IVector) underlyingValues.read(0)).subVector(0, 500));
          break;
        case "SCENARIO 2":
          resultCell.write(((IVector) underlyingValues.read(0)).subVector(500, 500));
          break;
        case "SCENARIO 3":
          resultCell.write(((IVector) underlyingValues.read(0)).subVector(1_000, 500));
          break;
        case "SCENARIO 1 EDITED":
          resultCell.write(((IVector) underlyingValues.read(0)).subVector(1_500, 500));
          break;
        default:
          throw new IllegalStateException("Unexpected scenario.");
      }
    } else {
      resultCell.write(underlyingValues.read(0));
    }
  }
  @Override
  public String getType() {
    return PLUGIN_KEY;
  }
  @Override
  protected boolean supportsAnalysisLevels() {
    return true;
  }
}

Copper.sum("SimulatedPnLs").as("sum").publish(ctx);
Copper.newPostProcessor(pnlExtractorPP.PLUGIN_KEY)
    .withProperty(AAdvancedPostProcessor.UNDERLYING_MEASURES, "sum")
    .withProperty(AAdvancedPostProcessor.ANALYSIS_LEVELS_PROPERTY, "Scenario")
    .withProperty(IPostProcessor.OUTPUT_TYPE_PROPERTY, ILiteralType.DOUBLE_ARRAY)
    .withProperty(
        ADynamicAggregationPostProcessor.LEAF_TYPE, ILiteralType.DOUBLE_ARRAY)
    .as("PnLExtractedScenario")
    .publish(ctx);
Copper.measure("PnLExtractedScenario")
    .map(
        (v, cell) ->
            cell.writeDouble(v.readVector(0).sumDouble() / v.readVector(0).size()),
        ILiteralType.DOUBLE)
    .as("averaged simulated pnL with Scenario drillDown")

@AtotiExtendedPluginValue(intf = IAnalysisHierarchy.class, key = TimeBucketHierarchy.PLUGIN_TYPE)
public static class TimeBucketHierarchy extends AAnalysisHierarchy {
  private static final long serialVersionUID = 6_01_00L;
  /** Plugin type. */
  public static final String PLUGIN_TYPE = "TIME_BUCKET";
  /** Time bucketer. */
  protected final IBucketer<Long> bucketer;
  public TimeBucketHierarchy(
      final IAnalysisHierarchyInfo info,
      final List<ILevelInfo> levelInfos,
      final IDictionary<Object>[] levelDictionaries) {
    super(info, levelInfos, levelDictionaries);
    this.bucketer = new TimeBucketer();
  }
  @Override
  protected Iterator<Object[]> buildDiscriminatorPathsIterator(final IDatabaseVersion database) {
    // We don't generate the unused members as they don't correspond to any possible trade.
    return bucketer.getAllBuckets().stream()
        .map(
            bucket ->
                new Object[] {null, bucket.equals("1+Y") ? "OTHER" : "CURRENT_YEAR", bucket})
        .iterator();
  }
  @Override
  public String getType() {
    return PLUGIN_TYPE;
  }
}

@AtotiPluginValue(intf = IAnalysisHierarchyDescriptionProvider.class)
public static class TimeBucketHierarchyDescriptionProvider extends PluginValue
    implements IAnalysisHierarchyDescriptionProvider {
  /** Time bucketer. */
  protected final IBucketer<?> bucketer;
  public TimeBucketHierarchyDescriptionProvider() {
    super();
    this.bucketer = new TimeBucketer();
  }
  @Override
  public String key() {
    return TimeBucketHierarchy.PLUGIN_TYPE;
  }
  @Override
  public IAnalysisHierarchyDescription getDescription() {
    final var desc =
        new AnalysisHierarchyDescription(TimeBucketHierarchy.PLUGIN_TYPE, "Maturity", true);
    final var levelDesc = new AxisLevelDescription("Maturity term category", null);
    levelDesc.putProperty(
        IAxisLevelDescription.ANALYSIS_LEVEL_TYPE_PROPERTY, String.valueOf(Types.TYPE_STRING));
    final var levelDescTwo = new AxisLevelDescription("Maturity term bucket", null);
    levelDescTwo.setComparator(createComparatorDescription());
    levelDescTwo.putProperty(
        IAxisLevelDescription.ANALYSIS_LEVEL_TYPE_PROPERTY, String.valueOf(Types.TYPE_STRING));
    desc.addLevel(levelDesc);
    desc.addLevel(levelDescTwo);
    return desc;
  }
  private IComparatorDescription createComparatorDescription() {
    final var comparator = new ComparatorDescription(IComparator.CUSTOM_PLUGIN_KEY);
    final var compOrder =
        new ComparatorOrderDescription("firstObjects", bucketer.getAllBuckets());
    comparator.setOrders(List.of(compOrder)); // Use the bucketer ordering rather than the
    // default one (alphabetical).
    return comparator;
  }
}

/**
 * Simple Time bucketer, that organizes time buckets separated by their time boundary. It comes
 * with a predefined collection of buckets.
 *
 * @author ActiveViam
 */
public static class TimeBucketer extends ATimeBucketer {
  /** Constructor. */
  public TimeBucketer() {
    createBuckets();
  }
  @Override
  public NavigableMap<Long, Object> createBucketMap(final Long timeReference) {
    return createBucketMap(timeReference, buckets);
  }
  /** Create default buckets. */
  protected void createBuckets() {
    createBucket("1W", ChronoUnit.WEEKS, 1);
    createBucket("1M", ChronoUnit.MONTHS, 1);
    createBucket("1Y", ChronoUnit.YEARS, 1);
    createBucket("1+Y", ChronoUnit.FOREVER, 1);
  }
  @Override
  public NavigableMap<Long, Object> createBucketMap(
      final Long timeReference, final List<Object> bucketSelection) {
    final NavigableMap<Long, Object> map = new TreeMap<>();
    for (int m = bucketSelection.size() - 1; m >= 0; m--) {
      final Object bucket = bucketSelection.get(m);
      final long boundary = getInvertedBoundary(timeReference, bucket);
      map.put(boundary, bucket);
    }
    return map;
  }
}

// [...cube Builder started]
.withDimension("Maturity")
.withAnalysisHierarchy("CurrentMaturityBucket", TimeBucketHierarchy.PLUGIN_TYPE)
.withAggregationProcedure(TimeBucketHierarchy.PLUGIN_TYPE)
.withUnderlyingLevels(LevelIdentifier.simple("TradeDate"))
.end()

/**
 * Aggregation procedure dynamically contributing time members to the time buckets.
 *
 * <p>It will allow the time buckets to exist for any primitive measure, making their values
 * available for post-processors based on it.
 */
public static class TimeBucketProcedure
    extends ABasicAggregationProcedure<
        IPair<NavigableMap<Long, Object>, Collection<ICondition>>> {
  /** The ordinal of the bucket level. */
  public static final int BUCKET_LEVEL_ORDINAL = 2;
  /** Instance mapping a date to a bucket. */
  protected final IBucketer<Long> bucketer;
  /** Info about the level with values to bucket. */
  protected final ILevelInfo bucketedLevel;
  /**
   * Function that takes a cube filter as argument and that creates a {@link ICondition} from it.
   * It is used to find if a bucket member is granted or not.
   */
  protected final Function<ICubeFilter, ICondition> filterCreator;
  public TimeBucketProcedure(
      final IAnalysisAggregationProcedureDescription description,
      final IHierarchy hierarchy,
      final IAggregationHierarchyCreationContext context) {
    super(description, hierarchy, context);
    this.bucketer = new TimeBucketer();
    this.bucketedLevel = this.underlyingLevels.get(0);
    this.filterCreator = filter -> TrueCondition.TRUE; // Not implemented for simplicity’s sake
  }
  /**
   * Gets the level info of the underlying bucket level.
   *
   * @return level info
   */
  protected ILevelInfo getBucketLevel() {
    return this.getHierarchy().getLevels().get(BUCKET_LEVEL_ORDINAL);
  }
  /**
   * Creates a request location by adding the required levels to map ActivePivot points to members
   * of the handled analysis hierarchies. Example : If the location is queried on a specific
   * bucket, we need to express the "TradeDates" level in the requested location in order to
   * determine which trade goes in the expressed bucket.
   *
   * @return {@code true} if this procedure must be used to handle the location and measure.
   */
  @Override
  public boolean buildRequestScope(
      final ILocationBuilder location,
      final ICubeFilter securityAndFilters,
      final IJoinMeasure joinMeasure,
      final IActivePivotVersion pivot,
      final Collection<IMeasureMember> underlyingMeasures) {
    if (location.getLevelDepth(this.getHierarchyOrdinal()) > 1) {
      expandOnUnderlyingLevels(location);
      // The hierarchy is expressed in the query location, get the underlying elements for
      // bucketing
      return true;
    } else if (expressHandledHierarchies(securityAndFilters)) {
      // The hierarchy is expressed in the query filter, get the underlying elements for bucketing
      expandOnUnderlyingLevels(location);
      location.expandToLevel(getBucketLevel());
      return true;
    } else { // The hierarchy is absent, dynamic bucketing is not wanted
      return false;
    }
  }
  /**
   * Creates the context that will be passed as an argument to the mapToFullLocation([...])
   * method. The "context" is the information provided during the procedure execution in order to
   * determine the appropriate member to choose for each point location. Here, the context
   * contains the Map of buckets and the query conditions.
   */
  @Override
  public IPair<NavigableMap<Long, Object>, Collection<ICondition>> createContext(
      final IActivePivotVersion pivot,
      final IScopeLocation primitiveRetrievalScope,
      final IScopeLocation targetScope,
      final IScopeLocation prefetchLocation,
      final IDatabaseRetrievalResult databaseResult) {
    final ICondition filterCondition =
        this.filterCreator.apply(CubeFilter.getFromContext(pivot.getContext()));
    ICondition scopeCondition;
    final Object scopeCoordinateFirstLevel =
        targetScope.getCleansedLocation().getCoordinate(getHierarchyOrdinal(), 1);
    if (scopeCoordinateFirstLevel == null) {
      scopeCondition = TrueCondition.TRUE;
    } else {
      final Object scopeCoordinateSecondLevel =
          targetScope.getCleansedLocation().getCoordinate(getHierarchyOrdinal(), 2);
      scopeCondition = new InCondition(scopeCoordinateFirstLevel);
      if (scopeCoordinateSecondLevel != null) {
        scopeCondition =
            new AndCondition(
                List.of(scopeCondition, new InCondition((scopeCoordinateSecondLevel))));
      }
    }
    return new Pair<>(createBucketMap(), Arrays.asList(filterCondition, scopeCondition));
  }
  /**
   * The heart of the procedure. Builds a full Location from a provided readable Location without
   * analysis levels and the provided context.
   */
  @Override
  public void mapToFullLocation(
      final IPair<NavigableMap<Long, Object>, Collection<ICondition>> context,
      final IPointLocationReader primitiveRetrievalLocation,
      final IAggregatesLocationResult aggregates,
      final IPointLocationBuilder targetLocationBuilder,
      final ResultConsumer consumer) {
    // Compute the target bucket based on the current bucketed level value
    final Date bucketedMember =
        ((Date)
            primitiveRetrievalLocation.getCoordinate(
                this.bucketedLevel.getHierarchyInfo().getOrdinal() - 1,
                this.bucketedLevel.getOrdinal()));
    final NavigableMap<Long, Object> bucketMap = context.getLeft();
    final Object[] memberArray;
    // Find the correct bucket entry that matches the time
    final Map.Entry<Long, Object> ceilingEntry = bucketMap.floorEntry(bucketedMember.getTime());
    if (ceilingEntry == null) {
      memberArray = null;
    } else {
      memberArray =
          ceilingEntry.getValue().equals("1+Y")
              ? new Object[] {"OTHER", ceilingEntry.getValue()}
              : new Object[] {"CURRENT_YEAR", ceilingEntry.getValue()};
    }
    if (memberArray == null) {
      return;
    }
    final Object category = memberArray[0];
    final Object bucket = memberArray[1];
    // Make sure the computed bucket member matches the query conditions
    if (bucket == null || !context.getRight().stream().allMatch(c -> c.evaluate(bucket))) {
      return;
    }
    // Keep the bucket if it is compatible with the current bucket coordinate
    final ILevelInfo bucketLevel = getBucketLevel();
    final Object bucketMember =
        targetLocationBuilder.readCoordinate(
            bucketLevel.getHierarchyInfo().getOrdinal() - 1, bucketLevel.getOrdinal());
    if (bucketMember != null) {
      // A bucket coordinate already exists. Only keep our bucket if it matches the current one
      if (bucketMember.equals(bucket)) {
        consumer.accept(targetLocationBuilder, -1);
      }
    } else {
      // The bucket coordinate is not set. We need to set it when asked.
      targetLocationBuilder.setCoordinate(getHierarchyOrdinal(), 1, category);
      // The maturity category may be set but not the bucket, we check if the location can be set
      if (targetLocationBuilder.getRangeCoordIndex(getHierarchyOrdinal(), 2) >= 0) {
        targetLocationBuilder.setCoordinate(getHierarchyOrdinal(), 2, bucket);
      }
      consumer.accept(targetLocationBuilder, -1);
    }
  }
  /**
   * Dynamically organize the buckets that are visible in the bucket hierarchy, and map those into
   * a navigable map so that finding the bucket associated with a date is very fast.
   *
   * <p>Creating the map of buckets is expensive and should be done only once per query, consider
   * using the QueryCache to safely do so.
   *
   * @return map of buckets
   */
  protected NavigableMap<Long, Object> createBucketMap() {
    final IAxisHierarchy bucketHierarchy = (IAxisHierarchy) this.getHierarchy();
    final List<? extends IAxisMember> visibleMembers =
        bucketHierarchy.retrieveMembers(BUCKET_LEVEL_ORDINAL);
    final long timeReference = System.currentTimeMillis();
    final List<Object> visibleBuckets = new ArrayList<>();
    for (int m = visibleMembers.size() - 1; m >= 0; m--) {
      final IAxisMember member = visibleMembers.get(m);
      final Object discriminator = member.getDiscriminator();
      visibleBuckets.add(discriminator);
    }
    return this.bucketer.createBucketMap(timeReference, visibleBuckets);
  }
  /** Returns an optional request for rows in a store. */
  @Override
  public DatabasePrefetchRequest getDatabasePrefetch(
      final ILocation prefetchLocation, final ICubeFilter filter) {
    return null; // No additional is required from the database to determine the correct bucket
  }
}

@AtotiPluginValue(intf = IAnalysisAggregationProcedure.IFactory.class)
public static class TimeBucketFactory extends PluginValue
    implements IAnalysisAggregationProcedure.IFactory<
        IPair<NavigableMap<Long, Object>, Collection<ICondition>>> {
  @Override
  public String description() {
    return "Factory for Time Bucketing procedures";
  }
  @Override
  public String key() {
    return TimeBucketHierarchy.PLUGIN_TYPE;
  }
  @Override
  public IAnalysisAggregationProcedure<IPair<NavigableMap<Long, Object>, Collection<ICondition>>>
      create(
          final IAnalysisAggregationProcedureDescription description,
          final Collection<? extends IHierarchy> hierarchies,
          final IAggregationHierarchyCreationContext creationContext) {
    assert hierarchies.size() == 1;
    return new TimeBucketProcedure(description, hierarchies.iterator().next(), creationContext);
  }
}

@QuartetExtendedPluginValue(
    intf = IMultiVersionHierarchy.class,
    key = StringAnalysisHierarchyOld.PLUGIN_KEY)
public static class StringAnalysisHierarchyOld extends AAnalysisHierarchy {
  private static final long serialVersionUID = 20191122_02L;
  public static final String PLUGIN_KEY = "STATIC_STRING";
  protected final List<Object> levelOneDiscriminators;
  protected final List<Object> levelTwoDiscriminators;
  /**
   * Default constructor.
   *
   * @param hierarchyInfo information about this hierarchy
   */
  public StringAnalysisHierarchyOld(
      IAnalysisHierarchyInfo hierarchyInfo,
      List<ILevelInfo> levelInfos,
      IWritableDictionary<Object>[] dictionaries) {
    super(hierarchyInfo, levelInfos, dictionaries);
    this.levelOneDiscriminators = Arrays.asList("A", "B");
    this.levelTwoDiscriminators = Arrays.asList("X", "Y", "Z");
  }
  @Override
  public String getType() {
    return PLUGIN_KEY;
  }
  @Override
  public int getLevelsCount() {
    return this.isAllMembersEnabled ? 3 : 2;
  }
  @Override
  public IComparator<Object> getLevelComparator(int levelOrdinal) {
    // The second level is expected to use the reverse natural order
    if (levelOrdinal == 2) {
      return new ReverseOrderComparator();
    } else {
      return new NaturalOrderComparator();
    }
  }
  @Override
  protected Iterator<Object[]> buildDiscriminatorPathsIterator(IDatabaseVersion database) {
    final List<Object[]> resultList = new ArrayList<>();
    for (Object lvlOneDiscriminator : levelOneDiscriminators) {
      for (Object lvlTwoDiscriminator : levelTwoDiscriminators) {
        final Object[] path = new Object[getLevelsCount()];
        path[path.length - 2] = lvlOneDiscriminator;
        path[path.length - 1] = lvlTwoDiscriminator;
        resultList.add(path);
      }
    }
    return resultList.iterator();
  }
}

@AtotiExtendedPluginValue(
    intf = IAnalysisHierarchy.class,
    key = StringAnalysisHierarchy.PLUGIN_KEY)
public static class StringAnalysisHierarchy extends AAnalysisHierarchy {
  public static final String PLUGIN_KEY = "STATIC_STRING";
  protected final List<Object> levelOneDiscriminators;
  protected final List<Object> levelTwoDiscriminators;
  /**
   * Default constructor.
   *
   * @param hierarchyInfo information about this hierarchy
   */
  public StringAnalysisHierarchy(
      final IAnalysisHierarchyInfo hierarchyInfo,
      final List<ILevelInfo> levelInfos,
      final IDictionary<Object>[] levelDictionaries) {
    super(hierarchyInfo, levelInfos, levelDictionaries);
    this.levelOneDiscriminators = Arrays.asList("A", "B");
    this.levelTwoDiscriminators = Arrays.asList("X", "Y", "Z");
  }
  @Override
  protected Iterator<Object[]> buildDiscriminatorPathsIterator(
      final IDatabaseVersion database) {
    final List<Object[]> resultList = new ArrayList<>();
    for (final Object lvlOneDiscriminator : levelOneDiscriminators) {
      for (final Object lvlTwoDiscriminator : levelTwoDiscriminators) {
        final Object[] path = new Object[base.getLevelInfos().size()];
        path[path.length - 2] = lvlOneDiscriminator;
        path[path.length - 1] = lvlTwoDiscriminator;
        resultList.add(path);
      }
    }
    return resultList.iterator();
  }
  @Override
  public String getType() {
    return PLUGIN_KEY;
  }
}

@AtotiPluginValue(intf = IAnalysisHierarchyDescriptionProvider.class)
public static class StringAnalysisHierarchyDescriptionProvider
    extends AAnalysisHierarchyDescriptionProvider {
  @Override
  public IAnalysisHierarchyDescription getDescription() {
    final var desc = new AnalysisHierarchyDescription(key(), "stringHierName");
    final var levelDesc = new AxisLevelDescription(STATIC_STRING, null);
    final var levelDescTwo = new AxisLevelDescription(STATIC_STRING + "_1", null);
    levelDescTwo.setComparator(
        new ComparatorDescription(IComparator.DESCENDING_NATURAL_ORDER_PLUGIN_KEY));
    desc.addLevel(levelDesc);
    desc.addLevel(levelDescTwo);
    return desc;
  }
  @Override
  public String key() {
    return TestAnalysisHierarchyCompatibility.StringAnalysisHierarchy.PLUGIN_KEY;
  }
}