Added lazy loading methods to CodeBottle.java

Author: burdoto

src/main/java/io/codebottle/api/CodeBottle.java

@@ -1,12 +1,15 @@
 package io.codebottle.api;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
 import io.codebottle.api.model.Category;
 import io.codebottle.api.model.Language;
 import io.codebottle.api.model.Snippet;
@@ -15,10 +18,11 @@
 import org.jetbrains.annotations.Nullable;
 
 public final class CodeBottle {
+    public final CompletionStage<Void> lazyLoading;
+
     private final Map<Integer, Language> languageCache = new ConcurrentHashMap<>();
     private final Map<Integer, Category> categoryCache = new ConcurrentHashMap<>();
     private final Map<Integer, Snippet> snippetCache = new ConcurrentHashMap<>();
-
     private final String token;
 
     public CodeBottle() {
@@ -27,6 +31,8 @@ public CodeBottle() {
 
     public CodeBottle(@Nullable String token) {
         this.token = token;
+
+        this.lazyLoading = CompletableFuture.allOf(requestLanguages(), requestCategories());
     }
 
     public Optional<String> getToken() {
@@ -56,6 +62,27 @@ public CompletableFuture<Language> requestLanguageByID(int id) {
                 });
     }
 
+    public CompletableFuture<Collection<Language>> requestLanguages() {
+        return new CodeBottleRequest<Collection<Language>>(this)
+                .to(Endpoint.LANGUAGES)
+                .makeGET()
+                .then(data -> {
+                    synchronized (languageCache) {
+                        return StreamSupport.stream(data.spliterator(), false)
+                                .map(node -> getLanguageByID(node.path("id").asInt())
+                                        .map(entity -> entity.update(node))
+                                        .orElseGet(() -> {
+                                            final Language language = new Language(this, node);
+
+                                            languageCache.compute(language.getID(), (k, v) -> language);
+
+                                            return language;
+                                        }))
+                                .collect(Collectors.toList());
+                    }
+                });
+    }
+
     public Optional<Category> getCategoryByID(int id) {
         if (id == -1) return Optional.empty();
 
@@ -79,6 +106,27 @@ public CompletableFuture<Category> requestCategoryByID(int id) {
                 });
     }
 
+    public CompletableFuture<Collection<Category>> requestCategories() {
+        return new CodeBottleRequest<Collection<Category>>(this)
+                .to(Endpoint.CATEGORIES)
+                .makeGET()
+                .then(data -> {
+                    synchronized (categoryCache) {
+                        return StreamSupport.stream(data.spliterator(), false)
+                                .map(node -> getCategoryByID(node.path("id").asInt())
+                                        .map(entity -> entity.update(node))
+                                        .orElseGet(() -> {
+                                            final Category category = new Category(this, node);
+
+                                            categoryCache.compute(category.getID(), (k, v) -> category);
+
+                                            return category;
+                                        }))
+                                .collect(Collectors.toList());
+                    }
+                });
+    }
+
     public Optional<Snippet> getSnippetByID(int id) {
         if (id == -1) return Optional.empty();
 
@@ -102,6 +150,27 @@ public CompletableFuture<Snippet> requestSnippetByID(int id) {
                 });
     }
 
+    public CompletableFuture<Collection<Snippet>> requestSnippets() {
+        return new CodeBottleRequest<Collection<Snippet>>(this)
+                .to(Endpoint.SNIPPETS)
+                .makeGET()
+                .then(data -> {
+                    synchronized (snippetCache) {
+                        return StreamSupport.stream(data.spliterator(), false)
+                                .map(node -> getSnippetByID(node.path("id").asInt())
+                                        .map(entity -> entity.update(node))
+                                        .orElseGet(() -> {
+                                            final Snippet snippet = new Snippet(this, node);
+
+                                            snippetCache.compute(snippet.getID(), (k, v) -> snippet);
+
+                                            return snippet;
+                                        }))
+                                .collect(Collectors.toList());
+                    }
+                });
+    }
+
     public Optional<Snippet.Revision> getSnippetRevisionByID(int snippetId, int id) throws IndexOutOfBoundsException {
         if (id == -1) return Optional.empty();