net.minecraft.nbt.CompressedStreamTools Java Examples

public static Template getBuiltinTemplate(World world, ResourceLocation templateId) {
    if (templateMap.containsKey(templateId)) {
        return templateMap.get(templateId);
    }
    Template template = new Template();
    String resourcePath = "/assets/" + templateId.getResourceDomain() + "/structures/" + templateId.getResourcePath() + ".nbt";
    InputStream inputStream = TemplateManager.class.getResourceAsStream(resourcePath);
    if (inputStream != null) {
        try {
            NBTTagCompound nbttagcompound = CompressedStreamTools.readCompressed(inputStream);
            if (!nbttagcompound.hasKey("DataVersion", 99)) {
                nbttagcompound.setInteger("DataVersion", 500);
            }
            DataFixer dataFixer = world.getMinecraftServer().getDataFixer();
            template.read(dataFixer.process(FixTypes.STRUCTURE, nbttagcompound));
        } catch (IOException exception) {
            GTLog.logger.error("Failed to load builtin template {}", templateId, exception);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
    } else {
        GTLog.logger.warn("Failed to find builtin structure with path {}", resourcePath);
    }
    templateMap.put(templateId, template);
    return template;
}
 

@Override
public void decodeInto(ChannelHandlerContext ctx, ByteBuf buf, EntityPlayer player) throws IOException
{
	super.decodeInto(ctx, buf, player);
	if (ship != null)
	{
		DataInputStream in = new DataInputStream(new ByteBufInputStream(buf));
		try
		{
			tagCompound = CompressedStreamTools.read(in);
		} catch (IOException e)
		{
			throw e;
		} finally
		{
			in.close();
		}
	}
}
 

private static Template loadTemplate(InputStream is)
{
    if (is == null)
        return null;
    try
    {
        NBTTagCompound nbt = CompressedStreamTools.readCompressed(is);
        Template template = new Template();
        template.read(nbt);
        return template;
    }
    catch (IOException e)
    {
        e.printStackTrace();
    }
    finally
    {
        if (is != null)
            IOUtils.closeQuietly(is);
    }
    return null;
}
 

public static void writeNBTTagCompoundToBuffer(ByteBuf buf, NBTTagCompound tag)
{
    if (tag == null)
    {
        buf.writeByte(0);
        return;
    }

    try
    {
        CompressedStreamTools.write(tag, new ByteBufOutputStream(buf));
    }
    catch (IOException ioexception)
    {
        EnderUtilities.logger.error("IOException while trying to write a NBTTagCompound to ByteBuf");
        throw new EncoderException(ioexception);
    }
}
 

private void save(boolean force) {
    if (!dirtyStorage.isEmpty() || force) {
        for (AbstractEnderStorage inv : dirtyStorage) {
            saveTag.setTag(inv.freq + "|" + inv.owner + "|" + inv.type(), inv.saveToTag());
            inv.setClean();
        }

        dirtyStorage.clear();

        try {
            File saveFile = saveFiles[saveTo];
            if (!saveFile.exists())
                saveFile.createNewFile();
            DataOutputStream dout = new DataOutputStream(new FileOutputStream(saveFile));
            CompressedStreamTools.writeCompressed(saveTag, dout);
            dout.close();
            FileOutputStream fout = new FileOutputStream(saveFiles[2]);
            fout.write(saveTo);
            fout.close();
            saveTo ^= 1;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
 

public static void saveNBTToPath( File file, NBTTagCompound nbt )
{
    try
    {
        if( file != null )
        {
            file.getParentFile().mkdirs();
            OutputStream output = new BufferedOutputStream( new FileOutputStream( file ) );
            try
            {
                CompressedStreamTools.writeCompressed( nbt, output );
            }
            finally
            {
                output.close();
            }
        }
    }
    catch( IOException e )
    {
        QCraft.log( "Warning: failed to save QCraft entanglement info" );
    }
}
 

public static NBTTagCompound loadNBTFromPath( File file )
{
    try
    {
        if( file != null && file.exists() )
        {
            InputStream input = new BufferedInputStream( new FileInputStream( file ) );
            try
            {
                return CompressedStreamTools.readCompressed( input );
            }
            finally
            {
                input.close();
            }
        }
    }
    catch( IOException e )
    {
        QCraft.log( "Warning: failed to load QCraft entanglement info" );
    }
    return null;
}
 

/**
 * Saves NBT data in the world folder.
 * @param file File to save data to
 * @param data Data to save
 * @return True on success.
 */
public boolean saveFile(File file, NBTTagCompound data) {
	try {
		File tempFile = new File(file.getParent(), file.getName().replaceFirst("\\.nbt$", ".tmp.nbt"));

		CompressedStreamTools.writeCompressed(data, new FileOutputStream(tempFile));

		if (file.exists()) {
			file.delete();
		}

		tempFile.renameTo(file);
		return true;
	} catch (Exception e) {
		Game.logger().error("Failed to queueSave {}!", file.getName(), e);
		e.printStackTrace();
		return false;
	}
}
 

/**
 * Saves NBT data in the world folder.
 * @param file File to save data to
 * @param data Data to save
 * @return True on success.
 */
public boolean saveFile(File file, NBTTagCompound data) {
	try {
		File tempFile = new File(file.getParent(), file.getName().replaceFirst("\\.nbt$", ".tmp.nbt"));

		CompressedStreamTools.writeCompressed(data, new FileOutputStream(tempFile));

		if (file.exists()) {
			file.delete();
		}

		tempFile.renameTo(file);
		return true;
	} catch (Exception e) {
		Game.logger().error("Failed to queueSave {}!", file.getName(), e);
		e.printStackTrace();
		return false;
	}
}
 

/**
 * Saves NBT data in the world folder.
 * @param file File to save data to
 * @param data Data to save
 * @return True on success.
 */
public boolean saveFile(File file, NBTTagCompound data) {
	try {
		File tempFile = new File(file.getParent(), file.getName().replaceFirst("\\.nbt$", ".tmp.nbt"));

		CompressedStreamTools.writeCompressed(data, new FileOutputStream(tempFile));

		if (file.exists()) {
			file.delete();
		}

		tempFile.renameTo(file);
		return true;
	} catch (Exception e) {
		Game.logger().error("Failed to queueSave {}!", file.getName());
		e.printStackTrace();
		return false;
	}
}
 

public static NBTTagCompound readNBT(File file) throws IOException {
    if (!file.exists()) {
        return null;
    }
    FileInputStream in = new FileInputStream(file);
    NBTTagCompound tag;
    try {
        tag = CompressedStreamTools.readCompressed(in);
    } catch (ZipException e) {
        if (e.getMessage().equals("Not in GZIP format")) {
            tag = CompressedStreamTools.read(file);
        } else {
            throw e;
        }
    }
    in.close();
    return tag;
}
 

private void save(boolean force) {
    if (!dirtyStorage.isEmpty() || force) {
        for (AbstractEnderStorage inv : dirtyStorage) {
            saveTag.put(inv.freq + ",type=" + inv.type(), inv.saveToTag());
            inv.setClean();
        }

        dirtyStorage.clear();

        try {
            File saveFile = saveFiles[saveTo];
            if (!saveFile.exists()) {
                saveFile.createNewFile();
            }
            DataOutputStream dout = new DataOutputStream(new FileOutputStream(saveFile));
            CompressedStreamTools.writeCompressed(saveTag, dout);
            dout.close();
            FileOutputStream fout = new FileOutputStream(saveFiles[2]);
            fout.write(saveTo);
            fout.close();
            saveTo ^= 1;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
 

public void saveServerList(List<ServerData> servers, Minecraft mc) {
    try {
        NBTTagList nbttaglist = new NBTTagList();

        for (ServerData server : servers) {
            NBTTagCompound nbtCompound = server.getNBTCompound();
            nbttaglist.appendTag(nbtCompound);
        }

        NBTTagCompound nbttagcompound = new NBTTagCompound();
        nbttagcompound.setTag("servers", nbttaglist);
        CompressedStreamTools.safeWrite(nbttagcompound, new File(mc.mcDataDir, "servers.dat"));
    } catch (Exception exception) {
        Hyperium.LOGGER.error("Save server list error", exception);
    }
}
 

public void loadServerList(List<ServerData> servers, Minecraft mc) {
    try {
        servers.clear();
        NBTTagCompound nbttagcompound = CompressedStreamTools
            .read(new File(mc.mcDataDir, "servers.dat"));

        if (nbttagcompound == null) return;

        NBTTagList nbttaglist = nbttagcompound.getTagList("servers", 10);

        int bound = nbttaglist.tagCount();
        for (int i = 0; i < bound; i++) {
            ServerData serverDataFromNBTCompound = ServerData.getServerDataFromNBTCompound(nbttaglist.getCompoundTagAt(i));
            servers.add(serverDataFromNBTCompound);
        }
    } catch (Exception exception) {
        Hyperium.LOGGER.error("Failed to load server list", exception);
    }
}
 

public void read() throws IOException{
	if (file.exists() && file.canRead()){
		NBTTagCompound root = CompressedStreamTools.read(file);
		for (int i =0; i < 7; ++i){
			String name = "slot" + (i+1);
			if (root.hasKey(name))
				tags[i].tag = root.getCompoundTag(name);
			if (root.hasKey(name+"Name"))
				tags[i].name = root.getString(name+"Name");
		}
	}
}
 

public void dumpNBT(File file) throws IOException {
    NBTTagList list = new NBTTagList();
    for (ItemStack stack : ItemPanel.items)
        list.appendTag(stack.writeToNBT(new NBTTagCompound()));

    NBTTagCompound tag = new NBTTagCompound();
    tag.setTag("list", list);

    CompressedStreamTools.writeCompressed(tag, new FileOutputStream(file));
}
 

/**
 * Reads a {@link CompoundNBT} from the stream.
 *
 * @return The {@link CompoundNBT}.
 */
@Nullable
default CompoundNBT readCompoundNBT() {
    if (!readBoolean()) {
        return null;
    } else {
        try {
            return CompressedStreamTools.read(toDataInput(), new NBTSizeTracker(2097152L));
        } catch (IOException e) {
            throw new EncoderException("Failed to read CompoundNBT from stream.", e);
        }
    }
}
 

public static void readFromDisk()
{
    // Clear the data structures when reading the data for a world/save, so that valid Energy Bridges
    // from another world won't carry over to a world/save that doesn't have the file yet.
    BRIDGE_LOCATIONS.clear();
    BRIDGE_COUNTS.clear();
    bridgeCountInEndDimensions = 0;

    try
    {
        File saveDir = DimensionManager.getCurrentSaveRootDirectory();

        if (saveDir == null)
        {
            return;
        }

        File file = new File(new File(saveDir, Reference.MOD_ID), "energybridges.dat");

        if (file.exists() && file.isFile())
        {
            FileInputStream is = new FileInputStream(file);
            readFromNBT(CompressedStreamTools.readCompressed(is));
            is.close();
        }
    }
    catch (Exception e)
    {
        EnderUtilities.logger.warn("Failed to read Energy Bridge data from file!", e);
    }
}
 

public void readFromDisk()
{
    // Clear the data structures when reading the data for a world/save, so that data
    // from another world won't carry over to a world/save that doesn't have the file yet.
    this.properties.clear();
    this.indices.clear();

    try
    {
        File saveDir = DimensionManager.getCurrentSaveRootDirectory();

        if (saveDir == null)
        {
            return;
        }

        File file = new File(new File(saveDir, Reference.MOD_ID), FILE_NAME_BASE + ".dat");

        if (file.exists() && file.isFile())
        {
            this.readFromNBT(CompressedStreamTools.readCompressed(new FileInputStream(file)));
        }
    }
    catch (Exception e)
    {
        EnderUtilities.logger.warn("Failed to read Placement Properties data from file");
    }
}
 

private void readTemplateFromStream(String id, InputStream stream) throws IOException
{
    NBTTagCompound nbt = CompressedStreamTools.readCompressed(stream);

    if (nbt.hasKey("DataVersion", Constants.NBT.TAG_ANY_NUMERIC) == false)
    {
        nbt.setInteger("DataVersion", 500);
    }

    TemplateEnderUtilities template = new TemplateEnderUtilities();
    template.read(this.fixer.process(FixTypes.STRUCTURE, nbt));
    this.templates.put(id, template);
}
 

private void readTemplateMetadataFromStream(String id, InputStream stream) throws IOException
{
    NBTTagCompound nbt = CompressedStreamTools.readCompressed(stream);
    TemplateMetadata templateMeta = new TemplateMetadata();
    templateMeta.read(nbt);
    this.templateMetas.put(id, templateMeta);
}
 

public static NBTTagCompound readNBTTagCompoundFromBuffer(ByteBuf buf) throws IOException
{
    int i = buf.readerIndex();
    byte b0 = buf.readByte();

    if (b0 == 0)
    {
        return null;
    }
    else
    {
        buf.readerIndex(i);
        return CompressedStreamTools.read(new ByteBufInputStream(buf), new NBTSizeTracker(2097152L));
    }
}
 

public void write() throws IOException{
	NBTTagCompound root = new NBTTagCompound();
	for (int i = 0; i <7; ++i){
		root.setTag("slot" + (i+1), tags[i].tag);
		root.setString("slot" + (i+1)+"Name", tags[i].name);
	}
	CompressedStreamTools.write(root, file);
}
 

@Override
public void encodeInto(ChannelHandlerContext ctx, ByteBuf buf) throws IOException
{
	super.encodeInto(ctx, buf);
	tagCompound = new NBTTagCompound();
	NBTTagList list = new NBTTagList();
	for (TileEntity te : ship.getShipChunk().chunkTileEntityMap.values())
	{
		NBTTagCompound nbt = new NBTTagCompound();
		if (te instanceof TileEntityHelm)
		{
			((TileEntityHelm) te).writeNBTforSending(nbt);
		} else
		{
			te.writeToNBT(nbt);
		}
		list.appendTag(nbt);
	}
	tagCompound.setTag("list", list);
	DataOutputStream out = new DataOutputStream(new ByteBufOutputStream(buf));
	try
	{
		CompressedStreamTools.write(tagCompound, out);
		out.flush();
	} catch (IOException e)
	{
		throw e;
	} finally
	{
		out.close();
	}
}
 

public static NBTTagCompound readNBTTagCompound(ByteBuf dataIn) {
  try {
    short size = dataIn.readShort();
    if (size < 0) {
      return null;
    } else {
      byte[] buffer = new byte[size];
      dataIn.readBytes(buffer);
      return CompressedStreamTools.readCompressed(new ByteArrayInputStream(buffer));
    }
  } catch (IOException e) {
    FMLCommonHandler.instance().raiseException(e, "Custom Packet", true);
    return null;
  }
}
 

public static void writeNBTTagCompound(NBTTagCompound compound, ByteBuf dataout) {
  try {
    if (compound == null) {
      dataout.writeShort(-1);
    } else {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      CompressedStreamTools.writeCompressed(compound, baos);
      byte[] buf = baos.toByteArray();
      dataout.writeShort((short) buf.length);
      dataout.writeBytes(buf);
    }
  } catch (IOException e) {
    FMLCommonHandler.instance().raiseException(e, "IoUtil.writeNBTTagCompound", true);
  }
}
 

public MCDataOutputWrapper writeNBTTagCompound(NBTTagCompound nbt) {
    if (nbt == null)
        this.writeByte(0);
    else try {
        CompressedStreamTools.write(nbt, dataout);
    } catch (IOException ioexception) {
        throw new EncoderException(ioexception);
    }
    return this;
}
 

/**
 * This function returns fingerprint of NBTTag. It can be used to compare two tags
 */
public static String getNBTHash(NBTTagCompound tag) {
	try {
		MessageDigest digest = MessageDigest.getInstance("MD5");
		OutputStream dump = new NullOutputStream();
		DigestOutputStream hasher = new DigestOutputStream(dump, digest);
		DataOutput output = new DataOutputStream(hasher);
		CompressedStreamTools.write(tag, output);
		byte[] hash = digest.digest();
		return new String(Hex.encodeHex(hash));
	} catch (IOException | NoSuchAlgorithmException e) {
		throw new RuntimeException(e);
	}
}
 

public NBTTagCompound loadFile(File file) {
	try {
		if (file.exists()) {
			return CompressedStreamTools.readCompressed(new FileInputStream(file));
		} else {
			return new NBTTagCompound();
		}
	} catch (Exception e) {
		Game.logger().error("Failed to load {}!", file.getName(), e);
		e.printStackTrace();
		return null;
	}
}
 

/**
 * Writes a {@link CompoundNBT} to the stream.
 *
 * @param tag The {@link CompoundNBT}.
 * @return The same stream.
 */
default MCDataOutput writeCompoundNBT(CompoundNBT tag) {
    if (tag == null) {
        writeBoolean(false);
    } else {
        try {
            writeBoolean(true);
            CompressedStreamTools.write(tag, toDataOutput());
        } catch (IOException e) {
            throw new EncoderException("Failed to write CompoundNBT to stream.", e);
        }
    }
    return this;
}