private IFluidHandlerItem getNextInChain() {
    if(rawCapabilityProviders != null) {
        boolean foundMyself = false;
        for(ICapabilityProvider provider : rawCapabilityProviders) {
            IFluidHandlerItem fluidHandlerItem = provider.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null);
            if(fluidHandlerItem != null) {
                if(fluidHandlerItem == this) {
                    foundMyself = true;
                } else if(foundMyself) {
                    this.nextHandlerInChain = fluidHandlerItem;
                    break;
                }
            }
        }
        this.rawCapabilityProviders = null;
    }
    return nextHandlerInChain;
}
 

public void onTileEntityCapabilityAttachEvent(AttachCapabilitiesEvent<TileEntity> event){
    ICapabilityProvider provider = new CapabilityDestinationProvider.Provider();
    boolean requiresCap = false;

    CapabilityDestinationProvider cap = provider.getCapability(CapabilityDestinationProvider.INSTANCE, null);
    for(IDestinationProvider destinationProvider : destinationProviders) {
        if(destinationProvider.isTileEntityApplicable(event.getObject())) {
            try {
                cap.addDestinationProvider(destinationProvider.getClass().newInstance());
                if(!requiresCap) {
                    requiresCap = true;
                    event.addCapability(new ResourceLocation(Constants.MOD_ID, "destinationProviderCapability"), provider);
                }
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}
 

@Override
public void gatherCapabilities(@Nullable ICapabilityProvider parent) {
	AttachCapabilitiesEvent<T> event = new AttachCapabilitiesEvent<>(baseClass, provider);
	MinecraftForge.EVENT_BUS.post(event);

	if (!event.getCapabilities().isEmpty() || parent != null) {
		capabilities = new CapabilityDispatcher(event.getCapabilities(), event.getListeners(), parent);
	} else {
		capabilities = null;
	}
}
 

@Override
public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
    for (ICapabilityProvider provider : providers) {
        if (provider.hasCapability(capability, facing)) {
            return true;
        }
    }
    return false;
}
 

@Nullable
@Override
public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
    for (ICapabilityProvider provider : providers) {
        T cap = provider.getCapability(capability, facing);
        if (cap != null) {
            return cap;
        }
    }
    return null;
}
 

@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
    ICapabilityProvider capabilityProvider = super.initCapabilities(stack, nbt);
    if (capabilityProvider != null && capabilityProvider.hasCapability(GregtechCapabilities.CAPABILITY_ELECTRIC_ITEM, null)) {
        IElectricItem electricItem = capabilityProvider.getCapability(GregtechCapabilities.CAPABILITY_ELECTRIC_ITEM, null);
        //noinspection ConstantConditions
        electricItem.addChargeListener((itemStack, newCharge) -> {
            int newDamage = (newCharge == 0 ? 16000 : 0) + itemStack.getItemDamage() % 16000;
            if (newDamage != itemStack.getItemDamage()) {
                itemStack.setItemDamage(newDamage);
            }
        });
    }
    return capabilityProvider;
}
 

@Override
public ICapabilityProvider createProvider(ItemStack itemStack) {
    if (allowPartlyFill) {
        return new ThermalFluidHandlerItemStack(itemStack, maxCapacity, minFluidTemperature, maxFluidTemperature);
    }
    return new SimpleThermalFluidHandlerItemStack(itemStack, maxCapacity, minFluidTemperature, maxFluidTemperature);
}
 

@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
    T metaValueItem = getItem(stack);
    if (metaValueItem == null) {
        return null;
    }
    ArrayList<ICapabilityProvider> providers = new ArrayList<>();
    for (IMetaItemStats metaItemStats : metaValueItem.getAllStats()) {
        if (metaItemStats instanceof IItemCapabilityProvider) {
            IItemCapabilityProvider provider = (IItemCapabilityProvider) metaItemStats;
            providers.add(provider.createProvider(stack));
        }
    }
    return new CombinedCapabilityProvider(providers);
}
 

@Override
public ICapabilityProvider initItemStackCapabilities(ItemStack itemStack) {
    return new FluidHandlerItemStack(itemStack, tankSize) {
        @Override
        public boolean canFillFluidType(FluidStack fluid) {
            return MetaTileEntityTank.this.canFillFluidType(fluid);
        }
    };
}
 

@Override
public ICapabilityProvider createProvider(ItemStack itemStack) {
    return new FluidHandlerItemStack(itemStack, 10000) {
        @Override
        public boolean canFillFluidType(FluidStack fluid) {
            return fluid != null && fluid.isFluidEqual(Materials.ConstructionFoam.getFluid(1));
        }
    };
}
 

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt)
{
    if (!getContent().modules.isEmpty())
    {
        return new CapabilityProviderItem(stack, getContent());
    } else
    {
        return null;
    }
}
 

@SubscribeEvent
public void attachCapabilities(AttachCapabilitiesEvent<Entity> e)
{
    if (!ConfigManager.SERVER.enableScraping.get())
        return;
    final Entity entity = e.getObject();

    if (!(entity instanceof ServerPlayerEntity))
        return;

    if (entity.world == null || entity.world.isRemote)
        return;

    e.addCapability(PROP_KEY, new ICapabilityProvider()
    {
        ItemBreakingTracker cap = new ItemBreakingTracker();
        LazyOptional<ItemBreakingTracker> cap_provider = LazyOptional.of(() -> cap);

        {
            cap.init(entity, entity.world);
        }

        @SuppressWarnings("unchecked")
        @Override
        public <T> LazyOptional<T> getCapability(Capability<T> capability, @Nullable Direction facing)
        {
            if (capability == TRACKER)
                return cap_provider.cast();
            return LazyOptional.empty();
        }
    });
}
 

public CapabilityToComponent(ICapabilityProvider capabilities, Class<NOVA> component, Set<NOVA> defaultInstances, Direction direction) {
	this.capabilities = capabilities;
	this.component = component;
	this.defaultInstances = Collections.unmodifiableSet(defaultInstances);
	this.instances = new HashSet<>();
	this.direction = direction;
}
 

@SubscribeEvent
public void attachCapabilities(AttachCapabilitiesEvent<ItemStack> evt)
{
	if (evt.getCapabilities().containsKey(KEY)) {
		return;
	}
	Item item = evt.getObject().getItem();
	if (item instanceof ItemSpaceArmor) {
		evt.addCapability(KEY, (ICapabilityProvider) item);
	}
}
 

/**
 * @return An unmodifiable view of the capabilities that will be attached to this object.
 */
public Map<Identifier, ICapabilityProvider> getCapabilities() {
	return view;
}
 

default void gatherCapabilities(@Nullable ICapabilityProvider parent) {
	getCapabilityProvider().gatherCapabilities(parent);
}
 

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
    return new CapabilityEnergyProvider(stack, Config.MININGGADGET_MAXPOWER.get());
}
 

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
    MetaTileEntity metaTileEntity = getMetaTileEntity(stack);
    return metaTileEntity == null ? null : metaTileEntity.initItemStackCapabilities(stack);
}
 

public ICapabilityProvider initItemStackCapabilities(ItemStack itemStack) {
    return null;
}
 

public CombinedCapabilityProvider(ICapabilityProvider... providers) {
    this.providers = providers;
}
 

public CombinedCapabilityProvider(List<ICapabilityProvider> providers) {
    this.providers = providers.toArray(new ICapabilityProvider[0]);
}
 

@Override
public ICapabilityProvider createProvider(ItemStack itemStack) {
    return new CapabilityProvider(itemStack);
}
 

@Override
public ICapabilityProvider createProvider(ItemStack itemStack) {
    return new CapabilityProvider(itemStack);
}
 

@Override
public ICapabilityProvider createProvider(ItemStack itemStack) {
    return new CapabilityProvider(itemStack);
}
 

@Override
public ICapabilityProvider createProvider(ItemStack itemStack) {
    return new ElectricItem(itemStack, maxCharge, tier, chargeable, dischargeable);
}
 

public GlassBottleFluidHandler(ItemStack itemStack, Collection<ICapabilityProvider> rawCapabilityProviders) {
    this.itemStack = itemStack;
    this.rawCapabilityProviders = rawCapabilityProviders;
}
 

@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt) {
	return new GTFluidItemStackHandler(stack, stack, size);
}
 

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
	return new ManaCapabilityProvider(new CustomManaCapability(1000, 1000, 0, 0));
}
 

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
	return new BeltItemHandler(stack);
}
 

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
	return new ManaCapabilityProvider(new CustomManaCapability(300, 300, 0, 0));
}