co🔗e: Linked List

This Page
Introduction | Usage | Download | Requirements | Acknowledgements

Introduction

Linked lists are suitable as a flexible and modular way to implement simple and powerful code with ease.
This library will allow you to leverage the simplicity, power and flexibility of linked lists.

A linked list is a data structure that represents a sequence of nodes (Elements). This library implements a so called "double linked list", which simply means that the list gives each Element pointers to both the next Element and the previous Element. Unlike an array, a linked list does not provide constant time access to a particular “index” within the list. This means that if you’d like to find the K-th element in the list, you will need to iterate through K elements. The benefit of a linked list is that you can add and remove Elements from the list during runtime so this means you can very easily extend your code with new FB's without extra coding since itteration with Elements is always done in FOR and/or WHILE loops. This means that, by design your code doesn't need to be rewritten, as demonstrated in the example below 👇

Usage

• Insert the Library Reference in your program's library manager.
• Declare a new FB named FB_ExtendedElement
• We need to either 1) extend at least one FB_Element since it has been decorated as ABSTRACT.
  or 2) implement interface: LinkedList.IElement.

Pro Tip
Any new FB that will be a part of the List should preferably use method 2) implement interface. This way FB_ExtendElement will act as a baseclass for your Element without being itself of type "FB_ELEMENT" (EXTENDS means "IS OF CLASS .. ", while IMPLEMENTS means "MAKES USE OF INTERFACE .. "). If you use encapsulation and composition for the appropriate interface, as a bonus it will provide you with more freedom and more flexibility as your FB is not inflicted with the dependancy inversion principle. However, as a penalty it will demand more programming effort since all methods and properties need to be implemented for the interface need to be implemented.

FUNCTION_BLOCK FB_ExtendedElement EXTENDS Element // Element is decorated with ABSTRACT!
VAR
    _itfPrev : IElement;
    _itfNext : IElement;
    _itfList : IList;
    _uiCount : UINT := 0;
END_VAR

// Body
SUPER^();


METHOD IsListMemberOf : BOOL // xMember
VAR_INPUT
    itfList : IList;
END_VAR

// Body
IsListMemberOf := (itfList = THIS^._itfList);


METHOD RemoveElem : IElement

// Body
IF _itfList = 0 THEN
    // This element is not a member of a list
    RemoveElem := 0;
    RETURN;
END_IF
RemoveElem := _itfList.RemoveElem(THIS^);


PROPERTY IsLinkedElem : BOOL

// Get 
GetIsLinkedElem := (_itfList <> 0); // 0 = interface is not initialised (pointing to something)

// Set not implemented 


PROPERTY List : IList

// Get
List := _itfList;

// Set
_itfList := List;


PROPERTY NextElem : IElement

// Get
List := _itfList;

// Set
_itfList := List;


PROPERTY PrevElem : IElement

// Get
PrevElem := _itfPrev;

// Set
_itfPrev := PrevElem;


METHOD ReturnInstance : POINTER TO FB_ExtendedElement

// Body
ReturnInstance := THIS;


METHOD Count : UINT;

// Body
_uiCount := uiCount + 1;

PROPERTY GetCount : UINT

// Get
GetCount := _uiCount;

• Declare an instance of LIST
• Declare an instance of FB_ExtendedElement;

VAR
    BuildList : Bool;
    List : LinkedList.List;
    Extended1: FB_ExtendedElement;
    Extended2: FB_ExtendedElement;
    Extended3: FB_ExtendedElement;
    Extended4: FB_ExtendedElement;     
    ListSize : UDINT := 0;
    itfCurElement : IElement;
END_VAR

// Body
IF BuildList THEN
   List.AppendElement( Extended1 );
   List.AppendElement( Extended2 );
   List.AppendElement( Extended3 );
   List.AppendElement( Extended4 );
   BuildList := FALSE;       
END_IF

ListSize := List.ListSize;            
IF ListSize <> 0 THEN // not empty

    itfCurElement := List.HeadElem; // Point itfCurElement to the first element the list was initialised with

    WHILE itfCurElement <> 0 DO

        FOR i := 1 TO 10 DO
        // Count gets tallied up
            itfCurElement.Count();
        END_FOR;
        CurCount := itfCurElement.GetCount;

        // Get the next element by using the pointer stored in the element itself (we can also use PrevElem to get the previous element)
        itfCurElement := itfCurElement.NextElem;

    END_WHILE

END_IF

PRO TIPS
Always obtain access to elements via the functionblock instance of List.
Element require more burnerplate-code when compared to array's but are also more flexible due to their dynamic nature.

Download

By downloading and using our software you abide by the MIT License

Requirements

https://www.linkedin.com/in/hahermsen

Project Members:

• h-hermsen (admin)
• i-campbell (admin)