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(com.blackhillsoftware.smf.internal.Section 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