bt.bencoding.model.JUMModelBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bt-bencoding Show documentation
Library for parsing, encoding and validating bencoded documents in Java
There is a newer version: 1.10
package bt.bencoding.model;

import bt.bencoding.model.rule.ExclusiveRule;
import bt.bencoding.model.rule.RequiredRule;
import bt.bencoding.model.rule.Rule;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import static bt.bencoding.model.ClassUtil.cast;
import static bt.bencoding.model.ClassUtil.castList;
import static bt.bencoding.model.ClassUtil.read;
import static bt.bencoding.model.ClassUtil.readNotNull;

/**
 * Builds an object model from a {@link java.util.Map}-based definition.
 *
 * @since 1.0
 */
public class JUMModelBuilder implements BEObjectModelBuilder {

    private static final String TYPE_KEY = "type";
    private static final String REQUIRED_KEY = "required";
    private static final String EXCLUSIVES_KEY = "exclusives";
    private static final String MAP_ENTRIES_KEY = "entries";
    private static final String MAP_ENTRY_KEY_KEY = "key";
    private static final String LIST_ELEMENTS_KEY = "elements";

    // TODO: allow defining custom types in separate files and re-use
    @Override
    public BEObjectModel buildModel(Map map) {
        // try reading custom object type and if it's not there resort to default types
        return readObjectModel(map).orElseGet(() -> {
            try {
                String sourceType = readType(map);
                switch (sourceType) {
                    case "dictionary": {
                        return buildMap(map);
                    }
                    case "list": {
                        return buildList(map);
                    }
                    case "binary": {
                        return new BEStringModel(true, Collections.emptyList());
                    }
                    case "string": {
                        return new BEStringModel(false, Collections.emptyList());
                    }
                    case "integer": {
                        return new BEIntegerModel(Collections.emptyList());
                    }
                    default: {
                        throw new IllegalArgumentException("Unsupported BE type: " + sourceType);
                    }
                }
            } catch (Exception e) {
                throw new RuntimeException("Failed to build BE model", e);
            }
        });
    }

    private Optional readObjectModel(Map map) {
        try {
            Object objectModel = read(map, Object.class, TYPE_KEY);
            if (objectModel == null || !Map.class.isAssignableFrom(objectModel.getClass())) {
                return Optional.empty();
            } else {
                return Optional.of(buildModel((Map) objectModel));
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to read type", e);
        }
    }

    private String readType(Map map) {
        try {
            return readNotNull(map, String.class, TYPE_KEY).toLowerCase();
        } catch (Exception e) {
            throw new RuntimeException("Failed to read type", e);
        }
    }

    private BEObjectModel buildMap(Map map) throws Exception {

        List entries = castList(Map.class, readNotNull(map, List.class, MAP_ENTRIES_KEY));
        Map entriesModel = new HashMap<>(entries.size() + 1);
        for (Map entry : entries) {
            String key = readNotNull(entry, String.class, MAP_ENTRY_KEY_KEY);
            entriesModel.put(key, buildModel(entry));
        }
        return new BEMapModel(entriesModel, buildMapValidation(map, entries));
    }

    private List buildMapValidation(Map map, List entries) throws Exception {

        List rules = new ArrayList<>(2);

        List required = entries.stream()
                .filter(this::isRequired)
                .map(entry -> {
                    try {
                        return readNotNull(entry, String.class, MAP_ENTRY_KEY_KEY);
                    } catch (Exception e) {
                        throw new RuntimeException("Unexpected error", e);
                    }
                })
                .collect(Collectors.toList());

        @SuppressWarnings("unchecked")
        List