Java ObjectMappingException類代碼示例

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
public SignsConfig(File baseDir) {
    super(baseDir, "signs");

    for (Object objKey : config.getChildrenMap().keySet()) {
        if (objKey instanceof String) {
            String key = (String) objKey;
            if (Utils.isInt(key)) {
                Set<DonorSign> signs = new HashSet<>();
                System.out.println("key " + key);
                try {
                    for (Location<World> loc : stringsToLocArray(config.getChildrenMap().get(objKey).getList(TypeToken.of(String.class)))) {
                        if (loc != null && loc.getTileEntity().isPresent() && loc.getTileEntity().get() instanceof Sign) {
                            System.out.println("2");
                            signs.add(new DonorSign(Utils.getInt(key), loc));
                        }
                    }
                } catch (ObjectMappingException e) {
                    e.printStackTrace();
                }
                donorSigns.put(Utils.getInt(key), signs);
            }
        }
    }
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
@Override
public Location deserialize(TypeToken<?> typeToken, ConfigurationNode value) throws ObjectMappingException {
    String name = value.getNode("world").getValue(TypeToken.of(String.class));
    Double x = value.getNode("x").getValue(TypeToken.of(Double.class));
    Double y = value.getNode("y").getValue(TypeToken.of(Double.class));
    Double z = value.getNode("z").getValue(TypeToken.of(Double.class));

    Optional<World> optional = Sponge.getServer().getWorld(name);

    if (!optional.isPresent()) {
        throw new ObjectMappingException("Unknown world");
    }

    World world = optional.get();
    return world.getLocation(x, y, z);
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
/**
 * loads the cameras from the config
 *
 * may only be called after the worlds of the server have been loaded
 */
public void loadCameras() {
    plugin.getCameras().clear();

    // yes i know it is bad to register it every time the config is loaded but i doesn't seem to work otherwise...
    TypeSerializers.getDefaultSerializers().registerType(TypeToken.of(Location.class), new LocationSerializer());

    config.getNode("cameras").getChildrenList().forEach((node) -> {
        try {
            Camera cam = node.getValue(TypeToken.of(Camera.class));
            cam.setLocation(node.getNode("location").getValue(TypeToken.of(Location.class)));
            plugin.getCameras().put(cam.getId(), cam);
        } catch (ObjectMappingException e) {
            System.out.println(TypeSerializers.getDefaultSerializers().get(TypeToken.of(Location.class)));
            logger.warn("Couldn't load Camera: " + e.getMessage());
        }
    });

    logger.info(String.format("Loaded %d Cameras", plugin.getCameras().size()));
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
public static void initMcrmbCore() {
    commentedConfig = ConfigManager.get().getConfig();
    config.sid = commentedConfig.getNode("sid").getString();
    if (config.sid.equalsIgnoreCase("null")) {
        config.sid = null;
    }
    config.key = commentedConfig.getNode("key").getString();
    if (config.key.equalsIgnoreCase("null")) {
        config.key = null;
    }

    config.logApi = commentedConfig.getNode("logApi").getBoolean();
    config.renewOnJoin = commentedConfig.getNode("renewOnJoin").getBoolean();
    config.opModifyWhiteList = new ArrayList<>();
    try {
        config.opModifyWhiteList.addAll(commentedConfig.getNode("opModifyWhiteList").getList(TypeToken.of(String.class)));
    } catch (ObjectMappingException e) {
    }
    config.point = commentedConfig.getNode("point").getString().replace("&", "§");
    config.prefix = commentedConfig.getNode("prefix").getString().replace("&", "§");
    config.command = commentedConfig.getNode("command").getString();

}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
/**
 * Creates a config object of the specified type
 *
 * @param file The {@link Path} where the config file will be created
 * @param clazz The {@link Class} of the object that is being retrieved
 * @param loader The {@link ConfigurationLoader} that this config will use
 * @param <M> The type of object which will be created
 * @return The created config object, or null if an exception was thrown
 */
@SuppressWarnings("unchecked")
public <M extends BaseConfig> M createConfig(Path file, Class<M> clazz, ConfigurationLoader loader) {
    try {
        if (!Files.exists(file)) {
            Files.createFile(file);
        }

        TypeToken<M> token = TypeToken.of(clazz);
        ConfigurationNode node = loader.load(ConfigurationOptions.defaults().setObjectMapperFactory(this.factory));
        M config = node.getValue(token, clazz.newInstance());
        config.init(loader, node, token);
        config.save();
        return config;
    } catch (IOException | ObjectMappingException | IllegalAccessException | InstantiationException e) {
        e.printStackTrace();
        return null;
    }
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
private <T> void setInternalValue(T storageHandler) {
    if (storageHandler instanceof ConfigurationNode) {
        ConfigurationNode node = ((ConfigurationNode) storageHandler).getNode(this.key.get());
        if (this.comment != null && node instanceof CommentedConfigurationNode) {
            ((CommentedConfigurationNode) node).setComment(this.comment);
        }

        if (this.modified) {
            if (this.valueTypeToken != null) {
                try {
                    node.setValue(this.valueTypeToken, this.value);
                } catch (ObjectMappingException e) {
                    e.printStackTrace();
                }
            } else {
                node.setValue(this.value);
            }
            this.modified = false;
        }
    }
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
private <T, U extends BaseValue<T>> void deserializeForKeys(
        ConfigurationNode node, DataQuery dataQuery, BiConsumer<Key<U>, T> consumer) throws InvalidDataException
{
    if (KEYS.containsKey(dataQuery))
    {
        try
        {
            @SuppressWarnings("unchecked")
            Key<U> key = (Key<U>) KEYS.get(dataQuery);
            @SuppressWarnings("unchecked")
            TypeToken<T> elementToken = (TypeToken<T>) key.getElementToken();
            consumer.accept(key, Optional.ofNullable(node.getValue(elementToken))
                    .orElseThrow(() -> new InvalidDataException("No value present")));
        }
        catch (ObjectMappingException e)
        {
            throw new InvalidDataException(e);
        }
    }
    else if (!EXCEPTIONS.contains(dataQuery))
    {
        throw new InvalidDataException("No matched query present");
    }
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
@Override
public CuboidRegion deserialize(TypeToken<?> type, ConfigurationNode value) throws ObjectMappingException {
    int aX = value.getNode("parA", "x").getInt();
    int aY = value.getNode("parA", "y").getInt();
    int aZ = value.getNode("parA", "z").getInt();

    int bX = value.getNode("parB", "x").getInt();
    int bY = value.getNode("parB", "y").getInt();
    int bZ = value.getNode("parB", "z").getInt();

    // Check for degenerate dimensions (distance of 0)
    if (aX == bX) {
        bX++;
    }
    if (aY == bY) {
        bY++;
    }
    if (aZ == bZ) {
        bZ++;
    }

    return new CuboidRegion(new Vector3i(aX, aY, aZ), new Vector3i(bX, bY, bZ));
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
@Override
public Shop deserialize(TypeToken<?> type, ConfigurationNode value) throws ObjectMappingException {
    UUID shopUUID = value.getNode("shopUUID").getValue(TypeToken.of(UUID.class));
    String name = value.getNode("shopName").getString();
    UUID ownerUUID = value.getNode("ownerUUID").getValue(TypeToken.of(UUID.class));
    UUID renterUUID = value.getNode("renterUUID").getValue(TypeToken.of(UUID.class));
    Set<UUID> managerUUIDset = new HashSet<>(value.getNode("managerSet").getList(TypeToken.of(UUID.class)));
    Map<UUID, ShopItem> items = value.getNode("items").getList(TypeToken.of(ShopItem.class)).stream().collect(Collectors.toMap(ShopItem::getShopItemUUID, shopItem -> shopItem));
    boolean unlimitedMoney = value.getNode("unlimitedMoney").getBoolean();
    boolean unlimitedStock = value.getNode("unlimitedStock").getBoolean();
    String shopType = value.getNode("type").getString();
    double price = value.getNode("price").getDouble(-1);
    double rent = value.getNode("rent").getDouble(-1);

    return new Shop(shopUUID, name, ownerUUID, renterUUID, managerUUIDset, items, unlimitedMoney, unlimitedStock, shopType, price, rent, null);
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
@Override
public void serialize(TypeToken<?> type, Shop obj, ConfigurationNode value) throws ObjectMappingException {
    value.getNode("shopUUID").setValue(TypeToken.of(UUID.class), obj.getUUID());
    value.getNode("shopName").setValue(obj.getName());
    value.getNode("ownerUUID").setValue(TypeToken.of(UUID.class), obj.getOwnerUUID().orElse(null));
    value.getNode("renterUUID").setValue(TypeToken.of(UUID.class), obj.getRenterUUID());
    Set<UUID> managerUUIDSet = obj.getManagerUUIDSet();
    value.getNode("managerSet").setValue(new TypeToken<List<UUID>>() {
    }, new ArrayList<>(managerUUIDSet));
    value.getNode("items").setValue(new TypeToken<List<ShopItem>>() {
    }, new ArrayList<>(obj.getItems().values()));
    value.getNode("unlimitedMoney").setValue(obj.isUnlimitedMoney());
    value.getNode("unlimitedStock").setValue(obj.isUnlimitedStock());
    value.getNode("type").setValue(obj.getType());
    value.getNode("price").setValue(obj.getPrice());
    value.getNode("rent").setValue(obj.getRent());
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
@Listener //During this state, the plugin gets ready for initialization. Logger and config
public void onPreInit(GamePreInitializationEvent preInitEvent) {
    logger.info("Setting up config");

    rootNode = configManager.createEmptyNode();
    try {
        configMapper = ObjectMapper.forClass(ColorConsoleConfig.class).bindToNew();

        rootNode = configManager.load();
        configMapper.populate(rootNode);

        //add and save missing values
        configMapper.serialize(rootNode);
        configManager.save(rootNode);
    } catch (IOException | ObjectMappingException ioEx) {
        logger.error("Cannot save default config", ioEx);
        return;
    }

    installLogFormat();
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
public EMessageBuilder getList(String name, EMessageBuilder builder, ConfigurationNode node, boolean prefix) {
  	try {
	List<String> messages = node.getList(TypeToken.of(String.class));
	if (!messages.isEmpty()) {
  			if (this.plugin.getChat() != null) {
  				builder.chat(new EFormatListString(this.plugin.getChat().replace(messages)), prefix);
  			} else {
  				builder.chat(new EFormatListString(node.getList(TypeToken.of(String.class))), prefix);
  			}
	}
} catch (ObjectMappingException e) {
	this.plugin.getELogger().warn("Impossible de charger la liste des messages : '" + name + "'");
	builder.chat(new EFormatString(name), false);
}
return builder;
  }
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
synchronized public void loadData() throws IOException, ObjectMappingException {
	HoconConfigurationLoader loader = getDataLoader();
	ConfigurationNode rootNode = loader.load();

	List<Kit> kitsList = rootNode.getNode("Kits").getList(TypeToken.of(Kit.class));
	this.kits = new HashMap<String, Kit>();
	for (Kit kit : kitsList) {
		this.kits.put(kit.getName().toLowerCase(), kit);
	}

	List<PlayerData> playersDataList = rootNode.getNode("PlayersData").getList(TypeToken.of(PlayerData.class));
	this.playersData = new HashMap<UUID, PlayerData>();
	for (PlayerData pd : playersDataList) {
		this.playersData.put(pd.getPlayerUUID(), pd);
	}
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
public void registerCollection(String collection) {
	if (collection.equals(PermissionService.SUBJECTS_DEFAULT)) return;
	
	ConfigurationNode config = this.get("collections." + collection).getNode(EPConfig.DEFAULT);
	boolean save = false;
	
	List<String> worlds = new ArrayList<String>();
	try {
		worlds.addAll(config.getList(TypeToken.of(String.class)));
	} catch (ObjectMappingException e) {}
	
	for (World world : this.plugin.getGame().getServer().getWorlds()) {
		if (this.getTypeWorld(collection, world.getName()).equals(EPConfig.DEFAULT) && !worlds.contains(world.getName())) {
			worlds.add(world.getName());
			save = true;
		}
	}
	
	config.setValue(worlds);
	if (config.isVirtual()) {
		config.setValue(ImmutableList.of());
		save = true;
	}
	
	if (save) this.save(true);
}
 

import ninja.leaping.configurate.objectmapping.ObjectMappingException; //導入依賴的package包/類
public void registerWorld(String world) {
	boolean save = false;
	
	for (String collection : this.getCollections()) {
		if (!this.getWorld(collection, world).isPresent()) {
			CommentedConfigurationNode config = this.get("collections." + collection).getNode(EPConfig.DEFAULT);
			
			try {
				List<String> worlds = new ArrayList<String>();
				worlds.addAll(config.getList(TypeToken.of(String.class)));
				worlds.add(world);
				config.setValue(worlds);
				
				save = true;
			} catch (ObjectMappingException e) {}
		}
	}
	
	if (save) this.save(true);
}