Howto:Start using vectors and hashes in Nasal: Difference between revisions

Now, this is fairly repetitive and not overly scalable, because the variable names are hardcoded and need to be changed in a lot of places in the source code.  

Whenever you see such a code, it should be obvious that using arrays/vectors would be a good idea.

What we need to save all the other waypoint specific information is a new variable type that serves as the "container" for variables, so that we can save several variables for each waypoint.

One simple way to accomplish this is by using another vector for each waypoint, nested inside the original vector. So that we end up with a two-dimensional data structure. For example, imagine a folder containing subfolders, with folders not having names but rather indices (numbers).

First of all, we are setting up all the different variables for wp4, next, you are storing all variables in a vector called "waypoint4". In the end, we store this vector in another vector named "waypoints".

The only issue here is that you'll need to keep vector ordering in mind so that you can always access the right element number. This could be simplified by using some variables with telling names as the index for each vector:

There's one caveat here: The set function doesn't check the size of the vector, so it may try to access elements that are not there. To fix this, you'd need to use size(vec) call and check its size, and then adjust the size as needed using the set size(vec, size) library function.

There's still one issue though: we are using lots of variables and helpers that all belong to the "waypoints" type, but which clutter our source code.  

So, next, we are going to look into an even more flexible approach that nicely maps each waypoint field and all helper functions to a symbolic name, without having to remember vector indices and such: using Nasal hashes, which are easier to use than complex arrangements using nested vectors.

Now, to access any of these fields, we would use the "dot notation" by first specifying the name of the enclosing context (which is just a fancy word for the name of the hash) and the name of the field we are interested in. You could read this as LOCATION.FIELD (i.e. get FIELD out of location).

This is already a pretty cool thing because you would end up with 5 different containers all having their own set of fields, that you can access and set arbitrarily - without affecting the other containers.

But the cool thing comes next:

This creates three different new containers/hashes by copying the fields from the hash specified in the parents' vector.

Once we start using a hash as a template for other hashes using the "parents" vector, we are creating a class that is copied to each new hash. This new copy of the class is called an "object" after creation.

A "class" is just a template for a certain data type that consists of other data types and provides functions to work with the class. The functions publicly accessible are called its "interface" because these functions are meant to be used by the users of your class. This is in contrast to member fields which are usually not meant to be accessed directly.

Once a class is used as a template to create a new object, we say the class is getting "instantiated", i.e. an instance of the class (an actual object) is created. This makes it then possible to make use of its interface and access member functions (which are methods). Also see {{forum link|p=145769}}.

Now, given that the creation of new hashes using a template class is such a common thing to do - we could just as well add a new function to the parent hash that we can use to construct new hashes. As you could see already, the fields (or members) of a hash are specified in a well-defined form using the key/value format where key and value are separated by a colon: "field_name: value".  

On the other hand, we were just about to make the construction of such hashes much simpler. This can be done by creating a new function that constructs hashes dynamically using a hash:

To iterate through all elements in a "hash the keys(hash) method" is used to produce a vector of the keys for the hash.

This will simply create a function named "new" which accepts an implicit list of arguments (in the implicit "args" vector). The function returns a hash whose parents field is set to the args vector, so this method could even be used for multiple inheritances. Note that the Position3D hash no longer has its constructor, it's just a simple hash in this case.  

# a new function with an implicit arg parameter that simply returns a new hash with the parents' field set to all arguments provided

Given that objects created from the same class template, there needs to be away for a method (class function) to refer to itself (its object), i.e. to refer to the object itself, otherwise, the function wouldn't know what object is meant, and what object it is referring to.

Note how we are just prepending the "me" keyword to the object's field, making it clear that "me" is the requested namespace/context of the field to be retrieved.

As you may remember, the parents' keyword points not just to a single "class template" (hash), but instead to a vector of hashes. This makes it possible to use several different hashes as the template for a new hash:

# seaplane is a new type of vehicle that inherits from the classes boat and aeroplane

* an aeroplane "IS A" vehicle

This was a very simple introduction to object-oriented programming in Nasal.

[[Category: Nasal howto|Module, Create a new Nasal]]