func (obj *AbstractAttribute) ResetIsModified() {
	obj.resetIsModified()
}
ResetIsModified resets the IsModified flag - recursively, if needed
package impl
import (
	"bytes"
	"encoding/gob"
	"fmt"
	"log"
	"reflect"
	"strconv"
	"strings"
	"sync/atomic"
	"tgdb"
	"time"
)
const (
	AttributeTypeInvalid = iota
	AttributeTypeBoolean
	AttributeTypeByte
	AttributeTypeChar
	AttributeTypeShort
	AttributeTypeInteger
	AttributeTypeLong
	AttributeTypeFloat
	AttributeTypeDouble
	AttributeTypeNumber
	AttributeTypeString
	AttributeTypeDate
	AttributeTypeTime
	AttributeTypeTimeStamp
	AttributeTypeBlob
	AttributeTypeClob
)
type AttributeType struct {
	typeId      int
	typeName    string
	implementor string
}
var PreDefinedAttributeTypes = map[int]AttributeType{
	AttributeTypeInvalid:   {typeId: AttributeTypeInvalid, typeName: "", implementor: ""},
	AttributeTypeBoolean:   {typeId: AttributeTypeBoolean, typeName: "bool", implementor: "BooleanAttribute"},
	AttributeTypeByte:      {typeId: AttributeTypeByte, typeName: "uint8", implementor: "ByteAttribute"},
	AttributeTypeChar:      {typeId: AttributeTypeChar, typeName: "byte", implementor: "CharAttribute"},
	AttributeTypeShort:     {typeId: AttributeTypeShort, typeName: "int16", implementor: "ShortAttribute"},
	AttributeTypeInteger:   {typeId: AttributeTypeInteger, typeName: "int", implementor: "IntegerAttribute"},
	AttributeTypeLong:      {typeId: AttributeTypeLong, typeName: "int64", implementor: "LongAttribute"},
	AttributeTypeFloat:     {typeId: AttributeTypeFloat, typeName: "float32", implementor: "FloatAttribute"},
	AttributeTypeDouble:    {typeId: AttributeTypeDouble, typeName: "float64", implementor: "DoubleAttribute"},
	AttributeTypeNumber:    {typeId: AttributeTypeNumber, typeName: "big.Int", implementor: "NumberAttribute"},
	AttributeTypeString:    {typeId: AttributeTypeString, typeName: "string", implementor: "StringAttribute"},
	AttributeTypeDate:      {typeId: AttributeTypeDate, typeName: "date", implementor: "TimestampAttribute"},
	AttributeTypeTime:      {typeId: AttributeTypeTime, typeName: "time", implementor: "TimestampAttribute"},
	AttributeTypeTimeStamp: {typeId: AttributeTypeTimeStamp, typeName: "time.Time", implementor: "TimestampAttribute"},
	AttributeTypeBlob:      {typeId: AttributeTypeBlob, typeName: "[]uint8", implementor: "BlobAttribute"},
	AttributeTypeClob:      {typeId: AttributeTypeClob, typeName: "[]rune", implementor: "ClobAttribute"},
}
func (obj *AttributeType) GetTypeId() int {
	return obj.typeId
}
func (obj *AttributeType) GetTypeName() string {
	return obj.typeName
}
func (obj *AttributeType) GetImplementor() string {
	return obj.implementor
}
func (obj *AttributeType) SetTypeId(id int) {
	obj.typeId = id
}
func (obj *AttributeType) SetTypeName(name string) {
	obj.typeName = name
}
func (obj *AttributeType) SetImplementor(impl string) {
	obj.implementor = impl
}
func GetAttributeTypeFromId(aType int) *AttributeType {
	attrObj, ok := PreDefinedAttributeTypes[aType]
	if ok {
		return &attrObj
	} else {
		invalid := PreDefinedAttributeTypes[AttributeTypeInvalid]
		return &invalid
	}
}
func GetAttributeTypeFromName(aName string) *AttributeType {
	for _, aType := range PreDefinedAttributeTypes {
		if strings.ToLower(aType.typeName) == strings.ToLower(aName) {
			return &aType
		}
	}
	invalid := PreDefinedAttributeTypes[AttributeTypeInvalid]
	return &invalid
}
var LocalAttributeId int64
type AttributeDescriptor struct {
	SysType     tgdb.TGSystemType
	attributeId int64
	Name        string
	AttrType    int
	IsArray     bool
	IsEncrypted bool
	Precision   int16
	Scale       int16
}
func DefaultAttributeDescriptor() *AttributeDescriptor {
	gob.Register(AttributeDescriptor{})
	newAttributeDescriptor := AttributeDescriptor{
		SysType:     tgdb.SystemTypeAttributeDescriptor,
		Name:        "",
		AttrType:    AttributeTypeInvalid,
		IsArray:     false,
		IsEncrypted: false,
		Precision:   0,
		Scale:       0,
	}
	newAttributeDescriptor.attributeId = atomic.AddInt64(&LocalAttributeId, 1)
	return &newAttributeDescriptor
}
func NewAttributeDescriptor(id int64) *AttributeDescriptor {
	newAttributeDescriptor := DefaultAttributeDescriptor()
	newAttributeDescriptor.attributeId = id
	return newAttributeDescriptor
}
func NewAttributeDescriptorWithType(name string, attrType int) *AttributeDescriptor {
	newAttributeDescriptor := DefaultAttributeDescriptor()
	newAttributeDescriptor.Name = name
	newAttributeDescriptor.AttrType = attrType
	if attrType == AttributeTypeNumber {
		newAttributeDescriptor.Precision = 20
		newAttributeDescriptor.Scale = 5
	}
	return newAttributeDescriptor
}
func NewAttributeDescriptorAsArray(name string, attrType int, isArray bool) *AttributeDescriptor {
	newAttributeDescriptor := NewAttributeDescriptorWithType(name, attrType)
	newAttributeDescriptor.IsArray = isArray
	return newAttributeDescriptor
}
func NewAttributeDescriptorOnServer(name string, attrType int, isArray bool, attributeId int64) *AttributeDescriptor {
	newAttributeDescriptor := NewAttributeDescriptorAsArray(name, attrType, isArray)
	newAttributeDescriptor.attributeId = attributeId
	return newAttributeDescriptor
}
func (obj *AttributeDescriptor) SetAttributeId(attrId int64) {
	obj.attributeId = attrId
}
func (obj *AttributeDescriptor) SetAttrType(attrType int) {
	obj.AttrType = attrType
}
func (obj *AttributeDescriptor) SetIsArray(arrayFlag bool) {
	obj.IsArray = arrayFlag
}
func (obj *AttributeDescriptor) SetIsEncrypted(encryptedFlag bool) {
	obj.IsEncrypted = encryptedFlag
}
func (obj *AttributeDescriptor) SetName(attrName string) {
	obj.Name = attrName
}
func (obj *AttributeDescriptor) SetSystemType(sysType tgdb.TGSystemType) {
	obj.SysType = sysType
}
func (obj *AttributeDescriptor) String() string {
	var buffer bytes.Buffer
	buffer.WriteString("AttributeDescriptor:{")
	buffer.WriteString(fmt.Sprintf("SysType: %d", obj.SysType))
	buffer.WriteString(fmt.Sprintf(", AttributeId: %d", obj.attributeId))
	buffer.WriteString(fmt.Sprintf(", Name: %s", obj.Name))
	buffer.WriteString(fmt.Sprintf(", AttrType: %s", GetAttributeTypeFromId(obj.AttrType).GetTypeName()))
	buffer.WriteString(fmt.Sprintf(", IsArray: %+v", obj.IsArray))
	buffer.WriteString(fmt.Sprintf(", Precision: %+v", obj.Precision))
	buffer.WriteString(fmt.Sprintf(", Scale: %+v", obj.Scale))
	buffer.WriteString("}")
	return buffer.String()
}
func (obj *AttributeDescriptor) GetAttributeId() int64 {
	return obj.attributeId
}
func (obj *AttributeDescriptor) GetAttrType() int {
	return obj.AttrType
}
func (obj *AttributeDescriptor) GetPrecision() int16 {
	return obj.Precision
}
func (obj *AttributeDescriptor) GetScale() int16 {
	return obj.Scale
}
func (obj *AttributeDescriptor) IsAttributeArray() bool {
	return obj.IsArray
}
func (obj *AttributeDescriptor) Is_Encrypted() bool {
	return obj.IsEncrypted
}
func (obj *AttributeDescriptor) SetPrecision(precision int16) {
	if obj.AttrType == AttributeTypeNumber {
		obj.Precision = precision
	}
}
func (obj *AttributeDescriptor) SetScale(scale int16) {
	if obj.AttrType == AttributeTypeNumber {
		obj.Scale = scale
	}
}
func (obj *AttributeDescriptor) GetName() string {
	return obj.Name
}
func (obj *AttributeDescriptor) GetSystemType() tgdb.TGSystemType {
	return tgdb.SystemTypeAttributeDescriptor
}
func (obj *AttributeDescriptor) ReadExternal(is tgdb.TGInputStream) tgdb.TGError {
	sType, err := is.(*ProtocolDataInputStream).ReadByte()  
	if err != nil {
		return err
	}
	if tgdb.TGSystemType(sType) != tgdb.SystemTypeAttributeDescriptor {
		logger.Warning(fmt.Sprint("WARNING: AttributeDescriptor:ReadExternal - types.TGSystemType(sType) != types.SystemTypeAttributeDescriptor"))
	}
	attributeId, err := is.(*ProtocolDataInputStream).ReadInt()
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read attributeId w/ Error: '%+v'", err.Error()))
		return err
	}
	attrName, err := is.(*ProtocolDataInputStream).ReadUTF()
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read attrName w/ Error: '%+v'", err.Error()))
		return err
	}
	attrType, err := is.(*ProtocolDataInputStream).ReadByte()
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read AttrType w/ Error: '%+v'", err.Error()))
		return err
	}
	isArray, err := is.(*ProtocolDataInputStream).ReadBoolean()
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read IsArray w/ Error: '%+v'", err.Error()))
		return err
	}
	isEncrypted, err := is.(*ProtocolDataInputStream).ReadBoolean()
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read Is_Encrypted w/ Error: '%+v'", err.Error()))
		return err
	}
	var precision, scale int16
	if attrType == AttributeTypeNumber {
		precision, err = is.(*ProtocolDataInputStream).ReadShort()
		if err != nil {
			logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read Precision w/ Error: '%+v'", err.Error()))
			return err
		}
		scale, err = is.(*ProtocolDataInputStream).ReadShort()
		if err != nil {
			logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:ReadExternal - unable to read Scale w/ Error: '%+v'", err.Error()))
			return err
		}
	}
	obj.SetSystemType(tgdb.TGSystemType(sType))
	obj.SetAttributeId(int64(attributeId))
	obj.SetName(attrName)
	obj.SetAttrType(int(attrType))
	obj.SetIsArray(isArray)
	obj.SetIsEncrypted(isEncrypted)
	obj.SetPrecision(precision)
	obj.SetScale(scale)
	if logger.IsDebug() {
		logger.Debug(fmt.Sprintf("Returning AttributeDescriptor:ReadExternal w/ NO error, for AttrDesc: '%+v'", obj))
	}
	return nil
}
func (obj *AttributeDescriptor) WriteExternal(os tgdb.TGOutputStream) tgdb.TGError {
	os.(*ProtocolDataOutputStream).WriteByte(int(tgdb.SystemTypeAttributeDescriptor))  
	os.(*ProtocolDataOutputStream).WriteInt(int(obj.GetAttributeId()))
	err := os.(*ProtocolDataOutputStream).WriteUTF(obj.GetName())
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:WriteExternal - unable to write AttrDesc Name w/ Error: '%+v'", err.Error()))
		return err
	}
	os.(*ProtocolDataOutputStream).WriteByte(obj.GetAttrType())
	os.(*ProtocolDataOutputStream).WriteBoolean(obj.IsAttributeArray())
	os.(*ProtocolDataOutputStream).WriteBoolean(obj.Is_Encrypted())
	if obj.AttrType == AttributeTypeNumber {
		os.(*ProtocolDataOutputStream).WriteShort(int(obj.GetPrecision()))
		os.(*ProtocolDataOutputStream).WriteShort(int(obj.GetScale()))
	}
	return nil
}
func (obj *AttributeDescriptor) MarshalBinary() ([]byte, error) {
	var b bytes.Buffer
	_, err := fmt.Fprintln(&b, obj.SysType, obj.attributeId, obj.Name, obj.AttrType, obj.IsArray, obj.Precision, obj.Scale)
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:MarshalBinary w/ Error: '%+v'", err.Error()))
		return nil, err
	}
	return b.Bytes(), nil
}
func (obj *AttributeDescriptor) UnmarshalBinary(data []byte) error {
	b := bytes.NewBuffer(data)
	_, err := fmt.Fscanln(b, &obj.SysType, &obj.attributeId, &obj.Name, &obj.AttrType, &obj.IsArray, &obj.Precision, &obj.Scale)
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AttributeDescriptor:UnmarshalBinary w/ Error: '%+v'", err.Error()))
		return err
	}
	return nil
}
const (
	DATE_ONLY    = 0
	TIME_ONLY    = 1
	TIMESTAMP    = 2
	TGNoZone     = -1
	TGZoneOffset = 0
	TGZoneId     = 1
	TGZoneName   = 2
)
type AbstractAttribute struct {
	owner      tgdb.TGEntity
	AttrDesc   *AttributeDescriptor
	AttrValue  interface{}
	IsModified bool
}
func defaultNewAbstractAttribute() *AbstractAttribute {
	gob.Register(AbstractAttribute{})
	newAttribute := AbstractAttribute{
		AttrDesc:   DefaultAttributeDescriptor(),
		IsModified: false,
	}
	return &newAttribute
}
func NewAbstractAttributeWithOwner(ownerEntity tgdb.TGEntity) *AbstractAttribute {
	newAttribute := defaultNewAbstractAttribute()
	newAttribute.owner = ownerEntity
	return newAttribute
}
func NewAbstractAttribute(attrDesc *AttributeDescriptor) *AbstractAttribute {
	newAttribute := defaultNewAbstractAttribute()
	newAttribute.AttrDesc = attrDesc
	return newAttribute
}
func NewAbstractAttributeWithDesc(ownerEntity tgdb.TGEntity, attrDesc *AttributeDescriptor, value interface{}) *AbstractAttribute {
	newAttribute := NewAbstractAttributeWithOwner(ownerEntity)
	newAttribute.AttrDesc = attrDesc
	newAttribute.AttrValue = value
	return newAttribute
}
func interfaceEncode(enc *gob.Encoder, p tgdb.TGAttribute) tgdb.TGError {
	err := enc.Encode(&p)
	if err != nil {
		log.Fatal("encode:", err)
		errMsg := "Unable to encode interface"
		return GetErrorByType(TGErrorIOException, "TGErrorIOException", errMsg, "")
	}
	return nil
}
func interfaceDecode(dec *gob.Decoder) tgdb.TGAttribute {
	var p tgdb.TGAttribute
	err := dec.Decode(&p)
	if err != nil {
		log.Fatal("decode:", err)
	}
	return p
}
func (obj *AbstractAttribute) getAttributeDescriptor() *AttributeDescriptor {
	return obj.AttrDesc
}
func (obj *AbstractAttribute) getIsModified() bool {
	return obj.IsModified
}
func (obj *AbstractAttribute) getName() string {
	return obj.GetAttributeDescriptor().GetName()
}
func (obj *AbstractAttribute) getOwner() tgdb.TGEntity {
	return obj.owner
}
func (obj *AbstractAttribute) getValue() interface{} {
	return obj.AttrValue
}
func (obj *AbstractAttribute) isNull() bool {
	return obj.AttrValue == nil
}
func (obj *AbstractAttribute) resetIsModified() {
	obj.IsModified = false
}
func (obj *AbstractAttribute) setIsModified(flag bool) {
	obj.IsModified = flag
}
func (obj *AbstractAttribute) setNull() {
	obj.AttrValue = nil
}
func (obj *AbstractAttribute) setOwner(ownerEntity tgdb.TGEntity) {
	obj.owner = ownerEntity
}
func (obj *AbstractAttribute) setValue(value interface{}) tgdb.TGError {
	if value == nil {
		errMsg := fmt.Sprintf("Attribute value is required")
		return GetErrorByType(TGErrorIOException, INTERNAL_SERVER_ERROR, errMsg, "")
	}
	if !obj.isNull() && obj.getValue() == value {
		return nil
	}
	obj.AttrValue = value
	obj.IsModified = true
	return nil
}
func (obj *AbstractAttribute) attributeToString() string {
	var buffer bytes.Buffer
	buffer.WriteString("AbstractAttribute:{")
	buffer.WriteString(fmt.Sprintf("AttrDesc: %s", obj.AttrDesc.String()))
	buffer.WriteString(fmt.Sprintf(", AttrValue: %+v", obj.AttrValue))
	buffer.WriteString(fmt.Sprintf(", IsModified: %+v", obj.IsModified))
	buffer.WriteString("}")
	return buffer.String()
}
func (obj *AbstractAttribute) SetIsModified(flag bool) {
	obj.setIsModified(flag)
}
func ReadExternalForEntity(owner tgdb.TGEntity, is tgdb.TGInputStream) (tgdb.TGAttribute, tgdb.TGError) {
	if logger.IsDebug() {
		logger.Debug(fmt.Sprint("Entering AbstractAttribute:ReadExternalForEntity"))
	}
	attrId, err := is.(*ProtocolDataInputStream).ReadInt()
	if err != nil {
		return nil, err
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprintf("Inside AbstractAttribute::ReadExternalForEntity - read attrId: '%+v'", attrId))
	}
	var gmd tgdb.TGGraphMetadata
	node, ok := owner.(*Node)
	if ok {
		gmd = node.AbstractEntity.GetGraphMetadata()
	} else {
		edge, ok := owner.(*Edge)
		if ok {
			gmd = edge.AbstractEntity.GetGraphMetadata()
		} else {
			absEntity, ok := owner.(*AbstractEntity)
			if ok {
				gmd = absEntity.GetGraphMetadata()
			}
		}
	}
	if gmd == nil {
		errMsg := fmt.Sprintf("Invalid graph meta data associated with owner: '%+v'", owner.(*AbstractEntity))
		return nil, GetErrorByType(TGErrorIOException, INTERNAL_SERVER_ERROR, errMsg, "")
	}
	attrDesc, err := gmd.GetAttributeDescriptorById(int64(attrId))
	if err != nil {
		return nil, err
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprintf("Inside AbstractAttribute::ReadExternalForEntity - read AttrDesc: '%+v'", attrDesc))
	}
	if attrDesc == nil {
		errMsg := fmt.Sprintf("Invalid attributeId:'%d' encountered while deserialized", attrId)
		return nil, GetErrorByType(TGErrorIOException, TGDB_CLIENT_READEXTERNAL, errMsg, "")
	}
	newAttr, err := CreateAttributeWithDesc(owner, attrDesc.(*AttributeDescriptor), nil)
	if err != nil {
		return nil, err
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprintf("Inside AbstractAttribute::ReadExternalForEntity - created new attribute newAttr: '%+v'", newAttr))
	}
	err = newAttr.ReadExternal(is)
	if err != nil {
		return nil, err
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprintf("Returning AbstractAttribute::ReadExternalForEntity - updated newAttr from stream: '%+v'", newAttr))
	}
	return newAttr, nil
}
func AbstractAttributeReadDecrypted(obj tgdb.TGAttribute, is tgdb.TGInputStream) tgdb.TGError {
	conn := obj.GetOwner().GetGraphMetadata().GetConnection()
	decryptBuf, err := conn.DecryptBuffer(is)
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AbstractAttribute:AbstractAttributeReadDecrypted w/ Error in conn.DecryptBuffer(encryptedBuf): %s", err.Error()))
		return err
	}
	value, err := ObjectFromByteArray(decryptBuf, obj.GetAttributeDescriptor().GetAttrType())
	if err != nil {
		logger.Error(fmt.Sprintf("ERROR: Returning AbstractAttribute:AbstractAttributeReadDecrypted w/ Error in ObjectFromByteArray(): %s", err.Error()))
		return err
	}
	return obj.SetValue(value)
}
func AbstractAttributeReadExternal(obj tgdb.TGAttribute, is tgdb.TGInputStream) tgdb.TGError {
	if logger.IsDebug() {
		logger.Debug(fmt.Sprint("Entering AbstractAttribute:EntityTypeReadExternal"))
	}
	isNull, err := is.(*ProtocolDataInputStream).ReadBoolean()
	if err != nil {
		logger.Error(fmt.Sprint("ERROR: Returning AbstractAttribute:AbstractAttributeReadExternal w/ Error in reading isNull from message buffer"))
		return err
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprintf("Inside AbstractAttribute::AbstractAttributeReadExternal - read isnull: '%+v'", isNull))
	}
	if isNull {
		obj.SetValue(nil)
		return nil
	}
	if obj.GetAttributeDescriptor().Is_Encrypted() &&
		obj.GetAttributeDescriptor().GetAttrType() != AttributeTypeBlob &&
		obj.GetAttributeDescriptor().GetAttrType() != AttributeTypeClob {
		return AbstractAttributeReadDecrypted(obj, is)
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprint("Returning AbstractAttribute::AbstractAttributeReadExternal after reading the attribute value"))
	}
	return obj.ReadValue(is)
}
func AbstractAttributeWriteEncrypted(obj tgdb.TGAttribute, os tgdb.TGOutputStream) tgdb.TGError {
	buff, err := ObjectToByteArray(obj.GetValue(), obj.GetAttributeDescriptor().GetAttrType())
	if err != nil {
		logger.Error(fmt.Sprint("ERROR: Returning AbstractAttribute:AbstractAttributeWriteEncrypted w/ Error in ObjectToByteArray"))
		return err
	}
	conn := obj.GetOwner().GetGraphMetadata().GetConnection()
	encryptedBuf, err := conn.EncryptEntity(buff)
	if err != nil {
		logger.Error(fmt.Sprint("ERROR: Returning AbstractAttribute:AbstractAttributeWriteEncrypted w/ Error in conn.EncryptEntity(buff)"))
		return err
	}
	return os.(*ProtocolDataOutputStream).WriteBytes(encryptedBuf)
}
func AbstractAttributeWriteExternal(obj tgdb.TGAttribute, os tgdb.TGOutputStream) tgdb.TGError {
	if logger.IsDebug() {
		logger.Debug(fmt.Sprint("Entering AbstractAttribute:AbstractAttributeWriteExternal"))
	}
	attrId := obj.GetAttributeDescriptor().GetAttributeId()
	os.(*ProtocolDataOutputStream).WriteInt(int(attrId))
	os.(*ProtocolDataOutputStream).WriteBoolean(obj.IsNull())
	if obj.IsNull() {
		return nil
	}
	if obj.GetAttributeDescriptor().Is_Encrypted() {
		return AbstractAttributeWriteEncrypted(obj, os)
	}
	if logger.IsDebug() {
		logger.Debug(fmt.Sprint("Returning AbstractAttribute:AbstractAttributeWriteExternal after writing the attribute value"))
	}
	return obj.WriteValue(os)
}
func (obj *AbstractAttribute) GetAttributeDescriptor() tgdb.TGAttributeDescriptor {
	return obj.getAttributeDescriptor()
}
func (obj *AbstractAttribute) GetIsModified() bool {
	return obj.getIsModified()
}
func (obj *AbstractAttribute) GetName() string {
	return obj.getName()
}
func (obj *AbstractAttribute) GetOwner() tgdb.TGEntity {
	return obj.getOwner()
}
func (obj *AbstractAttribute) GetValue() interface{} {
	return obj.getValue()
}
func (obj *AbstractAttribute) IsNull() bool {
	return obj.isNull()
}