io.vertx.reactivex.core.file.FileSystem Java Examples

protected Single<TemplateVariants> loadVariants() {
	String path = name;
	int lastSlash = path.lastIndexOf('/');
	String templateDir;
	String namePart; 
	if(lastSlash != -1) {
		templateDir = path.substring(0, lastSlash);
		namePart = path.substring(lastSlash+1);
	} else {
		templateDir = ""; // current dir
		namePart = path;
	}
	FileSystem fs = AppGlobals.get().getVertx().fileSystem();
	return fs.rxReadDir(templateDir)
		.map(list -> loadVariants(fs, templateDir, namePart, list));
}
 

public Single<String> selectVariant(Request request){
	return loadVariants()
			.flatMap(variants -> {
				// no variant
				if(variants.variants.isEmpty())
					return Single.just(variants.defaultTemplate);
				Variant selectedVariant = request.selectVariant(new ArrayList<>(variants.variants.keySet()));
				// no acceptable variant
				if(selectedVariant == null) {
					// if it does not exist, that's special
					String template = variants.defaultTemplate;
					FileSystem fs = AppGlobals.get().getVertx().fileSystem();
					return fs.rxExists(template)
							.map(exists -> {
								if(exists)
									return template;
								throw new WebApplicationException(Status.NOT_ACCEPTABLE);
							});
				}
				return Single.just(variants.variants.get(selectedVariant));
			});
}
 

static Single<JsonArray> load() {
    Vertx vertx = Vertx.vertx();
    FileSystem fileSystem = vertx.fileSystem();
    return fileSystem.rxReadFile("src/main/resources/characters.json")
        .map(buffer -> buffer.toString())
        .map(content -> new JsonArray(content));
}
 

protected Flowable<Character> load() {
    Vertx vertx = Vertx.vertx();
    FileSystem fileSystem = vertx.fileSystem();
    return fileSystem.rxReadFile("src/main/resources/characters.json")
        .map(buffer -> buffer.toString())
        .map(content -> new JsonArray(content))
        .flatMapPublisher(array -> Flowable.fromIterable(array))
        .cast(JsonObject.class)
        .map(json -> json.mapTo(Character.class));
}
 

static Flowable<Character> load() {
    Vertx vertx = Vertx.vertx();
    FileSystem fileSystem = vertx.fileSystem();
    return fileSystem.rxReadFile("src/main/resources/characters.json")
        .map(buffer -> buffer.toString())
        .map(content -> new JsonArray(content))
        .flatMapPublisher(array -> Flowable.fromIterable(array))
        .cast(JsonObject.class)
        .map(json -> json.mapTo(Character.class));
}
 

private TemplateVariants loadVariants(FileSystem fs, String templateDir, String namePart,
		List<String> list) {
	Map<Variant, String> variants = new HashMap<>();
	String defaultTemplateExtension = "";
	for (String entry : list) {
		// classpath dir entries are expanded into temp folders which we get as absolute paths
		int lastSlash = entry.lastIndexOf('/');
		if(lastSlash != -1)
			entry = entry.substring(lastSlash+1);
		if(!entry.equals(namePart)
				&& entry.startsWith(namePart)) {
			String extensionWithDot = entry.substring(namePart.length());
			if(!extensionWithDot.startsWith("."))
				continue;
			// get rid of the template extension
			int templateExtension = extensionWithDot.indexOf('.', 1);
			if(templateExtension == -1) {
				// we have a single extension, it's probably the default template extension
				defaultTemplateExtension = extensionWithDot;
				continue;
			}
			String mediaExtension = extensionWithDot.substring(1, templateExtension);
			MediaType mediaType = AbstractTemplate.parseMediaType(mediaExtension);
			variants.put(new Variant(mediaType, (String)null, null), templateDir+"/"+entry);
		}
	}
	return new TemplateVariants(templateDir+"/"+namePart+defaultTemplateExtension, variants);
}
 

public void toFlowable(Vertx vertx) {
  FileSystem fs = vertx.fileSystem();
  fs.open("/data.txt", new OpenOptions(), result -> {
    AsyncFile file = result.result();
    Flowable<Buffer> observable = file.toFlowable();
    observable.forEach(data -> System.out.println("Read data: " + data.toString("UTF-8")));
  });
}
 

public void unmarshaller(FileSystem fileSystem) {
  fileSystem.open("/data.txt", new OpenOptions(), result -> {
    AsyncFile file = result.result();
    Observable<Buffer> observable = file.toObservable();
    observable.compose(ObservableHelper.unmarshaller((MyPojo.class))).subscribe(
      mypojo -> {
        // Process the object
      }
    );
  });
}
 

@Override
public void setUp() throws Exception {
  super.setUp();
  vertx = new Vertx(super.vertx);
  java.nio.file.FileSystem fs = FileSystems.getDefault();
  pathSep = fs.getSeparator();
  File ftestDir = testFolder.newFolder();
  testDir = ftestDir.toString();
}
 

public static FileSystem fs() {
    return vertx.fileSystem();
}
 

static Single<String> getFile() {
	Vertx vertx = Vertx.vertx();
	FileSystem fileSystem = vertx.fileSystem();
	return fileSystem.rxReadFile("src/main/resources/characters.json")
			.map(buffer -> buffer.toString());
}