LseStdESSwitch — first device as scheme object

class LseStdSwitch isclass LseDevice
{
    public string ControlName;
    public float OffValue = 0.0;
    public float OnValue = 1.0;
    public float OnValueDelta = 0.2;

    public bool State;

    public void Init(LseDeviceManager mgr, LseLocomotive loco)
    {
        inherited(mgr, loco);

        loco.SetControlHandler(ControlName, me);
    }

    public void ProcessControl(string controlName,
                               LseCabinControlState controlState,
                               float value)
    {
        State = Math.Fabs(value - OnValue) <= OnValueDelta;
    }

    public void SetState(bool state)
    {
        float value = OffValue;
        if (state)
            value = OnValue;
        int controlId = Loco.GetControlId(ControlName);
        Loco.GetControlState(controlId).Value = value;
        Loco.UpdateControlState(controlId);
    }

    public LseStdSwitch Clone(LseStdSwitch ret)
    {
        ret.ControlName = ControlName;
        ret.OffValue = OffValue;
        ret.OnValue = OnValue;
        ret.OnValueDelta = OnValueDelta;

        return ret;
    }

    public LseDevice CloneDevice() { return cast<LseDevice> Clone(new LseStdSwitch()); }
};


class LseStdESSwitch isclass LseGapiESObject, LseStdSwitch
{
    public string[] Contacts = null;
    public string[] InvContacts = null;
    // public bool State = false;
    public float ContactResistance = LseGapiESConst.Zero;
    public float ContactClosedResistance = LseGapiESConst.Inf;

    LseGapiESEdge[] _contactEdges;
    LseGapiESEdge[] _invContactEdges;

    public void Init(LseDeviceManager mgr, LseLocomotive loco)
    {
        inherited(mgr, loco);
    }

    public void InitES(LseGapiElectricScheme mScheme, string name, LlHashSoup elements)
    {
        int i;
        if (Contacts)
        {
            _contactEdges = new LseGapiESEdge[Contacts.size()];
            for (i = 0; i < Contacts.size(); ++i)
            {
                int edgeId = elements.GetNamedTagAsInt(Contacts[i], -1);
                _contactEdges[i] = Scheme.GetEdge(edgeId);
            }
        }

        if (InvContacts)
        {
            _invContactEdges = new LseGapiESEdge[InvContacts.size()];
            for (i = 0; i < InvContacts.size(); ++i)
            {
                int edgeId = elements.GetNamedTagAsInt(InvContacts[i], -1);
                _invContactEdges[i] = Scheme.GetEdge(edgeId);
            }
        }

        mScheme.AddObject(me);
    }

    public void InitES(LseGapiElectricScheme mScheme, string name, LlHashSoup elements, LlHashSoup props)
    {
        int i;
        if (!Contacts)
        {
            LlHashSoup cnts = props.GetNamedSoup("contacts");
            _contactEdges = new LseGapiESEdge[cnts.CountTags()];
            for (i = 0; i < cnts.CountTags(); ++i)
            {
                int edgeId = elements.GetNamedTagAsInt(cnts.GetNamedTag(i), -1);
                _contactEdges[i] = Scheme.GetEdge(edgeId);
            }
        }

        if (!InvContacts)
        {
            LlHashSoup cnts = props.GetNamedSoup("invcontacts");
            _invContactEdges = new LseGapiESEdge[cnts.CountTags()];
            for (i = 0; i < cnts.CountTags(); ++i)
            {
                int edgeId = elements.GetNamedTagAsInt(cnts.GetNamedTag(i), -1);
                _invContactEdges[i] = Scheme.GetEdge(edgeId);
            }
        }
    }

    public void SetPropertiesES(LlHashSoup props)
    {
        ContactResistance = props.GetNamedTagAsFloat("r", ContactResistance);
        ContactClosedResistance = props.GetNamedTagAsFloat("rclosed", ContactClosedResistance);
        State = props.GetNamedTagAsBool("state", State);
    }

    public void UpdateES(float dt)
    {
        LseGapiESEdge[] opened;
        LseGapiESEdge[] closed;

        if (State)
        {
            opened = _contactEdges;
            closed = _invContactEdges;
        }
        else
        {
            closed = _contactEdges;
            opened = _invContactEdges;
        }

        float g = 1.0 / ContactResistance;
        float cg = 1.0 / ContactClosedResistance;

        int i;
        for (i = 0; i < opened.size(); ++i)
            opened[i].SetG(g);
        for (i = 0; i < closed.size(); ++i)
            closed[i].SetG(cg);
    }

    public LseStdESSwitch CloneESSwitch(LseStdESSwitch ret)
    {
        Clone(cast<LseStdSwitch> ret);

        ret.Contacts = Contacts;
        ret.InvContacts = InvContacts;
        ret.ContactResistance = ContactResistance;
        ret.ContactClosedResistance = ContactClosedResistance;

        return ret;
    }

    public LseDevice CloneDevice() { return cast<LseDevice> Clone(new LseStdESSwitch()); }
};