Module com.blackhillsoftware.easysmf.je
Package com.blackhillsoftware.smf.db2.section

Class Qbgl

java.lang.Object
com.blackhillsoftware.smf.Data
com.blackhillsoftware.smf.SmfData
com.blackhillsoftware.smf.db2.section.Qbgl
public final class Qbgl extends SmfData

  • Field Details

  • Method Details

    • qbglgn

      public long qbglgn()
      QBGLGN value.
      Returns:
      long QBGLGN value

    • qbglflg

      public int qbglflg()
      QBGLFLG value.
      Returns:
      int QBGLFLG value

    • qbglcon

      public boolean qbglcon()
      Return true if QBGLCON bit in qbglflg() is set.
      Returns:
      boolean QBGLCON bit is set in qbglflg()

      QBGLCON = 0x80

    • qbglgg

      public long qbglgg()
      QBGLGG value, throws exception if QBGLGG overflows 64 bit signed integer.
      Returns:
      long QBGLGG
      Throws:
      IllegalArgumentException - If the value of QBGLGG exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLGG). Use qbglggAsBigInteger() if this is possible.

    • qbglggAsBigInteger

      public BigInteger qbglggAsBigInteger()
      QBGLGG value as a BigInteger.

      qbglgg() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLGG

    • qbglxd

      public long qbglxd()
      QBGLXD value, throws exception if QBGLXD overflows 64 bit signed integer.
      Returns:
      long QBGLXD
      Throws:
      IllegalArgumentException - If the value of QBGLXD exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLXD). Use qbglxdAsBigInteger() if this is possible.

    • qbglxdAsBigInteger

      public BigInteger qbglxdAsBigInteger()
      QBGLXD value as a BigInteger.

      qbglxd() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLXD

    • qbglxr

      public long qbglxr()
      QBGLXR value, throws exception if QBGLXR overflows 64 bit signed integer.
      Returns:
      long QBGLXR
      Throws:
      IllegalArgumentException - If the value of QBGLXR exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLXR). Use qbglxrAsBigInteger() if this is possible.

    • qbglxrAsBigInteger

      public BigInteger qbglxrAsBigInteger()
      QBGLXR value as a BigInteger.

      qbglxr() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLXR

    • qbglmd

      public long qbglmd()
      QBGLMD value, throws exception if QBGLMD overflows 64 bit signed integer.
      Returns:
      long QBGLMD
      Throws:
      IllegalArgumentException - If the value of QBGLMD exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLMD). Use qbglmdAsBigInteger() if this is possible.

    • qbglmdAsBigInteger

      public BigInteger qbglmdAsBigInteger()
      QBGLMD value as a BigInteger.

      qbglmd() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLMD

    • qbglmr

      public long qbglmr()
      QBGLMR value, throws exception if QBGLMR overflows 64 bit signed integer.
      Returns:
      long QBGLMR
      Throws:
      IllegalArgumentException - If the value of QBGLMR exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLMR). Use qbglmrAsBigInteger() if this is possible.

    • qbglmrAsBigInteger

      public BigInteger qbglmrAsBigInteger()
      QBGLMR value as a BigInteger.

      qbglmr() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLMR

    • qbglsw

      public long qbglsw()
      QBGLSW value, throws exception if QBGLSW overflows 64 bit signed integer.
      Returns:
      long QBGLSW
      Throws:
      IllegalArgumentException - If the value of QBGLSW exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLSW). Use qbglswAsBigInteger() if this is possible.

    • qbglswAsBigInteger

      public BigInteger qbglswAsBigInteger()
      QBGLSW value as a BigInteger.

      qbglsw() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLSW

    • qbglwc

      public long qbglwc()
      QBGLWC value, throws exception if QBGLWC overflows 64 bit signed integer.
      Returns:
      long QBGLWC
      Throws:
      IllegalArgumentException - If the value of QBGLWC exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWC). Use qbglwcAsBigInteger() if this is possible.

    • qbglwcAsBigInteger

      public BigInteger qbglwcAsBigInteger()
      QBGLWC value as a BigInteger.

      qbglwc() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWC

    • qbglct

      public long qbglct()
      QBGLCT value, throws exception if QBGLCT overflows 64 bit signed integer.
      Returns:
      long QBGLCT
      Throws:
      IllegalArgumentException - If the value of QBGLCT exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLCT). Use qbglctAsBigInteger() if this is possible.

    • qbglctAsBigInteger

      public BigInteger qbglctAsBigInteger()
      QBGLCT value as a BigInteger.

      qbglct() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLCT

    • qbglgt

      public long qbglgt()
      QBGLGT value, throws exception if QBGLGT overflows 64 bit signed integer.
      Returns:
      long QBGLGT
      Throws:
      IllegalArgumentException - If the value of QBGLGT exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLGT). Use qbglgtAsBigInteger() if this is possible.

    • qbglgtAsBigInteger

      public BigInteger qbglgtAsBigInteger()
      QBGLGT value as a BigInteger.

      qbglgt() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLGT

    • qbglwm

      public long qbglwm()
      QBGLWM value, throws exception if QBGLWM overflows 64 bit signed integer.
      Returns:
      long QBGLWM
      Throws:
      IllegalArgumentException - If the value of QBGLWM exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWM). Use qbglwmAsBigInteger() if this is possible.

    • qbglwmAsBigInteger

      public BigInteger qbglwmAsBigInteger()
      QBGLWM value as a BigInteger.

      qbglwm() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWM

    • qbglws

      public long qbglws()
      QBGLWS value, throws exception if QBGLWS overflows 64 bit signed integer.
      Returns:
      long QBGLWS
      Throws:
      IllegalArgumentException - If the value of QBGLWS exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWS). Use qbglwsAsBigInteger() if this is possible.

    • qbglwsAsBigInteger

      public BigInteger qbglwsAsBigInteger()
      QBGLWS value as a BigInteger.

      qbglws() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWS

    • qbglex

      public long qbglex()
      QBGLEX value, throws exception if QBGLEX overflows 64 bit signed integer.
      Returns:
      long QBGLEX
      Throws:
      IllegalArgumentException - If the value of QBGLEX exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLEX). Use qbglexAsBigInteger() if this is possible.

    • qbglexAsBigInteger

      public BigInteger qbglexAsBigInteger()
      QBGLEX value as a BigInteger.

      qbglex() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLEX

    • qbglaw

      public long qbglaw()
      QBGLAW value, throws exception if QBGLAW overflows 64 bit signed integer.
      Returns:
      long QBGLAW
      Throws:
      IllegalArgumentException - If the value of QBGLAW exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLAW). Use qbglawAsBigInteger() if this is possible.

    • qbglawAsBigInteger

      public BigInteger qbglawAsBigInteger()
      QBGLAW value as a BigInteger.

      qbglaw() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLAW

    • qbglrc

      public long qbglrc()
      QBGLRC value, throws exception if QBGLRC overflows 64 bit signed integer.
      Returns:
      long QBGLRC
      Throws:
      IllegalArgumentException - If the value of QBGLRC exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLRC). Use qbglrcAsBigInteger() if this is possible.

    • qbglrcAsBigInteger

      public BigInteger qbglrcAsBigInteger()
      QBGLRC value as a BigInteger.

      qbglrc() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLRC

    • qbglcm

      public long qbglcm()
      QBGLCM value, throws exception if QBGLCM overflows 64 bit signed integer.
      Returns:
      long QBGLCM
      Throws:
      IllegalArgumentException - If the value of QBGLCM exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLCM). Use qbglcmAsBigInteger() if this is possible.

    • qbglcmAsBigInteger

      public BigInteger qbglcmAsBigInteger()
      QBGLCM value as a BigInteger.

      qbglcm() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLCM

    • qbglcr

      public long qbglcr()
      QBGLCR value, throws exception if QBGLCR overflows 64 bit signed integer.
      Returns:
      long QBGLCR
      Throws:
      IllegalArgumentException - If the value of QBGLCR exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLCR). Use qbglcrAsBigInteger() if this is possible.

    • qbglcrAsBigInteger

      public BigInteger qbglcrAsBigInteger()
      QBGLCR value as a BigInteger.

      qbglcr() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLCR

    • qbglwp

      public long qbglwp()
      QBGLWP value, throws exception if QBGLWP overflows 64 bit signed integer.
      Returns:
      long QBGLWP
      Throws:
      IllegalArgumentException - If the value of QBGLWP exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWP). Use qbglwpAsBigInteger() if this is possible.

    • qbglwpAsBigInteger

      public BigInteger qbglwpAsBigInteger()
      QBGLWP value as a BigInteger.

      qbglwp() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWP

    • qbglwf

      public long qbglwf()
      QBGLWF value, throws exception if QBGLWF overflows 64 bit signed integer.
      Returns:
      long QBGLWF
      Throws:
      IllegalArgumentException - If the value of QBGLWF exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWF). Use qbglwfAsBigInteger() if this is possible.

    • qbglwfAsBigInteger

      public BigInteger qbglwfAsBigInteger()
      QBGLWF value as a BigInteger.

      qbglwf() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWF

    • qbglos

      public long qbglos()
      QBGLOS value, throws exception if QBGLOS overflows 64 bit signed integer.
      Returns:
      long QBGLOS
      Throws:
      IllegalArgumentException - If the value of QBGLOS exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLOS). Use qbglosAsBigInteger() if this is possible.

    • qbglosAsBigInteger

      public BigInteger qbglosAsBigInteger()
      QBGLOS value as a BigInteger.

      qbglos() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLOS

    • qbglac

      public long qbglac()
      QBGLAC value, throws exception if QBGLAC overflows 64 bit signed integer.
      Returns:
      long QBGLAC
      Throws:
      IllegalArgumentException - If the value of QBGLAC exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLAC). Use qbglacAsBigInteger() if this is possible.

    • qbglacAsBigInteger

      public BigInteger qbglacAsBigInteger()
      QBGLAC value as a BigInteger.

      qbglac() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLAC

    • qbglax

      public long qbglax()
      QBGLAX value, throws exception if QBGLAX overflows 64 bit signed integer.
      Returns:
      long QBGLAX
      Throws:
      IllegalArgumentException - If the value of QBGLAX exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLAX). Use qbglaxAsBigInteger() if this is possible.

    • qbglaxAsBigInteger

      public BigInteger qbglaxAsBigInteger()
      QBGLAX value as a BigInteger.

      qbglax() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLAX

    • qbglay

      public long qbglay()
      QBGLAY value, throws exception if QBGLAY overflows 64 bit signed integer.
      Returns:
      long QBGLAY
      Throws:
      IllegalArgumentException - If the value of QBGLAY exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLAY). Use qbglayAsBigInteger() if this is possible.

    • qbglayAsBigInteger

      public BigInteger qbglayAsBigInteger()
      QBGLAY value as a BigInteger.

      qbglay() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLAY

    • qbglck

      public long qbglck()
      QBGLCK value, throws exception if QBGLCK overflows 64 bit signed integer.
      Returns:
      long QBGLCK
      Throws:
      IllegalArgumentException - If the value of QBGLCK exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLCK). Use qbglckAsBigInteger() if this is possible.

    • qbglckAsBigInteger

      public BigInteger qbglckAsBigInteger()
      QBGLCK value as a BigInteger.

      qbglck() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLCK

    • qbglun

      public long qbglun()
      QBGLUN value, throws exception if QBGLUN overflows 64 bit signed integer.
      Returns:
      long QBGLUN
      Throws:
      IllegalArgumentException - If the value of QBGLUN exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLUN). Use qbglunAsBigInteger() if this is possible.

    • qbglunAsBigInteger

      public BigInteger qbglunAsBigInteger()
      QBGLUN value as a BigInteger.

      qbglun() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLUN

    • qbglcc

      public long qbglcc()
      QBGLCC value, throws exception if QBGLCC overflows 64 bit signed integer.
      Returns:
      long QBGLCC
      Throws:
      IllegalArgumentException - If the value of QBGLCC exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLCC). Use qbglccAsBigInteger() if this is possible.

    • qbglccAsBigInteger

      public BigInteger qbglccAsBigInteger()
      QBGLCC value as a BigInteger.

      qbglcc() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLCC

    • qbglcs

      public long qbglcs()
      QBGLCS value, throws exception if QBGLCS overflows 64 bit signed integer.
      Returns:
      long QBGLCS
      Throws:
      IllegalArgumentException - If the value of QBGLCS exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLCS). Use qbglcsAsBigInteger() if this is possible.

    • qbglcsAsBigInteger

      public BigInteger qbglcsAsBigInteger()
      QBGLCS value as a BigInteger.

      qbglcs() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLCS

    • qbgldn

      public long qbgldn()
      QBGLDN value, throws exception if QBGLDN overflows 64 bit signed integer.
      Returns:
      long QBGLDN
      Throws:
      IllegalArgumentException - If the value of QBGLDN exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLDN). Use qbgldnAsBigInteger() if this is possible.

    • qbgldnAsBigInteger

      public BigInteger qbgldnAsBigInteger()
      QBGLDN value as a BigInteger.

      qbgldn() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLDN

    • qbglrd

      public long qbglrd()
      QBGLRD value, throws exception if QBGLRD overflows 64 bit signed integer.
      Returns:
      long QBGLRD
      Throws:
      IllegalArgumentException - If the value of QBGLRD exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLRD). Use qbglrdAsBigInteger() if this is possible.

    • qbglrdAsBigInteger

      public BigInteger qbglrdAsBigInteger()
      QBGLRD value as a BigInteger.

      qbglrd() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLRD

    • qbglrg

      public long qbglrg()
      QBGLRG value, throws exception if QBGLRG overflows 64 bit signed integer.
      Returns:
      long QBGLRG
      Throws:
      IllegalArgumentException - If the value of QBGLRG exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLRG). Use qbglrgAsBigInteger() if this is possible.

    • qbglrgAsBigInteger

      public BigInteger qbglrgAsBigInteger()
      QBGLRG value as a BigInteger.

      qbglrg() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLRG

    • qbgldg

      public long qbgldg()
      QBGLDG value, throws exception if QBGLDG overflows 64 bit signed integer.
      Returns:
      long QBGLDG
      Throws:
      IllegalArgumentException - If the value of QBGLDG exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLDG). Use qbgldgAsBigInteger() if this is possible.

    • qbgldgAsBigInteger

      public BigInteger qbgldgAsBigInteger()
      QBGLDG value as a BigInteger.

      qbgldg() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLDG

    • qbgl2f

      public long qbgl2f()
      QBGL2F value, throws exception if QBGL2F overflows 64 bit signed integer.
      Returns:
      long QBGL2F
      Throws:
      IllegalArgumentException - If the value of QBGL2F exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGL2F). Use qbgl2fAsBigInteger() if this is possible.

    • qbgl2fAsBigInteger

      public BigInteger qbgl2fAsBigInteger()
      QBGL2F value as a BigInteger.

      qbgl2f() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGL2F

    • qbgl2s

      public long qbgl2s()
      QBGL2S value, throws exception if QBGL2S overflows 64 bit signed integer.
      Returns:
      long QBGL2S
      Throws:
      IllegalArgumentException - If the value of QBGL2S exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGL2S). Use qbgl2sAsBigInteger() if this is possible.

    • qbgl2sAsBigInteger

      public BigInteger qbgl2sAsBigInteger()
      QBGL2S value as a BigInteger.

      qbgl2s() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGL2S

    • qbgl2d

      public long qbgl2d()
      QBGL2D value, throws exception if QBGL2D overflows 64 bit signed integer.
      Returns:
      long QBGL2D
      Throws:
      IllegalArgumentException - If the value of QBGL2D exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGL2D). Use qbgl2dAsBigInteger() if this is possible.

    • qbgl2dAsBigInteger

      public BigInteger qbgl2dAsBigInteger()
      QBGL2D value as a BigInteger.

      qbgl2d() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGL2D

    • qbgl2r

      public long qbgl2r()
      QBGL2R value, throws exception if QBGL2R overflows 64 bit signed integer.
      Returns:
      long QBGL2R
      Throws:
      IllegalArgumentException - If the value of QBGL2R exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGL2R). Use qbgl2rAsBigInteger() if this is possible.

    • qbgl2rAsBigInteger

      public BigInteger qbgl2rAsBigInteger()
      QBGL2R value as a BigInteger.

      qbgl2r() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGL2R

    • qbgl2n

      public long qbgl2n()
      QBGL2N value, throws exception if QBGL2N overflows 64 bit signed integer.
      Returns:
      long QBGL2N
      Throws:
      IllegalArgumentException - If the value of QBGL2N exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGL2N). Use qbgl2nAsBigInteger() if this is possible.

    • qbgl2nAsBigInteger

      public BigInteger qbgl2nAsBigInteger()
      QBGL2N value as a BigInteger.

      qbgl2n() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGL2N

    • qbglhs

      public long qbglhs()
      QBGLHS value, throws exception if QBGLHS overflows 64 bit signed integer.
      Returns:
      long QBGLHS
      Throws:
      IllegalArgumentException - If the value of QBGLHS exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLHS). Use qbglhsAsBigInteger() if this is possible.

    • qbglhsAsBigInteger

      public BigInteger qbglhsAsBigInteger()
      QBGLHS value as a BigInteger.

      qbglhs() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLHS

    • qbgl2h

      public long qbgl2h()
      QBGL2H value, throws exception if QBGL2H overflows 64 bit signed integer.
      Returns:
      long QBGL2H
      Throws:
      IllegalArgumentException - If the value of QBGL2H exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGL2H). Use qbgl2hAsBigInteger() if this is possible.

    • qbgl2hAsBigInteger

      public BigInteger qbgl2hAsBigInteger()
      QBGL2H value as a BigInteger.

      qbgl2h() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGL2H

    • qbglp1

      public long qbglp1()
      QBGLP1 value, throws exception if QBGLP1 overflows 64 bit signed integer.
      Returns:
      long QBGLP1
      Throws:
      IllegalArgumentException - If the value of QBGLP1 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLP1). Use qbglp1AsBigInteger() if this is possible.

    • qbglp1AsBigInteger

      public BigInteger qbglp1AsBigInteger()
      QBGLP1 value as a BigInteger.

      qbglp1() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLP1

    • qbglp2

      public long qbglp2()
      QBGLP2 value, throws exception if QBGLP2 overflows 64 bit signed integer.
      Returns:
      long QBGLP2
      Throws:
      IllegalArgumentException - If the value of QBGLP2 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLP2). Use qbglp2AsBigInteger() if this is possible.

    • qbglp2AsBigInteger

      public BigInteger qbglp2AsBigInteger()
      QBGLP2 value as a BigInteger.

      qbglp2() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLP2

    • qbglp3

      public long qbglp3()
      QBGLP3 value, throws exception if QBGLP3 overflows 64 bit signed integer.
      Returns:
      long QBGLP3
      Throws:
      IllegalArgumentException - If the value of QBGLP3 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLP3). Use qbglp3AsBigInteger() if this is possible.

    • qbglp3AsBigInteger

      public BigInteger qbglp3AsBigInteger()
      QBGLP3 value as a BigInteger.

      qbglp3() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLP3

    • qbglu1

      public long qbglu1()
      QBGLU1 value, throws exception if QBGLU1 overflows 64 bit signed integer.
      Returns:
      long QBGLU1
      Throws:
      IllegalArgumentException - If the value of QBGLU1 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLU1). Use qbglu1AsBigInteger() if this is possible.

    • qbglu1AsBigInteger

      public BigInteger qbglu1AsBigInteger()
      QBGLU1 value as a BigInteger.

      qbglu1() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLU1

    • qbgls1

      public long qbgls1()
      QBGLS1 value, throws exception if QBGLS1 overflows 64 bit signed integer.
      Returns:
      long QBGLS1
      Throws:
      IllegalArgumentException - If the value of QBGLS1 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLS1). Use qbgls1AsBigInteger() if this is possible.

    • qbgls1AsBigInteger

      public BigInteger qbgls1AsBigInteger()
      QBGLS1 value as a BigInteger.

      qbgls1() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLS1

    • qbgls2

      public long qbgls2()
      QBGLS2 value, throws exception if QBGLS2 overflows 64 bit signed integer.
      Returns:
      long QBGLS2
      Throws:
      IllegalArgumentException - If the value of QBGLS2 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLS2). Use qbgls2AsBigInteger() if this is possible.

    • qbgls2AsBigInteger

      public BigInteger qbgls2AsBigInteger()
      QBGLS2 value as a BigInteger.

      qbgls2() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLS2

    • qbgls3

      public long qbgls3()
      QBGLS3 value, throws exception if QBGLS3 overflows 64 bit signed integer.
      Returns:
      long QBGLS3
      Throws:
      IllegalArgumentException - If the value of QBGLS3 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLS3). Use qbgls3AsBigInteger() if this is possible.

    • qbgls3AsBigInteger

      public BigInteger qbgls3AsBigInteger()
      QBGLS3 value as a BigInteger.

      qbgls3() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLS3

    • qbgln1

      public long qbgln1()
      QBGLN1 value, throws exception if QBGLN1 overflows 64 bit signed integer.
      Returns:
      long QBGLN1
      Throws:
      IllegalArgumentException - If the value of QBGLN1 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLN1). Use qbgln1AsBigInteger() if this is possible.

    • qbgln1AsBigInteger

      public BigInteger qbgln1AsBigInteger()
      QBGLN1 value as a BigInteger.

      qbgln1() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLN1

    • qbgln2

      public long qbgln2()
      QBGLN2 value, throws exception if QBGLN2 overflows 64 bit signed integer.
      Returns:
      long QBGLN2
      Throws:
      IllegalArgumentException - If the value of QBGLN2 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLN2). Use qbgln2AsBigInteger() if this is possible.

    • qbgln2AsBigInteger

      public BigInteger qbgln2AsBigInteger()
      QBGLN2 value as a BigInteger.

      qbgln2() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLN2

    • qbgln3

      public long qbgln3()
      QBGLN3 value, throws exception if QBGLN3 overflows 64 bit signed integer.
      Returns:
      long QBGLN3
      Throws:
      IllegalArgumentException - If the value of QBGLN3 exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLN3). Use qbgln3AsBigInteger() if this is possible.

    • qbgln3AsBigInteger

      public BigInteger qbgln3AsBigInteger()
      QBGLN3 value as a BigInteger.

      qbgln3() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLN3

    • qbglwa

      public long qbglwa()
      QBGLWA value, throws exception if QBGLWA overflows 64 bit signed integer.
      Returns:
      long QBGLWA
      Throws:
      IllegalArgumentException - If the value of QBGLWA exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWA). Use qbglwaAsBigInteger() if this is possible.

    • qbglwaAsBigInteger

      public BigInteger qbglwaAsBigInteger()
      QBGLWA value as a BigInteger.

      qbglwa() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWA

    • qbglwx

      public long qbglwx()
      QBGLWX value, throws exception if QBGLWX overflows 64 bit signed integer.
      Returns:
      long QBGLWX
      Throws:
      IllegalArgumentException - If the value of QBGLWX exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLWX). Use qbglwxAsBigInteger() if this is possible.

    • qbglwxAsBigInteger

      public BigInteger qbglwxAsBigInteger()
      QBGLWX value as a BigInteger.

      qbglwx() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLWX

    • qbglsu

      public long qbglsu()
      QBGLSU value, throws exception if QBGLSU overflows 64 bit signed integer.
      Returns:
      long QBGLSU
      Throws:
      IllegalArgumentException - If the value of QBGLSU exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLSU). Use qbglsuAsBigInteger() if this is possible.

    • qbglsuAsBigInteger

      public BigInteger qbglsuAsBigInteger()
      QBGLSU value as a BigInteger.

      qbglsu() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLSU

    • qbglas

      public long qbglas()
      QBGLAS value, throws exception if QBGLAS overflows 64 bit signed integer.
      Returns:
      long QBGLAS
      Throws:
      IllegalArgumentException - If the value of QBGLAS exceeds the maximum value of a signed 64 bit integer (i.e. the high order bit is set in QBGLAS). Use qbglasAsBigInteger() if this is possible.

    • qbglasAsBigInteger

      public BigInteger qbglasAsBigInteger()
      QBGLAS value as a BigInteger.

      qbglas() may provide better performance if the value will not exceed the maximum value for a signed long.

      Returns:
      BigInteger QBGLAS

    • create

      public static Qbgl create(byte[] Data, int offset, int length, SmfDb2Record parent)
      create is intended for internal use only. Instances of this section are created by the parent record or section.
      Parameters:
      Data - Array of bytes containing data for this section
      offset - Offset of this section in the data
      length - length of the section