Accessing Private Members

[Ayanami]

So I have 2 structs, Struct A and Struct B. I want it so that Struct B can access Struct A's private members, but only Struct B.

struct A
    private static integer a
endstruct

struct B
    private static method test takes nothing returns nothing
        set A.a = 1 // I want to make this legal
    endmethod
endstruct

struct C
    private static method test takes nothing returns nothing
        set A.a = 1// illegal since only struct B can access struct A's private member
    endmethod
endstruct

Is there a way to do this?

 

[dudeim]

Extend A should work

so:

struct A
//stuff
endstruct

struct B extends A //taking all methods and variables from A
//stuff
endstruct

 

[Bribe]

Extending doesn't work as the privatization protects against child structs as well.

Usually to make this kind of tool function properly you use a module to implement
struct B's contents into struct A (or vice versa).

 

[Ayanami]

Extending doesn't work as the privatization protects against child structs as well.

Usually to make this kind of tool function properly you use a module to implement
struct B's contents into struct A (or vice versa).

Hmm, but using a module would mean that I'm actually using a single struct right? If I'm not wrong, modules are basically something like a textmacro which just inserts that portion of the code into a struct. Wouldn't this mean it's actually 1 struct and not 2 structs?

EDIT

Actually just thought of something. Couldn't I just do this:

struct A
    private static integer x

    public static method setX takes integer i returns nothing
        set x = i
    endmethod

    public static method getX takes nothing returns integer
        return x
    endmethod
endstruct

struct B
    private static method test takes nothing returns nothing
        call setX(1)
    endmethod
endstruct

I guess the only problem would be that the methods [ljass]setX()[/ljass] and [ljass]setY()[/ljass] can be accessed by any other structs as well, which is basically public in a sense @_@

 

[Sevion]

If struct and b are both in a library then make a private and b public.

library lib
    private struct a
        public static integer x
    endstruct

    public struct b
        public method setX takes integer value returns nothing
            set a.x = value
        endmethod
    endstruct
endlibrary

Now you can simply do [ljass]call lib_b.setX(1)[/ljass] and it'll work fine.

 

[Uberplayer]

If they're not all in the same library:

library XLibrary

    private keyword I //Library private

    public struct A

        static integer I

    endstruct

    public struct B

        public static method M takes nothing returns nothing
            A.I = 5 //Valid
        endmethod

    endstruct

endlibrary

library YLibrary requires XLibrary

    public struct C

        public static method M takes nothing returns nothing
            A.I = 5 //Invalid
        endmethod

    endstruct

endlibrary

I have no idea if this works in vJass, but it works in Zinc.

 

[Bribe]

Well "keyword" does not compile in Zinc so I'm not sure how you managed that ;D

 

[Uberplayer]

Explain this then, straight from latest XANID.

//! zinc

library Object requires Table, TimerUtils
{

    public constant integer OBJECT_FACING_RIGHT = 0;
    public constant integer OBJECT_FACING_LEFT  = 1;

    //===========================================================================

    private keyword right, left;
    private keyword objectRegistry;

    public interface ObjectInterface
    {
        unit unit;
        unit right = null, left = null;
        
        //===========================================================================
        
        real originX, originY;
        
        real boundingBoxMinX, boundingBoxMaxX;
        real boundingBoxMinY, boundingBoxMaxY;
        
        //===========================================================================
        
        real velocityMaxX, velocityMaxY;
        
        //===========================================================================
        
        integer animCurrent = 0;
        integer animStand, animWalk;
        
        real animSpeed = 1.00;
        
        boolean lockAnim = false;
        boolean lockFace = false;
        
        //===========================================================================
        
        method operator facing() -> integer;
        method operator facing=(integer face);
        
        //===========================================================================
        
        method operator x() -> real = 0.00;
        method operator x=(real value) = null;
        method operator y() -> real = 0.00;
        method operator y=(real value) = null;
        
        //===========================================================================
        
        integer health;
        
        boolean isRecovering = false;
        
        method damageGlobal(integer amount) = null;
        method damagePoint(integer amount, real x, real y) = null;
        method damageSource(integer amount, ObjectInterface source) = null;
        
        //===========================================================================
        
        method collisionGroupAdd(ObjectInterface obj) -> boolean = false;
        method collisionGroupRemove(ObjectInterface obj) -> boolean = false;
        method collisionGroupExists(ObjectInterface obj) -> boolean = false;
        
        method collisionGroupClear() = null;
        
        method collisionGroupEnum(code f) = null;
        
        method onObjectCollision(ObjectInterface obj) -> boolean = false;
        method onSolidCollision(integer dir) = null;
        
        //===========================================================================
        
        method onStep() = null;
        
        //===========================================================================
        
        method createEffectAtOrigin(string path, real face, real scale) = null;
        method createEffectAtOriginHeight(string path, real face, real scale, real height) = null;
        method attachEffectAtOrigin(string path, real duration, real face, real scale) = null;
        
        //===========================================================================
        
        boolean active = false;
        
        boolean forcedPhysics = false;
        boolean forcedCollision = false;
        
        method operator enabledPhysics() -> boolean;
        method operator enabledPhysics=(boolean flag);
        method operator enabledCollision() -> boolean;
        method operator enabledCollision=(boolean flag);

        //===========================================================================
        
        method setVertexColor(integer r, integer g, integer b, integer a);
        method setTeamColor(playercolor value);
        method compareId(integer id) -> boolean;
    }
    
    public module ObjectModule
    {
        private static constant real FACING_RIGHT_ANGLE = 0.00;
        private static constant real FACING_LEFT_ANGLE  = 180.00;
    
        //===========================================================================
    
        public static method create(real x, real y) -> thistype
        {
            thistype this = thistype.allocate();
            
            if (thistype.FACING_RIGHT_ID != 0) this.right = CreateUnit(PLAYER, thistype.FACING_RIGHT_ID, x, y, FACING_RIGHT_ANGLE);
            if (thistype.FACING_LEFT_ID != 0) this.left = CreateUnit(PLAYER, thistype.FACING_LEFT_ID, x, y, FACING_LEFT_ANGLE);
            SetUnitPathing(this.right, false);
            SetUnitPathing(this.left, false);
            
            this.x_value = x;
            this.y_value = y;
            
            ShowUnit(this.right, true);
            ShowUnit(this.left, false);
            this.unit = this.right;
            
            this.health = thistype.MaxHealth;
            
            ObjectRegistry[this.right] = this;
            ObjectRegistry[this.left] = this;
            
            GroupAddUnit(ObjectGroup, this.right);

            SetUnitAnimationByIndex(this.unit, this.animStand);
            
            PhysicsEngine.AddObject(this);
            
            if (this.collisionGroup == null) this.collisionGroup = CreateGroup();
            
            static if (thistype.onObjectCreate.exists) this.onObjectCreate();

            return this;
        }
    
        public method destroy()
        {
            static if (thistype.onObjectDestroy.exists) this.onObjectDestroy();
            
            this.enabledPhysics = false;
            this.enabledCollision = false;
            
            PhysicsEngine.RemoveObject(this);
        
            ObjectRegistry.flush(this.right);
            ObjectRegistry.flush(this.left);
            
            GroupRemoveUnit(ObjectGroup, this.right);
        
            if (this.unit != this.right) RemoveUnit(this.right);
            if (this.unit != this.left) RemoveUnit(this.left);
            KillUnit(this.unit);
            
            SetUnitTimeScale(this.unit, 1.00);
            
            GroupClear(this.collisionGroup);
            
            this.deallocate();
        }
        
        //===========================================================================
        // Changes facing to right or left. However, this does not lock objects facing.
        // Use lockFace property after this to do it.
        
        public method operator facing() -> integer
        {
            if (this.unit == this.right) return OBJECT_FACING_RIGHT;
            else return OBJECT_FACING_LEFT;
        }
        
        public method operator facing=(integer face)
        {
            if (face == OBJECT_FACING_RIGHT && this.unit != this.right)
            {
                ShowUnit(this.unit, false);
                this.unit = this.right;
                ShowUnit(this.unit, true);
            }
            else if (face == OBJECT_FACING_LEFT && this.unit != this.left)
            {
                ShowUnit(this.unit, false);
                this.unit = this.left;
                ShowUnit(this.unit, true);
            }
        }
        
        //===========================================================================
        
        private real x_value;
        
        public method operator x() -> real
        {
            return this.x_value;
        }
        
        public method operator x=(real value)
        {
            real oldX = this.x_value;
            PhysicsEngine dat = PhysicsEngine[this];
            
            if (dat.xAcceleration > 0.00 && dat.xVelocity > 0.00)
            {
                if (!this.lockAnim && (this.animCurrent != this.animWalk || this.unit != this.right))
                {
                    SetUnitAnimationByIndex(this.right, this.animWalk);
                    this.animCurrent = this.animWalk;
                }
                if (!this.lockFace && (this.unit != this.right))
                {
                    ShowUnit(this.unit, false);
                    this.unit = this.right;
                    ShowUnit(this.unit, true);
                }
                
                if (!dat.stateOnWater)
                {
                    SetUnitTimeScale(this.unit, this.animSpeed * 1.50 * (dat.xVelocity / this.velocityMaxX));
                }
                else
                {
                    SetUnitTimeScale(this.unit, this.animSpeed * 0.40);
                }
            }
            else if (dat.xAcceleration < 0.00 && dat.xVelocity < 0.00)
            {
                if (!this.lockAnim && (this.animCurrent != this.animWalk || this.unit != this.left))
                {
                    SetUnitAnimationByIndex(this.left, this.animWalk);
                    this.animCurrent = this.animWalk;
                }
                if (!this.lockFace && (this.unit != this.left))
                {
                    ShowUnit(this.unit, false);
                    this.unit = this.left;
                    ShowUnit(this.unit, true);
                }
                
                if (!dat.stateOnWater)
                {
                    SetUnitTimeScale(this.unit, this.animSpeed * 1.50 * (-dat.xVelocity / this.velocityMaxX));
                }
                else
                {
                    SetUnitTimeScale(this.unit, this.animSpeed * 0.40);
                }
            }
            else
            {
                if (!this.lockAnim && (dat.stateOnWater && !dat.stateOnGround))
                {
                    SetUnitAnimationByIndex(this.unit, this.animWalk);
                    this.animCurrent = this.animWalk;
                }
                else if (!this.lockAnim && (this.animCurrent != this.animStand))
                {
                    SetUnitAnimationByIndex(this.unit, this.animStand);
                    this.animCurrent = this.animStand;
                }
                
                if (!dat.stateOnWater)
                {
                    SetUnitTimeScale(this.unit, this.animSpeed);
                }
                else
                {
                    SetUnitTimeScale(this.unit, this.animSpeed * 0.40);
                }
            }
            
            SetUnitX(this.unit, value - this.originX);
            this.x_value = value;
            
            static if (thistype.onObjectSetX.exists) this.onObjectSetX(oldX);
        }
        
        private real y_value;
        
        public method operator y() -> real
        {
            return this.y_value;
        }
        
        public method operator y=(real value)
        {
            real oldY = this.y_value;
        
            SetUnitY(this.unit, value - this.originY);
            this.y_value = value;
            
            static if (thistype.onObjectSetY.exists) this.onObjectSetY(oldY);
        }
        
        //===========================================================================
        
        public static integer MaxHealth;
        
        private integer recoveryTicks;
        
        private static method Recover()
        {
            thistype this = GetTimerData(GetExpiredTimer());
            
            this.recoveryTicks -= 1;
            
            if (this.recoveryTicks == 1)
            {
                this.setVertexColor(255, 255, 255, 255);
            }
            else if (this.recoveryTicks == 0)
            {
                this.isRecovering = false;
                
                ReleaseTimer(GetExpiredTimer());
            }
        }
        
        public method damageGlobal(integer amount)
        {
            timer t;
        
            boolean wantRemove = true;
            
            if (this.health - amount > 0)
            {
                static if (thistype.onObjectDamageGlobal.exists)
                {
                    if (this.onObjectDamageGlobal(amount))
                    {
                        if (!this.isRecovering)
                        {
                            this.health -= amount;
                            static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                            
                            this.setVertexColor(255, 128, 128, 64);
                            
                            t = NewTimer();
                            SetTimerData(t, integer(this));
                            this.recoveryTicks = 2;
                            this.isRecovering = true;
                            TimerStart(t, 0.50, true, static method thistype.Recover);
                        }
                    }
                }
                else if (!this.isRecovering)
                {
                    this.health -= amount;
                    static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                    
                    this.setVertexColor(255, 128, 128, 64);
                    
                    t = NewTimer();
                    SetTimerData(t, integer(this));
                    this.recoveryTicks = 2;
                    this.isRecovering = true;
                    TimerStart(t, 0.50, true, static method thistype.Recover);
                }
            }
            else
            {
                static if (thistype.onObjectDamageGlobal.exists)
                {
                    if (this.onObjectDamageGlobal(amount))
                    {
                        if (!this.isRecovering)
                        {
                            this.health -= amount;
                            static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                            static if (thistype.onObjectDeath.exists)
                            {
                                wantRemove = this.onObjectDeath.evaluate();
                            }
                            if (wantRemove)
                            {
                                this.destroy();
                            }
                        }
                    }
                }
                else if (!this.isRecovering)
                {
                    static if (thistype.onObjectDeath.exists)
                    {
                        wantRemove = this.onObjectDeath.evaluate();
                    }
                    if (wantRemove)
                    {
                        this.destroy();
                    }
                }
            }
            
            t = null;
        }
        
        public method damagePoint(integer amount, real x, real y)
        {
            timer t;
        
            boolean wantRemove = true;
            
            if (this.health - amount > 0)
            {
                static if (thistype.onObjectDamagePoint.exists)
                {
                    if (this.onObjectDamagePoint(amount, x, y))
                    {
                        if (!this.isRecovering)
                        {
                            this.health -= amount;
                            static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                            
                            this.setVertexColor(255, 128, 128, 64);
                            
                            t = NewTimer();
                            SetTimerData(t, integer(this));
                            this.recoveryTicks = 2;
                            this.isRecovering = true;
                            TimerStart(t, 0.50, true, static method thistype.Recover);
                        }
                    }
                }
                else if (!this.isRecovering)
                {
                    this.health -= amount;
                    static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                    
                    this.setVertexColor(255, 128, 128, 64);
                    
                    t = NewTimer();
                    SetTimerData(t, integer(this));
                    this.recoveryTicks = 2;
                    this.isRecovering = true;
                    TimerStart(t, 0.50, true, static method thistype.Recover);
                }
            }
            else
            {
                static if (thistype.onObjectDamagePoint.exists)
                {
                    if (this.onObjectDamagePoint(amount, x, y))
                    {
                        if (!this.isRecovering)
                        {
                            this.health -= amount;
                            static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                            static if (thistype.onObjectDeath.exists)
                            {
                                wantRemove = this.onObjectDeath.evaluate();
                            }
                            if (wantRemove)
                            {
                                this.destroy();
                            }
                        }
                    }
                }
                else if (!this.isRecovering)
                {
                    static if (thistype.onObjectDeath.exists)
                    {
                        wantRemove = this.onObjectDeath.evaluate();
                    }
                    if (wantRemove)
                    {
                        this.destroy();
                    }
                }
            }
        }
        
        public method damageSource(integer amount, ObjectInterface source)
        {
            timer t;
        
            boolean wantRemove = true;
            
            if (this.health - amount > 0)
            {
                static if (thistype.onObjectDamageSource.exists)
                {
                    if (this.onObjectDamageSource(amount, source))
                    {
                        if (!this.isRecovering)
                        {
                            this.health -= amount;
                            static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                            
                            this.setVertexColor(255, 128, 128, 64);
                            
                            t = NewTimer();
                            SetTimerData(t, integer(this));
                            this.recoveryTicks = 2;
                            this.isRecovering = true;
                            TimerStart(t, 0.50, true, static method thistype.Recover);
                        }
                    }
                }
                else if (!this.isRecovering)
                {
                    this.health -= amount;
                    static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                    
                    this.setVertexColor(255, 128, 128, 64);
                    
                    t = NewTimer();
                    SetTimerData(t, integer(this));
                    this.recoveryTicks = 2;
                    this.isRecovering = true;
                    TimerStart(t, 0.50, true, static method thistype.Recover);
                }
            }
            else
            {
                static if (thistype.onObjectDamageSource.exists)
                {
                    if (this.onObjectDamageSource(amount, source))
                    {
                        if (!this.isRecovering)
                        {
                            this.health -= amount;
                            static if (thistype.onObjectDamage.exists) this.onObjectDamage();
                            static if (thistype.onObjectDeath.exists)
                            {
                                wantRemove = this.onObjectDeath.evaluate();
                            }
                            if (wantRemove)
                            {
                                this.destroy();
                            }
                        }
                    }
                }
                else if (!this.isRecovering)
                {
                    static if (thistype.onObjectDeath.exists)
                    {
                        wantRemove = this.onObjectDeath.evaluate();
                    }
                    if (wantRemove)
                    {
                        this.destroy();
                    }
                }
            }
        }
        
        //===========================================================================
        
        private group collisionGroup;
        
        public method collisionGroupAdd(ObjectInterface obj) -> boolean
        {
            boolean flag = IsUnitInGroup(obj.unit, this.collisionGroup);
        
            if (!flag)
            {
                GroupAddUnit(this.collisionGroup, obj.right);
                GroupAddUnit(this.collisionGroup, obj.left);
            }
        
            return !flag;
        }
        
        public method collisionGroupRemove(ObjectInterface obj) -> boolean
        {
            boolean flag = IsUnitInGroup(obj.unit, this.collisionGroup);
            
            if (flag)
            {
                GroupRemoveUnit(this.collisionGroup, obj.right);
                GroupRemoveUnit(this.collisionGroup, obj.left);
            }
            
            return flag;
        }
        
        public method collisionGroupExists(ObjectInterface obj) -> boolean
        {
            return IsUnitInGroup(obj.unit, this.collisionGroup);
        }
        
        public method collisionGroupClear()
        {
            GroupClear(this.collisionGroup);
        }
        
        public method collisionGroupEnum(code f)
        {
            ForGroup(this.collisionGroup, f);
        }
        
        //===========================================================================
        
        module ObjectEffectModule;
        
        //===========================================================================
        
        private boolean value_enabledPhysics = false;
        
        public method operator enabledPhysics() -> boolean
        {
            return this.value_enabledPhysics && this.active;
        }
        
        public method operator enabledPhysics=(boolean flag)
        {
            this.value_enabledPhysics = flag;
        }
        
        private boolean value_enabledCollision = false;
        
        public method operator enabledCollision() -> boolean
        {
            return this.value_enabledCollision && this.active;
        }
        
        public method operator enabledCollision=(boolean flag)
        {
            this.value_enabledCollision = flag;
        }
        
        //===========================================================================
        
        public method setVertexColor(integer red, integer green, integer blue, integer alpha)
        {
            SetUnitVertexColor(this.right, red, green, blue, alpha);
            SetUnitVertexColor(this.left, red, green, blue, alpha);
        }
        
        public method setTeamColor(playercolor value)
        {
            SetUnitColor(this.right, value);
            SetUnitColor(this.left, value);
        }
        
        public method compareId(integer id) -> boolean
        {
            return (id == thistype.FACING_RIGHT_ID || id == thistype.FACING_LEFT_ID);
        }
    }

    //===========================================================================
    
    private HandleTable ObjectRegistry;
    
    private boolexpr EnumFilter;
    private integer EnumCount;
    private group ObjectGroup = CreateGroup();
    
    public function ObjectGetEnum() -> ObjectInterface
    {
        return ObjectRegistry[GetEnumUnit()];
    }
    
    public function ObjectGetEnumCount() -> integer
    {
        return EnumCount;
    }
    
    public function ObjectEnumInRange(real x, real y, real r, code f)
    {
        EnumCount = 0;
        GroupEnumUnitsInRange(ENUM_GROUP, x, y, r, function () -> boolean {
            if (ObjectRegistry.exists(GetFilterUnit()))
            {
                EnumCount += 1;
                return true;
            }
            return false;
        });
        ForGroup(ENUM_GROUP, f);
        GroupClear(ENUM_GROUP);
    }
    
    public function ObjectEnumInRect(rect r, code f)
    {
        EnumCount = 0;
        GroupEnumUnitsInRect(ENUM_GROUP, r, function () -> boolean {
            if (ObjectRegistry.exists(GetFilterUnit()))
            {
                EnumCount += 1;
                return true;
            }
            return false;
        });
        ForGroup(ENUM_GROUP, f);
        GroupClear(ENUM_GROUP);
    }
    
    public function ObjectEnumAll(code f)
    {
        ForGroup(ObjectGroup, f);
    }
    
    //==============================================================================
    
    public function IsObjectOnScreen(ObjectInterface obj) -> boolean
    {
        real x = CameraEngine.X;
        real y = CameraEngine.Y;
        boolean a = obj.x + obj.boundingBoxMaxX > x + SCREEN_MIN_X;
        boolean b = a && (obj.x + obj.boundingBoxMinX < x + SCREEN_MAX_X);
        boolean c = b && (obj.y + obj.boundingBoxMaxY > y + SCREEN_MIN_Y);
        boolean d = c && (obj.y + obj.boundingBoxMinY < y + SCREEN_MAX_Y);
        return (d);
    }
    
    //==============================================================================
    
    public function ObjectExists(ObjectInterface obj) -> boolean
    {
        return ObjectRegistry.exists(obj.unit);
    }
    
    //==============================================================================

    private struct Hack
    {
        private static method onInit()
        {
            ObjectRegistry = HandleTable.create();
        }
    }
    
    //==============================================================================
    
    private struct ObjectEffectStruct
    {
        private ObjectInterface obj;
        private unit objUnit;
        private unit dummy;
        private effect model;
        
        public static method create(ObjectInterface obj, unit dummy, effect model, real duration) -> thistype
        {
            thistype this = thistype.allocate();
            timer t;
            
            this.ticks = R2I(duration / DEFAULT_PERIOD);
            this.obj = obj;
            this.objUnit = obj.unit;
            this.dummy = dummy;
            this.model = model;
            
            t = NewTimer();
            SetTimerData(t, this);
            TimerStart(t, DEFAULT_PERIOD, true, static method thistype.Handler);
            t = null;
            
            return this;
        }
        
        private integer ticks;
    
        private static method Handler()
        {
            thistype this = GetTimerData(GetExpiredTimer());
            
            this.ticks -= 1;
            if (this.ticks == 0 || !ObjectRegistry.exists(this.objUnit))
            {
                ReleaseTimer(GetExpiredTimer());
                DestroyEffect(this.model);
                KillUnit(this.dummy);
            }
            else
            {
                SetUnitX(this.dummy, this.obj.x);
                SetUnitY(this.dummy, this.obj.y);
            }
        }
    }
    
    module ObjectEffectModule
    {
        public method createEffectAtOrigin(string path, real face, real scale)
        {
            unit u = CreateUnit(PLAYER, DUMMY_ID, this.x, this.y, face);
            SetUnitFlyHeight(u, 64.00, 0.00);
            SetUnitScale(u, scale, scale, scale);
            
            DestroyEffect(AddSpecialEffectTarget(path, u, "origin"));
            
            KillUnit(u);
            u = null;
        }
        
        public method createEffectAtOriginHeight(string path, real face, real scale, real height)
        {
            unit u = CreateUnit(PLAYER, DUMMY_ID, this.x, this.y, face);
            SetUnitFlyHeight(u, height, 0.00);
            SetUnitScale(u, scale, scale, scale);
            
            DestroyEffect(AddSpecialEffectTarget(path, u, "origin"));
            
            KillUnit(u);
            u = null;
        }
        
        public method attachEffectAtOrigin(string path, real duration, real face, real scale)
        {
            unit u = CreateUnit(PLAYER, DUMMY_ID, this.x, this.y, face);
            SetUnitFlyHeight(u, 64.00, 0.00);
            SetUnitScale(u, scale, scale, scale);
            
            ObjectEffectStruct.create(this, u, AddSpecialEffectTarget(path, u, "origin"), duration);
            
            u = null;
        }
    }

}

//! endzinc

Never mind the mess, you're not supposed to read it anyway. It's a work of about 2 years.

 

[Bribe]

That's interesting. I wonder if it was some other unrelated syntax error
and it was targetting the "keyword" line by mistake (it does this a lot)