java类net.minecraft.nbt.NBTTagLong的实例源码

@Override
public void readFromNBT(NBTTagCompound tag) {
    NBTTagList list = tag.getTagList("blocks", Constants.NBT.TAG_LONG);
    blocks.clear();
    for (int i = 0; i < list.tagCount(); i++) {
        blocks.add(BlockPos.fromLong(((NBTTagLong) list.get(i)).getLong()));
    }
    list = tag.getTagList("leaves", Constants.NBT.TAG_COMPOUND);
    leavesToTick.clear();
    for (int i = 0; i < list.tagCount(); i++) {
        NBTTagCompound tc = list.getCompoundTagAt(i);
        BlockPos pos = BlockPos.fromLong(tc.getLong("p"));
        int counter = tc.getInteger("c");
        leavesToTick.put(pos, counter);
    }
}

@Override
public void deserializeNBT(NBTTagCompound nbt)
{
    this.growthRanges[0].deserializeNBT(nbt.getCompoundTag("tGrowthRangeMinimal"));
    this.growthRanges[1].deserializeNBT(nbt.getCompoundTag("tGrowthRangeOptimal"));
    this.growthRanges[2].deserializeNBT(nbt.getCompoundTag("tGrowthRangePerfect"));
    this.humidityGrowthRange = Pair.of(nbt.getCompoundTag("hGrowthRange").getFloat("min"), nbt.getCompoundTag("hGrowthRange").getFloat("max"));
    this.generation = nbt.getInteger("generation");
    this.wild = nbt.getBoolean("wild");
    this.type = EnumCrop.values()[nbt.getByte("type")];
    this.plantedAt = new Calendar();
    if (nbt.hasKey("plantedAt"))
    {
        this.plantedAt.deserializeNBT((NBTTagLong) nbt.getTag("plantedAt"));
    }

    this.health = nbt.getFloat("health");
    this.growthRate = nbt.getFloat("growthRate");
    this.waterConsumption = nbt.getFloat("waterConsumption");
    this.growth = nbt.getFloat("growth");
    this.nutrientConsumption.clear();
    nbt.getTagList("nutrientConsumption", NBT.TAG_COMPOUND).forEach(tag -> this.nutrientConsumption.put(EnumPlantNutrient.values()[((NBTTagCompound)tag).getByte("nutrient")], ((NBTTagCompound)tag).getFloat("amount")));
}

@Test
public void test_merge__Can_create_new_Tag() {
  // Given:
  NBTTagCompound nbt = new NBTTagCompound();

  Table data = new DefaultTable();
  String key = "my_key";
  long value = 53;
  data.rawset(key, value);

  // When:
  NBTTagCompound actual = underTest.merge(nbt, data);

  // Then:
  assertThat(actual.getKeySet()).containsOnly(key);
  assertThat(actual.getTag(key)).isEqualTo(new NBTTagLong(value));
}

@Test
public void test_toNbtCompound__With_numeric_Value() {
  // Given:
  Table data = new DefaultTable();
  String key = "my_key";
  long value = 42;
  data.rawset(key, value);
  String keyString = String.valueOf(key);

  // When:
  NBTTagCompound actual = underTest.toNbtCompound(data);

  // Then:
  assertThat(actual.getKeySet()).containsOnly(keyString);
  assertThat(actual.getTag(keyString)).isEqualTo(new NBTTagLong(value));
}

@Test
public void test_toNbtCompound__With_Compound_Value() {
  // Given:
  Table data = new DefaultTable();
  String key = "my_key";
  Table value = new DefaultTable();
  data.rawset(key, value);
  String key2 = "my_key2";
  long value2 = 42;
  value.rawset(key2, value2);

  // When:
  NBTTagCompound actual = underTest.toNbtCompound(data);

  // Then:
  assertThat(actual.getKeySet()).containsOnly(key);
  assertThat(actual.getTag(key)).isExactlyInstanceOf(NBTTagCompound.class);
  NBTTagCompound actualValue = actual.getCompoundTag(key);
  assertThat(actualValue.getKeySet()).containsOnly(key2);
  assertThat(actualValue.getTag(key2)).isEqualTo(new NBTTagLong(value2));
}

@Override
public void readFromNBT(NBTTagCompound tag) {
    super.readFromNBT(tag);

    if (tag.hasKey("Energy")) {
        energy.receiveEnergy(tag.getInteger("Energy"), false);
    }

    if (tag.hasKey("CurrentPos")) {
        currentPos = BlockPos.fromLong(tag.getLong("CurrentPos"));
    }

    if (tag.hasKey("Range")) {
        range = tag.getInteger("Range");
    }

    if (tag.hasKey("Surfaces")) {
        NBTTagList surfaces = tag.getTagList("Surfaces", Constants.NBT.TAG_LONG);

        for (NBTBase surface : surfaces) {
            this.surfaces.add(BlockPos.fromLong(((NBTTagLong) surface).getLong()));
        }
    }

    tank.readFromNBT(tag);
}

private void linkPortalWithOrigin(EntityPlayer player, World world, ItemStack stack, ControlBlockLocation thisPortal,
        PortalLinkerOrigin remoteInfo) {

    ControlBlockLocation remotePortal = findControllerBlock(world, remoteInfo.pos, STANDARD_SIZER);

    stack.setTagInfo("origin", new NBTTagLong(0));
    stack.setTagInfo("dimid", new NBTTagInt(0));

    if (remotePortal == null) {
        return;
    }

    linkPortalTo(world, thisPortal, remotePortal, remoteInfo.dimId, remoteInfo.side);
    linkPortalTo(world, remotePortal, thisPortal, player.dimension, getSide(player, thisPortal));

    playSound(player);
    stack.damageItem(1, player);
}

private static void asJson(NBTBase tag, StringBuilder builder) {
    switch(tag.getId()) {
    case NBT.TAG_BYTE: builder.append(((NBTTagByte)tag).getByte()).append('b'); break;
    case NBT.TAG_SHORT: builder.append(((NBTTagShort)tag).getByte()).append('b'); break;
    case NBT.TAG_INT: builder.append(((NBTTagInt)tag).getInt()); break;
    case NBT.TAG_LONG: builder.append(((NBTTagLong)tag).getByte()).append('l'); break;
    case NBT.TAG_FLOAT: builder.append(((NBTTagFloat)tag).getFloat()).append('f'); break;
    case NBT.TAG_DOUBLE: builder.append(((NBTTagDouble)tag).getDouble()).append('d'); break;
    case NBT.TAG_STRING: builder.append('"').append(((NBTTagString)tag).getString()).append('"'); break;
    case NBT.TAG_BYTE_ARRAY: builder.append(Arrays.toString(((NBTTagByteArray)tag).getByteArray())); break;
    case NBT.TAG_INT_ARRAY: builder.append(Arrays.toString(((NBTTagIntArray)tag).getIntArray())); break;
    case NBT.TAG_COMPOUND: asJson((NBTTagCompound) tag, builder); break;
    case NBT.TAG_LIST: asJson((NBTTagList) tag, builder); break;
    }

}

/** Creates and returns a primitive NBT tag from a value.
 *  If the value already is an NBT tag, it is returned instead. */
public static NBTBase createTag(Object value) {
    if (value == null)
        throw new IllegalArgumentException("value is null");
    if (value instanceof NBTBase) return (NBTBase)value;
    if (value instanceof Byte)    return new NBTTagByte((Byte)value);
    if (value instanceof Short)   return new NBTTagShort((Short)value);
    if (value instanceof Integer) return new NBTTagInt((Integer)value);
    if (value instanceof Long)    return new NBTTagLong((Long)value);
    if (value instanceof Float)   return new NBTTagFloat((Float)value);
    if (value instanceof Double)  return new NBTTagDouble((Double)value);
    if (value instanceof String)  return new NBTTagString((String)value);
    if (value instanceof byte[])  return new NBTTagByteArray((byte[])value);
    if (value instanceof int[])   return new NBTTagIntArray((int[])value);
    throw new IllegalArgumentException("Can't create an NBT tag of value: " + value);
}

public static Object getObject(NBTBase base)
{
    if(base instanceof NBTTagByte)
        return ((NBTTagByte)base).func_150290_f();
    if(base instanceof NBTTagShort)
        return ((NBTTagShort)base).func_150289_e();
    if(base instanceof NBTTagInt)
        return ((NBTTagInt)base).func_150287_d();
    if(base instanceof NBTTagLong)
        return ((NBTTagLong)base).func_150291_c();
    if(base instanceof NBTTagFloat)
        return ((NBTTagFloat)base).func_150288_h();
    if(base instanceof NBTTagDouble)
        return ((NBTTagDouble)base).func_150286_g();
    if(base instanceof NBTTagByteArray)
        return ((NBTTagByteArray)base).func_150292_c();
    if(base instanceof NBTTagString)
        return ((NBTTagString)base).func_150285_a_();
    if(base instanceof NBTTagList)
        return base;
    if(base instanceof NBTTagCompound)
        return ((NBTTagCompound)base);
    if(base instanceof NBTTagIntArray)
        return ((NBTTagIntArray)base).func_150302_c();
    return null;
}

@Override
public NBTTagCompound writeToNBT(NBTTagCompound tagCompound) {
    tagCompound = super.writeToNBT(tagCompound);
    tagCompound.setBoolean(IS_MASTER, isMaster);

    NBTTagList slaveList = new NBTTagList();
    for (BlockPos slavePos : slaves) {
        slaveList.appendTag(new NBTTagLong(slavePos.toLong()));
    }
    tagCompound.setTag(SLAVES, slaveList);

    if (masterPos != null) {
        tagCompound.setLong(MASTER_POS, masterPos.toLong());
    }
    return tagCompound;
}

@Override
public void readFromNBT(NBTTagCompound tagCompound) {
    super.readFromNBT(tagCompound);
    isMaster = tagCompound.getBoolean(IS_MASTER);

    NBTTagList tagList = tagCompound.getTagList(SLAVES, Constants.NBT.TAG_LONG);
    for (int i = 0; i < tagList.tagCount(); i++) {
        NBTBase tag = tagList.get(i);
        if (tag instanceof NBTTagLong) {
            BlockPos blockPos = BlockPos.fromLong(((NBTTagLong) tag).getLong());
            slaves.add(blockPos);
        }
    }

    masterPos = BlockPos.fromLong(tagCompound.getLong(MASTER_POS));
}

private static void setValidValue(Node<NamedNBT> node, String value){
    NamedNBT named = node.getObject();
    NBTBase base = named.getNBT();

    if (base instanceof NBTTagByte)
        named.setNBT(new NBTTagByte(ParseHelper.parseByte(value)));
    if (base instanceof NBTTagShort)
        named.setNBT(new NBTTagShort(ParseHelper.parseShort(value)));
    if (base instanceof NBTTagInt)
        named.setNBT(new NBTTagInt(ParseHelper.parseInt(value)));
    if (base instanceof NBTTagLong)
        named.setNBT(new NBTTagLong(ParseHelper.parseLong(value)));
    if(base instanceof NBTTagFloat)
        named.setNBT(new NBTTagFloat(ParseHelper.parseFloat(value)));
    if(base instanceof NBTTagDouble)
        named.setNBT(new NBTTagDouble(ParseHelper.parseDouble(value)));
    if(base instanceof NBTTagByteArray)
        named.setNBT(new NBTTagByteArray(ParseHelper.parseByteArray(value)));
    if(base instanceof NBTTagIntArray)
        named.setNBT(new NBTTagIntArray(ParseHelper.parseIntArray(value)));
    if (base instanceof NBTTagString)
        named.setNBT(new NBTTagString(value));
}

public void createFromItemNBT(NBTTagCompound tag)
{
    this.uprootedAt = Optional.of(new Calendar());
    if (tag.hasKey("uprootedAt", NBT.TAG_LONG))
    {
        this.uprootedAt.get().deserializeNBT((NBTTagLong) tag.getTag("uprootedAt"));
    }

    this.deserializeNBT(tag);
}

@Override
public void deserializeNBT(NBTTagCompound nbt)
{
    this.moistureLevel = nbt.getFloat("moisture");
    for (NBTBase tag : nbt.getTagList("nutrientData", NBT.TAG_COMPOUND))
    {
        NBTTagCompound tagCompound = (NBTTagCompound) tag;
        this.nutrientData.put(EnumPlantNutrient.values()[tagCompound.getByte("key")], tagCompound.getFloat("value"));
    }

    if (nbt.hasKey("calendar"))
    {
        this.timeKeeper.deserializeNBT((NBTTagLong) nbt.getTag("calendar"));
    }
}

@Override
public void deserializeNBT(NBTTagCompound nbt)
{
    this.stats = new CropStats();
    this.stats.deserializeNBT(nbt.getCompoundTag("stats"));
    this.isSick = nbt.getBoolean("eaten");
    this.timeKeeper.deserializeNBT((NBTTagLong) nbt.getTag("calendar"));
}

public Calendar getLastTickTime(ItemStack is)
{
    Calendar ret = new Calendar();
    if (is.getOrCreateSubCompound("exp.foodData").hasKey("lastTick"))
    {
        ret.deserializeNBT((NBTTagLong) is.getOrCreateSubCompound("exp.foodData").getTag("lastTick"));
    }

    return ret;
}

@Override
public void deserializeNBT(NBTTagCompound nbt)
{
    this.packID = new UUID(nbt.getLong("idMost"), nbt.getLong("idLeast"));
    this.leaderUUID = new UUID(nbt.getLong("leaderMost"), nbt.getLong("leaderLeast"));
    this.entitiesSet.clear();
    Iterator<NBTBase> iter = nbt.getTagList("entities", Constants.NBT.TAG_LONG).iterator();
    while (iter.hasNext())
    {
        this.entitiesSet.add(new UUID(((NBTTagLong)iter.next()).getLong(), ((NBTTagLong)iter.next()).getLong()));
    }

    this.playerReps.clear();
    StreamSupport.stream(nbt.getTagList("playerReps", Constants.NBT.TAG_COMPOUND).spliterator(), false).map(n -> (NBTTagCompound)n).forEach(tag -> this.playerReps.put(new UUID(tag.getLong("keyMost"), tag.getLong("keyLeast")), tag.getFloat("value")));
}

public static Object getNBTBaseData(final NBTBase nbt) {
    if (nbt == null) {
        return null;
    }
    switch (nbt.getId()) {
        case 1: {
            return ((NBTTagByte)nbt).func_150290_f();
        }
        case 2: {
            return ((NBTTagShort)nbt).func_150289_e();
        }
        case 3: {
            return ((NBTTagInt)nbt).func_150287_d();
        }
        case 4: {
            return ((NBTTagLong)nbt).func_150291_c();
        }
        case 5: {
            return ((NBTTagFloat)nbt).func_150288_h();
        }
        case 6: {
            return ((NBTTagDouble)nbt).func_150286_g();
        }
        case 8: {
            return ((NBTTagString)nbt).func_150285_a_();
        }
        case 10: {
            return nbt;
        }
        default: {
            return null;
        }
    }
}

public static NBTBase getNBTBase(final Object o) {
    if (o instanceof Integer) {
        return (NBTBase)new NBTTagInt((Integer)o);
    }
    if (o instanceof Short) {
        return (NBTBase)new NBTTagShort((Short)o);
    }
    if (o instanceof Long) {
        return (NBTBase)new NBTTagLong((Long)o);
    }
    if (o instanceof String) {
        return (NBTBase)new NBTTagString((String)o);
    }
    if (o instanceof Double) {
        return (NBTBase)new NBTTagDouble((Double)o);
    }
    if (o instanceof Float) {
        return (NBTBase)new NBTTagFloat((Float)o);
    }
    if (o instanceof NBTTagCompound) {
        return (NBTBase)o;
    }
    if (o instanceof Byte) {
        return (NBTBase)new NBTTagByte((Byte)o);
    }
    LogHelper.debug("Can't find type for " + o, new Object[0]);
    throw null;
}

@SubscribeEvent
public void rotAttachCapability(AttachCapabilitiesEvent<ItemStack> event)
{
    ItemStack stack = event.getObject();

    if(isRottingItem(stack) && MINECRAFT_DATE != -1) //All items instead?
    {
        NBTTagCompound compound = stack.getTagCompound();
        if(compound == null || !compound.hasKey(CREATION_TIME_TAG))
            stack.setTagInfo(CREATION_TIME_TAG,new NBTTagLong(MINECRAFT_DATE));
        //event.addCapability(ROT,new Rot());
    }
}

private Map<Class<? extends NBTBase>, NbtMerger<? extends NBTBase>> getMergers() {
  if (mergers == null) {
    mergers = new HashMap<>();
    registerMerger(NBTTagByte.class, new NbtByteMerger(this));
    registerMerger(NBTTagCompound.class, new NbtCompoundMerger(this));
    registerMerger(NBTTagDouble.class, new NbtDoubleMerger(this));
    registerMerger(NBTTagFloat.class, new NbtFloatMerger(this));
    registerMerger(NBTTagInt.class, new NbtIntMerger(this));
    registerMerger(NBTTagList.class, new NbtListMerger(this));
    registerMerger(NBTTagLong.class, new NbtLongMerger(this));
    registerMerger(NBTTagShort.class, new NbtShortMerger(this));
    registerMerger(NBTTagString.class, new NbtStringMerger(this));
  }
  return mergers;
}

@Override
public NBTTagLong merge(NBTTagLong nbt, Object data, String key, String path) {
  if (data instanceof Number) {
    return NbtConverter.toNbt(((Number) data).longValue());
  }
  throw converter.conversionException(path, data, "number");
}

private void setOriginPortal(EntityPlayer player, ItemStack stack, ControlBlockLocation thisPortal) {
    stack.setTagInfo("origin", new NBTTagLong(thisPortal.pos.toLong()));
    stack.setTagInfo("dimid", new NBTTagInt(player.dimension));
    int side = getSide(player, thisPortal);
    stack.setTagInfo("side", new NBTTagInt(side));
    playSound(player);
}

/**
 * Converts the map to a NBT tag compound
 * @param map    The map to convert
 * @return       The output NBT
 */
private static NBTTagCompound convertMapToCompoundNbt(Map<String, Long> map) {
    NBTTagCompound output = new NBTTagCompound();
    for(Map.Entry<String, Long> entry : map.entrySet()) {
        output.setTag(entry.getKey(), new NBTTagLong(entry.getValue()));
    }
    return output;
}

/**
 * Converts a {@link JsonElement} into an {@link NBTBase}
 * 
 * @param element the {@link JsonElement} to convert
 * @return the converted {@link NBTBase}
 */
public static NBTBase toNBTElement(JsonElement element) {
    if (element.isJsonArray()) {
        NBTTagList list = new NBTTagList();
        for (JsonElement elem : element.getAsJsonArray()) list.appendTag(toNBTElement(elem));
        return list;
    }
    else if (element.isJsonObject()) {
        NBTTagCompound compound = new NBTTagCompound();
        for (Map.Entry<String, JsonElement> entry : element.getAsJsonObject().entrySet()) compound.setTag(entry.getKey(), toNBTElement(entry.getValue()));
        return compound;
    }
    else if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
        Number num = element.getAsJsonPrimitive().getAsNumber();

        if (num instanceof Byte) return new NBTTagByte(num.byteValue());
        else if (num instanceof Short) return new NBTTagShort(num.shortValue());
        else if (num instanceof Integer) return new NBTTagInt(num.intValue());
        else if (num instanceof Long) return new NBTTagLong(num.longValue());
        else if (num instanceof Float) return new NBTTagFloat(num.floatValue());
        else if (num instanceof Double) return new NBTTagDouble(num.doubleValue());
        else return new NBTTagDouble(num.doubleValue());
    }
    else if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isString()) 
        return new NBTTagString(element.getAsJsonPrimitive().getAsString());
    else return null;
}

/**
 * Reads an unknown object withPriority a known name from NBT
 * @param tag - tag to read the value from
 * @param key - name of the value
 * @return object or suggestionValue if nothing is found
 */
public Object load(NBTTagCompound tag, String key) {
    if (tag != null && key != null) {
        NBTBase saveTag = tag.getTag(key);

        if (saveTag instanceof NBTTagFloat) {
            return tag.getFloat(key);
        } else if (saveTag instanceof NBTTagDouble) {
            return tag.getDouble(key);
        } else if (saveTag instanceof NBTTagInt) {
            return tag.getInteger(key);
        } else if (saveTag instanceof NBTTagString) {
            if (tag.getBoolean(key + "::nova.isBigInteger")) {
                return new BigInteger(tag.getString(key));
            } else if (tag.getBoolean(key + "::nova.isBigDecimal")) {
                return new BigDecimal(tag.getString(key));
            } else {
                return tag.getString(key);
            }
        } else if (saveTag instanceof NBTTagShort) {
            return tag.getShort(key);
        } else if (saveTag instanceof NBTTagByte) {
            if (tag.getBoolean(key + "::nova.isBoolean")) {
                return tag.getBoolean(key);
            } else {
                return tag.getByte(key);
            }
        } else if (saveTag instanceof NBTTagLong) {
            return tag.getLong(key);
        } else if (saveTag instanceof NBTTagByteArray) {
            return tag.getByteArray(key);
        } else if (saveTag instanceof NBTTagIntArray) {
            return tag.getIntArray(key);
        } else if (saveTag instanceof NBTTagCompound) {
            NBTTagCompound innerTag = tag.getCompoundTag(key);
            return toNova(innerTag);
        }
    }
    return null;
}

/**
 * Reads an unknown object withPriority a known name from NBT
 * @param tag - tag to read the value from
 * @param key - name of the value
 * @return object or suggestionValue if nothing is found
 */
public Object load(NBTTagCompound tag, String key) {
    if (tag != null && key != null) {
        NBTBase saveTag = tag.getTag(key);

        if (saveTag instanceof NBTTagFloat) {
            return tag.getFloat(key);
        } else if (saveTag instanceof NBTTagDouble) {
            return tag.getDouble(key);
        } else if (saveTag instanceof NBTTagInt) {
            return tag.getInteger(key);
        } else if (saveTag instanceof NBTTagString) {
            if (tag.getBoolean(key + "::nova.isBigInteger")) {
                return new BigInteger(tag.getString(key));
            } else if (tag.getBoolean(key + "::nova.isBigDecimal")) {
                return new BigDecimal(tag.getString(key));
            } else {
                return tag.getString(key);
            }
        } else if (saveTag instanceof NBTTagShort) {
            return tag.getShort(key);
        } else if (saveTag instanceof NBTTagByte) {
            if (tag.getBoolean(key + "::nova.isBoolean")) {
                return tag.getBoolean(key);
            } else {
                return tag.getByte(key);
            }
        } else if (saveTag instanceof NBTTagLong) {
            return tag.getLong(key);
        } else if (saveTag instanceof NBTTagByteArray) {
            return tag.getByteArray(key);
        } else if (saveTag instanceof NBTTagIntArray) {
            return tag.getIntArray(key);
        } else if (saveTag instanceof NBTTagCompound) {
            NBTTagCompound innerTag = tag.getCompoundTag(key);
            return toNova(innerTag);
        }
    }
    return null;
}

/** Returns the primitive value of a tag, casted to the return type. */
public static <T> T getTagValue(NBTBase tag) {
    if (tag == null)
        throw new IllegalArgumentException("tag is null");
    if (tag instanceof NBTTagByte)      return (T)(Object)((NBTTagByte)tag).func_150290_f();
    if (tag instanceof NBTTagShort)     return (T)(Object)((NBTTagShort)tag).func_150289_e();
    if (tag instanceof NBTTagInt)       return (T)(Object)((NBTTagInt)tag).func_150287_d();
    if (tag instanceof NBTTagLong)      return (T)(Object)((NBTTagLong)tag).func_150291_c();
    if (tag instanceof NBTTagFloat)     return (T)(Object)((NBTTagFloat)tag).func_150288_h();
    if (tag instanceof NBTTagDouble)    return (T)(Object)((NBTTagDouble)tag).func_150286_g();
    if (tag instanceof NBTTagString)    return (T)((NBTTagString)tag).func_150285_a_();
    if (tag instanceof NBTTagByteArray) return (T)((NBTTagByteArray)tag).func_150292_c();
    if (tag instanceof NBTTagIntArray)  return (T)((NBTTagIntArray)tag).func_150302_c();
    throw new IllegalArgumentException(NBTBase.NBTTypes[tag.getId()] + " isn't a primitive NBT tag");
}

@Override
public NBTTagCompound writeToNBT(NBTTagCompound tagCompound) {
    tagCompound = super.writeToNBT(tagCompound);
    tagCompound.setBoolean(IS_MASTER, isMaster);

    NBTTagList slaveList = new NBTTagList();
    for (BlockPos slavePos : slaves) {
        slaveList.appendTag(new NBTTagLong(slavePos.toLong()));
    }
    tagCompound.setTag(SLAVES, slaveList);
    return tagCompound;
}