How to use com.graphhopper.routing.util

@Override
public long reverseFlags(long flags) {
  // swap access
  flags = super.reverseFlags(flags);
  // swap speeds 
  double otherValue = reverseSpeedEncoder.getDoubleValue(flags);
  flags = setReverseSpeed(flags, speedEncoder.getDoubleValue(flags));
  return setSpeed(flags, otherValue);
}

@Override
public long reverseFlags(long flags) {
  // swap access
  flags = super.reverseFlags(flags);
  // swap speeds 
  double otherValue = reverseSpeedEncoder.getDoubleValue(flags);
  flags = setReverseSpeed(flags, speedEncoder.getDoubleValue(flags));
  return setSpeed(flags, otherValue);
}

@Override
public double getDouble(long flags, int key) {
  switch (key) {
    case PriorityWeighting.KEY:
      return (double) priorityWayEncoder.getValue(flags) / BEST.getValue();
    case MotorcycleFlagEncoder.CURVATURE_KEY:
      return (double) curvatureEncoder.getValue(flags) / 10;
    default:
      return super.getDouble(flags, key);
  }
}

@Override
public int defineWayBits(int index, int shift) {
  // first two bits are reserved for route handling in superclass
  shift = super.defineWayBits(index, shift);
  // larger value required - ferries are faster than pedestrians
  speedEncoder = new EncodedDoubleValue("Speed", shift, speedBits, speedFactor, MEAN_SPEED, maxPossibleSpeed);
  shift += speedEncoder.getBits();
  priorityWayEncoder = new EncodedValue("PreferWay", shift, 3, 1, 0, 7);
  shift += priorityWayEncoder.getBits();
  return shift;
}

@Override
public long handleRelationTags(ReaderRelation relation, long oldRelationFlags) {
  oldRelationFlags = super.handleRelationTags(relation, oldRelationFlags);
  int code = 0;
  if (relation.hasTag("route", "mtb"))
    code = PREFER.getValue();
  int oldCode = (int) relationCodeEncoder.getValue(oldRelationFlags);
  if (oldCode < code)
    return relationCodeEncoder.setValue(0, code);
  return oldRelationFlags;
}

@Override
public int defineWayBits(int index, int shift) {
  shift = super.defineWayBits(index, shift);
  reverseSpeedEncoder = new EncodedDoubleValue("Reverse Speed", shift, speedBits, speedFactor,
      getHighwaySpeed("cycleway"), maxPossibleSpeed);
  shift += reverseSpeedEncoder.getBits();
  return shift;
}

@Override
public long handleSpeed(ReaderWay way, double speed, long flags) {
  // handle oneways
  flags = super.handleSpeed(way, speed, flags);
  if (isBackward(flags))
    flags = setReverseSpeed(flags, speed);
  if (isForward(flags))
    flags = setSpeed(flags, speed);
  return flags;
}

@Override
public double getDouble(long flags, int key) {
  switch (key) {
    case PriorityWeighting.KEY:
      return (double) priorityWayEncoder.getValue(flags) / BEST.getValue();
    default:
      return super.getDouble(flags, key);
  }
}

EncodingManager createEncodingManager(boolean restrictedOnly) {
  if (restrictedOnly)
    carEncoder = new CarFlagEncoder(5, 5, 1);
  else
    // allow for basic costs too
    carEncoder = new CarFlagEncoder(5, 5, 3);
  return new EncodingManager(carEncoder);
}

private NameSimilarityEdgeFilter createNameSimilarityEdgeFilter(String s) {
  return new NameSimilarityEdgeFilter(DefaultEdgeFilter.allEdges(new CarFlagEncoder()), s);
}

@Override
protected long setLowSpeed(long flags, double speed, boolean reverse) {
  if (reverse)
    return setBool(reverseSpeedEncoder.setDoubleValue(flags, 0), K_BACKWARD, false);
  return setBool(speedEncoder.setDoubleValue(flags, 0), K_FORWARD, false);
}

  @Override
  public final boolean accept(EdgeIteratorState edgeState) {
    return super.accept(edgeState) && allFilter.accept(edgeState);
  }
};

@Override
public long setProperties(double speed, boolean forward, boolean backward) {
  long flags = super.setProperties(speed, forward, backward);
  if (backward)
    return setReverseSpeed(flags, speed);
  return flags;
}

@Override
protected long setLowSpeed(long flags, double speed, boolean reverse) {
  if (reverse)
    return setBool(reverseSpeedEncoder.setDoubleValue(flags, 0), K_BACKWARD, false);
  return setBool(speedEncoder.setDoubleValue(flags, 0), K_FORWARD, false);
}

@Override
public long setProperties(double speed, boolean forward, boolean backward) {
  long flags = super.setProperties(speed, forward, backward);
  if (backward)
    return setReverseSpeed(flags, speed);
  return flags;
}

@Override
public long flagsDefault(boolean forward, boolean backward) {
  long flags = super.flagsDefault(forward, backward);
  if (backward)
    return reverseSpeedEncoder.setDefaultValue(flags);
  return flags;
}

  @Override
  public double getSpeed(long flags) {
    double speed = super.getSpeed(flags);
    if (speed == getMaxSpeed()) {
      // We cannot be sure if it was a long or a short trip
      return SHORT_TRIP_FERRY_SPEED;
    }
    return speed;
  }
}

@Override
public long flagsDefault(boolean forward, boolean backward) {
  long flags = super.flagsDefault(forward, backward);
  if (backward)
    return reverseSpeedEncoder.setDefaultValue(flags);
  return flags;
}

/**
 * Sets default flags with specified access.
 */
public long flagsDefault(boolean forward, boolean backward) {
  long flags = speedEncoder.setDefaultValue(0);
  return setAccess(flags, forward, backward);
}

@Override
public double getDouble(long flags, int key) {
  switch (key) {
    case PriorityWeighting.KEY:
      return (double) priorityWayEncoder.getValue(flags) / BEST.getValue();
    default:
      return super.getDouble(flags, key);
  }
}