package org.lwjgl.util.shaderc;

import java.nio.ByteBuffer;
import javax.annotation.Nullable;
import org.lwjgl.BufferUtils;
import org.lwjgl.system.Checks;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.system.MemoryUtil;
import org.lwjgl.system.NativeResource;
import org.lwjgl.system.NativeType;
import org.lwjgl.system.Struct;
import org.lwjgl.system.StructBuffer;

@NativeType("struct shaderc_include_result")
public class ShadercIncludeResult extends Struct<ShadercIncludeResult> implements NativeResource {
   public static final int SIZEOF;
   public static final int ALIGNOF;
   public static final int SOURCE_NAME;
   public static final int SOURCE_NAME_LENGTH;
   public static final int CONTENT;
   public static final int CONTENT_LENGTH;
   public static final int USER_DATA;

   protected ShadercIncludeResult(long address, @Nullable ByteBuffer container) {
      super(address, container);
   }

   protected ShadercIncludeResult create(long address, @Nullable ByteBuffer container) {
      return new ShadercIncludeResult(address, container);
   }

   public ShadercIncludeResult(ByteBuffer container) {
      super(MemoryUtil.memAddress(container), __checkContainer(container, SIZEOF));
   }

   public int sizeof() {
      return SIZEOF;
   }

   @NativeType("char const *")
   public ByteBuffer source_name() {
      return nsource_name(this.address());
   }

   @NativeType("char const *")
   public String source_nameString() {
      return nsource_nameString(this.address());
   }

   @NativeType("size_t")
   public long source_name_length() {
      return nsource_name_length(this.address());
   }

   @NativeType("char const *")
   public ByteBuffer content() {
      return ncontent(this.address());
   }

   @NativeType("char const *")
   public String contentString() {
      return ncontentString(this.address());
   }

   @NativeType("size_t")
   public long content_length() {
      return ncontent_length(this.address());
   }

   @NativeType("void *")
   public long user_data() {
      return nuser_data(this.address());
   }

   public ShadercIncludeResult source_name(@NativeType("char const *") ByteBuffer value) {
      nsource_name(this.address(), value);
      return this;
   }

   public ShadercIncludeResult content(@NativeType("char const *") ByteBuffer value) {
      ncontent(this.address(), value);
      return this;
   }

   public ShadercIncludeResult user_data(@NativeType("void *") long value) {
      nuser_data(this.address(), value);
      return this;
   }

   public ShadercIncludeResult set(ByteBuffer source_name, ByteBuffer content, long user_data) {
      this.source_name(source_name);
      this.content(content);
      this.user_data(user_data);
      return this;
   }

   public ShadercIncludeResult set(ShadercIncludeResult src) {
      MemoryUtil.memCopy(src.address(), this.address(), (long)SIZEOF);
      return this;
   }

   public static ShadercIncludeResult malloc() {
      return new ShadercIncludeResult(MemoryUtil.nmemAllocChecked((long)SIZEOF), (ByteBuffer)null);
   }

   public static ShadercIncludeResult calloc() {
      return new ShadercIncludeResult(MemoryUtil.nmemCallocChecked(1L, (long)SIZEOF), (ByteBuffer)null);
   }

   public static ShadercIncludeResult create() {
      ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF);
      return new ShadercIncludeResult(MemoryUtil.memAddress(container), container);
   }

   public static ShadercIncludeResult create(long address) {
      return new ShadercIncludeResult(address, (ByteBuffer)null);
   }

   @Nullable
   public static ShadercIncludeResult createSafe(long address) {
      return address == 0L ? null : new ShadercIncludeResult(address, (ByteBuffer)null);
   }

   public static Buffer malloc(int capacity) {
      return new Buffer(MemoryUtil.nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity);
   }

   public static Buffer calloc(int capacity) {
      return new Buffer(MemoryUtil.nmemCallocChecked((long)capacity, (long)SIZEOF), capacity);
   }

   public static Buffer create(int capacity) {
      ByteBuffer container = __create(capacity, SIZEOF);
      return new Buffer(MemoryUtil.memAddress(container), container, -1, 0, capacity, capacity);
   }

   public static Buffer create(long address, int capacity) {
      return new Buffer(address, capacity);
   }

   @Nullable
   public static Buffer createSafe(long address, int capacity) {
      return address == 0L ? null : new Buffer(address, capacity);
   }

   /** @deprecated */
   @Deprecated
   public static ShadercIncludeResult mallocStack() {
      return malloc(MemoryStack.stackGet());
   }

   /** @deprecated */
   @Deprecated
   public static ShadercIncludeResult callocStack() {
      return calloc(MemoryStack.stackGet());
   }

   /** @deprecated */
   @Deprecated
   public static ShadercIncludeResult mallocStack(MemoryStack stack) {
      return malloc(stack);
   }

   /** @deprecated */
   @Deprecated
   public static ShadercIncludeResult callocStack(MemoryStack stack) {
      return calloc(stack);
   }

   /** @deprecated */
   @Deprecated
   public static Buffer mallocStack(int capacity) {
      return malloc(capacity, MemoryStack.stackGet());
   }

   /** @deprecated */
   @Deprecated
   public static Buffer callocStack(int capacity) {
      return calloc(capacity, MemoryStack.stackGet());
   }

   /** @deprecated */
   @Deprecated
   public static Buffer mallocStack(int capacity, MemoryStack stack) {
      return malloc(capacity, stack);
   }

   /** @deprecated */
   @Deprecated
   public static Buffer callocStack(int capacity, MemoryStack stack) {
      return calloc(capacity, stack);
   }

   public static ShadercIncludeResult malloc(MemoryStack stack) {
      return new ShadercIncludeResult(stack.nmalloc(ALIGNOF, SIZEOF), (ByteBuffer)null);
   }

   public static ShadercIncludeResult calloc(MemoryStack stack) {
      return new ShadercIncludeResult(stack.ncalloc(ALIGNOF, 1, SIZEOF), (ByteBuffer)null);
   }

   public static Buffer malloc(int capacity, MemoryStack stack) {
      return new Buffer(stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity);
   }

   public static Buffer calloc(int capacity, MemoryStack stack) {
      return new Buffer(stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity);
   }

   public static ByteBuffer nsource_name(long struct) {
      return MemoryUtil.memByteBufferNT1(MemoryUtil.memGetAddress(struct + (long)SOURCE_NAME));
   }

   public static String nsource_nameString(long struct) {
      return MemoryUtil.memUTF8(MemoryUtil.memGetAddress(struct + (long)SOURCE_NAME));
   }

   public static long nsource_name_length(long struct) {
      return MemoryUtil.memGetAddress(struct + (long)SOURCE_NAME_LENGTH);
   }

   public static ByteBuffer ncontent(long struct) {
      return MemoryUtil.memByteBufferNT1(MemoryUtil.memGetAddress(struct + (long)CONTENT));
   }

   public static String ncontentString(long struct) {
      return MemoryUtil.memUTF8(MemoryUtil.memGetAddress(struct + (long)CONTENT));
   }

   public static long ncontent_length(long struct) {
      return MemoryUtil.memGetAddress(struct + (long)CONTENT_LENGTH);
   }

   public static long nuser_data(long struct) {
      return MemoryUtil.memGetAddress(struct + (long)USER_DATA);
   }

   public static void nsource_name(long struct, ByteBuffer value) {
      MemoryUtil.memPutAddress(struct + (long)SOURCE_NAME, MemoryUtil.memAddress(value));
      nsource_name_length(struct, (long)value.remaining());
   }

   public static void nsource_name_length(long struct, long value) {
      MemoryUtil.memPutAddress(struct + (long)SOURCE_NAME_LENGTH, value);
   }

   public static void ncontent(long struct, ByteBuffer value) {
      MemoryUtil.memPutAddress(struct + (long)CONTENT, MemoryUtil.memAddress(value));
      ncontent_length(struct, (long)value.remaining());
   }

   public static void ncontent_length(long struct, long value) {
      MemoryUtil.memPutAddress(struct + (long)CONTENT_LENGTH, value);
   }

   public static void nuser_data(long struct, long value) {
      MemoryUtil.memPutAddress(struct + (long)USER_DATA, value);
   }

   public static void validate(long struct) {
      Checks.check(MemoryUtil.memGetAddress(struct + (long)SOURCE_NAME));
      Checks.check(MemoryUtil.memGetAddress(struct + (long)CONTENT));
   }

   static {
      Struct.Layout layout = __struct(new Struct.Member[]{__member(POINTER_SIZE), __member(POINTER_SIZE), __member(POINTER_SIZE), __member(POINTER_SIZE), __member(POINTER_SIZE)});
      SIZEOF = layout.getSize();
      ALIGNOF = layout.getAlignment();
      SOURCE_NAME = layout.offsetof(0);
      SOURCE_NAME_LENGTH = layout.offsetof(1);
      CONTENT = layout.offsetof(2);
      CONTENT_LENGTH = layout.offsetof(3);
      USER_DATA = layout.offsetof(4);
   }

   public static class Buffer extends StructBuffer<ShadercIncludeResult, Buffer> implements NativeResource {
      private static final ShadercIncludeResult ELEMENT_FACTORY = ShadercIncludeResult.create(-1L);

      public Buffer(ByteBuffer container) {
         super(container, container.remaining() / ShadercIncludeResult.SIZEOF);
      }

      public Buffer(long address, int cap) {
         super(address, (ByteBuffer)null, -1, 0, cap, cap);
      }

      Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) {
         super(address, container, mark, pos, lim, cap);
      }

      protected Buffer self() {
         return this;
      }

      protected ShadercIncludeResult getElementFactory() {
         return ELEMENT_FACTORY;
      }

      @NativeType("char const *")
      public ByteBuffer source_name() {
         return ShadercIncludeResult.nsource_name(this.address());
      }

      @NativeType("char const *")
      public String source_nameString() {
         return ShadercIncludeResult.nsource_nameString(this.address());
      }

      @NativeType("size_t")
      public long source_name_length() {
         return ShadercIncludeResult.nsource_name_length(this.address());
      }

      @NativeType("char const *")
      public ByteBuffer content() {
         return ShadercIncludeResult.ncontent(this.address());
      }

      @NativeType("char const *")
      public String contentString() {
         return ShadercIncludeResult.ncontentString(this.address());
      }

      @NativeType("size_t")
      public long content_length() {
         return ShadercIncludeResult.ncontent_length(this.address());
      }

      @NativeType("void *")
      public long user_data() {
         return ShadercIncludeResult.nuser_data(this.address());
      }

      public Buffer source_name(@NativeType("char const *") ByteBuffer value) {
         ShadercIncludeResult.nsource_name(this.address(), value);
         return this;
      }

      public Buffer content(@NativeType("char const *") ByteBuffer value) {
         ShadercIncludeResult.ncontent(this.address(), value);
         return this;
      }

      public Buffer user_data(@NativeType("void *") long value) {
         ShadercIncludeResult.nuser_data(this.address(), value);
         return this;
      }
   }
}