Examples with Frequency mekanism.common.lib.frequency.Frequency used on opensource projects

Example 1 with Frequency

use of mekanism.common.lib.frequency.Frequency in project Mekanism by mekanism.

the class CCArgumentWrapper method wrapReturnType.

private static Object wrapReturnType(Object result) {
    if (result == null || result instanceof Number || result instanceof Boolean || result instanceof String) {
        // Short circuit if it doesn't need wrapping
        return result;
    } else if (result instanceof ResourceLocation || result instanceof UUID) {
        return result.toString();
    } else if (result instanceof ForgeRegistryEntry<?>) {
        return getName((ForgeRegistryEntry<?>) result);
    } else if (result instanceof ChemicalStack<?>) {
        ChemicalStack<?> stack = (ChemicalStack<?>) result;
        Map<String, Object> wrapped = new HashMap<>(2);
        wrapped.put("name", getName(stack.getType()));
        wrapped.put("amount", stack.getAmount());
        return wrapped;
    } else if (result instanceof FluidStack) {
        FluidStack stack = (FluidStack) result;
        return wrapStack(stack.getFluid(), "amount", stack.getAmount(), stack.getTag());
    } else if (result instanceof ItemStack) {
        ItemStack stack = (ItemStack) result;
        return wrapStack(stack.getItem(), "count", stack.getCount(), stack.getTag());
    } else if (result instanceof INBT) {
        Object wrapped = wrapNBT((INBT) result);
        if (wrapped != null) {
            return wrapped;
        }
    } else if (result instanceof Vector3i) {
        // BlockPos is covered by this case
        Vector3i pos = (Vector3i) result;
        Map<String, Object> wrapped = new HashMap<>(3);
        wrapped.put("x", pos.getX());
        wrapped.put("y", pos.getY());
        wrapped.put("z", pos.getZ());
        return wrapped;
    } else if (result instanceof Coord4D) {
        // BlockPos is covered by this case
        Coord4D coord = (Coord4D) result;
        Map<String, Object> wrapped = new HashMap<>(4);
        wrapped.put("x", coord.getX());
        wrapped.put("y", coord.getY());
        wrapped.put("z", coord.getZ());
        wrapped.put("dimension", wrapReturnType(coord.dimension.location()));
        return wrapped;
    } else if (result instanceof Frequency) {
        FrequencyIdentity identity = ((Frequency) result).getIdentity();
        Map<String, Object> wrapped = new HashMap<>(2);
        wrapped.put("key", wrapReturnType(identity.getKey()));
        wrapped.put("public", identity.isPublic());
        return wrapped;
    } else if (result instanceof Enum) {
        return ((Enum<?>) result).name();
    } else if (result instanceof IFilter) {
        Map<String, Object> wrapped = new HashMap<>();
        wrapped.put("type", wrapReturnType(((IFilter<?>) result).getFilterType()));
        if (result instanceof IItemStackFilter) {
            ItemStack stack = ((IItemStackFilter<?>) result).getItemStack();
            wrapped.put("item", wrapReturnType(stack.getItem()));
            if (!stack.isEmpty()) {
                CompoundNBT tag = stack.getTag();
                if (tag != null && !tag.isEmpty()) {
                    wrapped.put("itemNBT", wrapNBT(tag));
                }
            }
        } else if (result instanceof IMaterialFilter) {
            wrapped.put("materialItem", wrapReturnType(((IMaterialFilter<?>) result).getMaterialItem().getItem()));
        } else if (result instanceof IModIDFilter) {
            wrapped.put("modId", ((IModIDFilter<?>) result).getModID());
        } else if (result instanceof ITagFilter) {
            wrapped.put("tag", ((ITagFilter<?>) result).getTagName());
        }
        if (result instanceof MinerFilter) {
            MinerFilter<?> minerFilter = (MinerFilter<?>) result;
            wrapped.put("requiresReplacement", minerFilter.requiresReplacement);
            wrapped.put("replaceTarget", wrapReturnType(minerFilter.replaceTarget));
        } else if (result instanceof SorterFilter) {
            SorterFilter<?> sorterFilter = (SorterFilter<?>) result;
            wrapped.put("allowDefault", sorterFilter.allowDefault);
            wrapped.put("color", wrapReturnType(sorterFilter.color));
            wrapped.put("size", sorterFilter.sizeMode);
            wrapped.put("min", sorterFilter.min);
            wrapped.put("max", sorterFilter.max);
            if (sorterFilter instanceof SorterItemStackFilter) {
                SorterItemStackFilter filter = (SorterItemStackFilter) sorterFilter;
                wrapped.put("fuzzy", filter.fuzzyMode);
            }
        } else if (result instanceof QIOFilter) {
            QIOFilter<?> qioFilter = (QIOFilter<?>) result;
            if (qioFilter instanceof QIOItemStackFilter) {
                QIOItemStackFilter filter = (QIOItemStackFilter) qioFilter;
                wrapped.put("fuzzy", filter.fuzzyMode);
            }
        } else if (result instanceof OredictionificatorFilter) {
            OredictionificatorFilter<?, ?, ?> filter = (OredictionificatorFilter<?, ?, ?>) result;
            wrapped.put("target", filter.getFilterText());
            wrapped.put("selected", wrapReturnType(filter.getResultElement()));
        }
        return wrapped;
    } else if (result instanceof Map) {
        return ((Map<?, ?>) result).entrySet().stream().collect(Collectors.toMap(entry -> wrapReturnType(entry.getKey()), entry -> wrapReturnType(entry.getValue()), (a, b) -> b));
    } else if (result instanceof Collection) {
        // so there is no real difference at that point about the type it is
        return ((Collection<?>) result).stream().map(CCArgumentWrapper::wrapReturnType).collect(Collectors.toList());
    } else if (result instanceof Object[]) {
        // Note: This doesn't handle/deal with primitive arrays
        return Arrays.stream((Object[]) result).map(CCArgumentWrapper::wrapReturnType).toArray();
    }
    return result;
}

Example 2 with Frequency

use of mekanism.common.lib.frequency.Frequency in project Mekanism by mekanism.

the class MekanismUtils method addFrequencyToTileTooltip.

/**
 * @apiNote Only call on the client.
 */
public static void addFrequencyToTileTooltip(ItemStack stack, FrequencyType<?> frequencyType, List<ITextComponent> tooltip) {
    if (ItemDataUtils.hasData(stack, NBTConstants.COMPONENT_FREQUENCY, NBT.TAG_COMPOUND)) {
        CompoundNBT frequencyComponent = ItemDataUtils.getCompound(stack, NBTConstants.COMPONENT_FREQUENCY);
        if (frequencyComponent.contains(frequencyType.getName(), NBT.TAG_COMPOUND)) {
            Frequency frequency = frequencyType.create(frequencyComponent.getCompound(frequencyType.getName()));
            frequency.setValid(false);
            tooltip.add(MekanismLang.FREQUENCY.translateColored(EnumColor.INDIGO, EnumColor.GRAY, frequency.getName()));
            if (frequency.getOwner() != null) {
                String owner = OwnerDisplay.getOwnerName(MekanismClient.tryGetClientPlayer(), frequency.getOwner(), frequency.getClientOwner());
                if (owner != null) {
                    tooltip.add(MekanismLang.OWNER.translateColored(EnumColor.INDIGO, EnumColor.GRAY, owner));
                }
            }
            tooltip.add(MekanismLang.MODE.translateColored(EnumColor.INDIGO, EnumColor.GRAY, frequency.isPublic() ? MekanismLang.PUBLIC : MekanismLang.PRIVATE));
        }
    }
}

Example 3 with Frequency

use of mekanism.common.lib.frequency.Frequency in project Mekanism by mekanism.

the class GuiFrequencySelector method updateButtons.

private void updateButtons() {
    List<FREQ> frequencies = getFrequencies();
    if (lastFrequencies != frequencies) {
        // If the frequencies changed
        lastFrequencies = frequencies;
        List<String> text = new ArrayList<>(frequencies.size());
        for (Frequency freq : frequencies) {
            if (publicFreq) {
                text.add(freq.getName() + " (" + freq.getClientOwner() + ")");
            } else {
                text.add(freq.getName());
            }
        }
        scrollList.setText(text);
    }
    if (publicFreq) {
        publicButton.active = false;
        privateButton.active = true;
    } else {
        publicButton.active = true;
        privateButton.active = false;
    }
    if (scrollList.hasSelection()) {
        FREQ selectedFrequency = frequencies.get(scrollList.getSelection());
        FREQ currentFrequency = frequencySelector.getFrequency();
        // Enable the set button if there is not currently a frequency set or the selected frequency
        // is different from the one that is currently set
        setButton.active = currentFrequency == null || !currentFrequency.equals(selectedFrequency);
        // Enable the delete button if the player is the owner of the frequency
        deleteButton.active = Minecraft.getInstance().player != null && selectedFrequency.ownerMatches(Minecraft.getInstance().player.getUUID());
    } else {
        setButton.active = false;
        deleteButton.active = false;
    }
    // TODO: Rework this as it only really is needed when the status changes or the frequency changes
    frequencySelector.buttonsUpdated();
}