WO2015133947A1 - Method and a computer device for searching for an object in a data structure - Google Patents

Abstract

A computer device and a method thereof is provided for searching for an object in a data structure comprising multiple objects and references, wherein the respective object is associated with a reference denoted key. At least some of the objects of the data structure are traversed to find the sought object, the keys associated with the objects providing a path to the sought object are stored, and the keys providing the path to the sought object are outputted. By using the embodiments it is possible to, given a specific object, find the path, or location, of that object in a data structure, which is not doubly linked.

Description

Method and a computer device for searching for an object in a data structure

Technical Field

The embodiments presented herein relate to a method and a computer device for searching for an object in a data structure.

Background

Developing software applications often requires searches of a certain piece of data in a data structure. Simpler data structures such as arrays, usually offer an instance method called indexOf, which takes an object and returns the numerical index indicative of where an object can be found.

There are several frameworks for JavaScript for instance, which offer additional utility features, such as underscore.js (http:/ /underscorejs.org) and boiler.js

(http:/ /boilerjs.com).

Underscore.js contains a number of different features such as "isEqual" which performs a deep comparison between two objects and "has" which performs a check whether or not an object contains a given key.

Boiler.js also contains different features such as "howDeep" which returns information on the depth that a certain key and "resolve" which returns objects for a key path (i.e. the location is known) or full key path for a key.

However, existing framework solutions do not provide the functionality to search through an arbitrary object structure for a certain object. The function indexOf is only applicable (and indeed useful) for a linear data structures, such as arrays. In addition, it is not evident how to apply indexOf for arbitrarily nested data structures where a child node is not aware of its parent node, since they have higher complexity. Summary

It is therefore desired to be able to, given a specific object, find the path, or location, of that object in a data structure, which is not doubly linked.

That is achieved by a computer device and method for searching for an object in a data structure comprising multiple objects and references, wherein the respective object is associated with a reference denoted key. At least some of the objects of the data structure are traversed to find the sought object, the keys associated with the objects providing a path to the sought object are stored, and the keys providing the path to the sought object is outputted. A difference between the embodiments of the present invention and the "resolve" function is that "resolve" requires knowledge of the key and the input is a string of keys and another difference is that resolve may not provide an unambiguous result (if the same key is located at several occasions the resolve will only output the last occasion) . In the embodiments of the present invention, the input to the method is a variable of object type associated with the searched object (e.g. a pointer to the object) and output is a list of keys which defines the path to the searched object.

According to one aspect of the embodiments of the present invention, a method for searching for an object in a data structure comprising multiple objects and references is provided. The respective object is associated with a reference denoted key. In the method, at least some of the objects of the data structure are traversed to find the sought object, the keys associated with the objects providing a path to the sought object are stored, and the keys providing the path to the sought object are outputted.

According to a further aspect of the embodiments of the present invention a computer device for searching for an object in a data structure comprising multiple objects and references is provided. The respective object is associated with a reference denoted key and the computer device comprises a processor and memory. Said memory contains instructions executable by said processor whereby said computer device is operative to traverse at least some of the objects of the data structure to find the sought object, store the keys associated with the objects providing a path to the sought object, and to output the keys providing the path to the sought object. An advantage with embodiments of the present invention is that objects can be found in a data structure and information of the surrounding objects of the sought object is provided.

One example where the method can be used is in a website which displays data (objects) from a data structure. When clicking on an object it is useful to know where in the data structure the object is located, if adjacent objects should be impacted, or if a parent object should be refreshed. Another example is when it is desired for the files to be aware of the folder that they are located in.

Brief Description of the Drawings

Figure 1 illustrates schematically a computer device that can implement the

embodiments of the present invention.

Figure 2 illustrates schematically a data structure for which the embodiments of the present invention can be applicable. Figure 3 and 4 provide further examples of data structures to explain the

embodiments of the present invention.

Figures 5-7 are flowchart illustrating methods according to the embodiments of the present invention.

Figures 8-9 illustrate a computer device according to different aspects of the embodiments of the present invention.

Detailed description

The embodiments may be described in the general context of computer code or machine-useable instructions, including computer-executable instructions such as program modules, being executed by a computer or other machine, such as a tablets or other handheld device. Generally, program modules including routines, programs, objects, components, data structures, etc., refer to code that perform particular tasks or implement particular abstract data types.

The embodiments may be practiced in a variety of system configurations, including hand-held devices, consumer electronics, general-purpose computers, more specialty computer devices, etc. The embodiments may also be practiced in distributed computing environments where tasks are performed by remote-processing devices that are linked through a communications network.

With reference to figure 1, the computer device 100 includes a bus 110 that directly or indirectly couples the following devices: memory 1 12, one or more processors 114, one or more presentation components 1 16, input/output (I/O) ports 118, input/output components 120, and an illustrative power supply 122. Bus 1 10 represents what may be one or more busses (such as an address bus, data bus, or combination thereof) . Although the various blocks of figure 1 are shown with lines for the sake of clarity, in reality, delineating various components is not so clear, and metaphorically, the lines would more accurately be grey and fuzzy. For example, one may consider a presentation component such as a display device to be an I/O component. Also, processors 114 have memory. The inventors recognize that such is the nature of the art, and reiterate that the diagram of figure 1 is merely illustrative of an exemplary computer device that can be used in connection with one or more embodiments of the present invention. Distinction is not made between such categories as "workstation," "server," "laptop," "tablet", "hand-held device," etc., as all are contemplated within the scope of figure 1 and reference to "computer device."

The computer device 100 typically includes a variety of computer-readable media. Computer-readable media can be any available media that can be accessed by computer device 100 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer-readable media may comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD), servers or similar in a cloud environment or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computer device 100. Communication media typically embodies computer-readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and any type of wireless media. Combinations of any of the above should also be included within the scope of computer-readable media. Memory 112 includes computer-storage media in the form of volatile and/ or nonvolatile memory. The memory may be removable, non-removable, or a combination thereof. Exemplary hardware devices include solid-state memory, hard drives, optical- disc drives, etc. Computer device 100 includes one or more processors that read data from various entities such as memory 1 12 or I/O components 120. Presentation component(s) 116 present data indications to a user or other device. Exemplary presentation components include a display device, speaker, printing component, vibrating component, etc.

I/O ports 118 allow computer device 100 to be logically coupled to other devices including I/O components 120, some of which may be built in. Illustrative components include a microphone, joystick, game pad, satellite dish, scanner, printer, wireless device, etc.

Figure 2 illustrates a data structure 200 where the embodiments of the present invention are applicable. A requirement for the data structure for which the

embodiments are applicable is that the data structure is not doubly linked. Doubly linked refers to the case when a child node is aware of its parent node. Thus in the data structure 200 of figure 2 the child nodes 220 are not aware of their respective parent node 210. The data structure 200 comprises multiple nodes which are referred to as objects and the respective object is associated with a reference denoted key. The key is typically a variable name of the object. As an example, it is desired to know where an object "data2" (i.e. "data2" refers to the data of the objected denoted "smartphone" and datal, data3-data8 also refers to the data of the respective object) is situated in the data structure of figure 2. A variable of object type is input to the method of the embodiment which refers to the object "data2". An object type variable is thus referring to a set of keys and their associated values.

Accordingly, a method for searching for an object in a data structure comprising multiple objects and key is provided. The respective object is associated with a key. At least some of the objects of the data structure are traversed to find data 2, the keys associated with the objects providing a path to the data 2 are stored, and the keys providing the path to data 2 are output.

The embodiments of the present invention will return Docs-Ideas-Good-Smart phone, i.e. the path to the object "data2", defined by keys. In this way, information is provided about the surrounding objects to the object "data2" that may be affected if the objected "data2" in some way is affected. It should be noted that the object "data2" could have own children. Also, the object "data2" could be a text file having keys such as content, name and author.

The embodiments described herein are described using the terms objects and keys which often are used in the context of object oriented programming and these terms are used with a similar meaning in this specification. To further explain the terms objects and keys, an object contains a number of keys. The keys can be used as references to the children of the object. In an example illustrated in figure 3, the key "car" is pointing at an object containing two keys;

"wheels" and "seat". I.e. the object in this case is a collection of keys, "seat" is further pointing at an object containing two keys; "frontseat" and "backseat"

{frontseat:, backseat}. The keys could be seen as a variable name, since they do not contain any information but the keys are used for getting the information. As an example car. wheel would give the value 2 which could indicate the number of wheels of the car and car.seat.frontseat would give blue which indicates that the color of the frontseat is blue. Thus it can also be considered that the keys are owned by an object. The names are referred to as keys, such as "Docs", "Ideas", and "crazy". The keys creates a search path to an object "data2".

To further illustrate the concept of objects and keys, the following example is provided. Figure 4 illustrates a data structure with a folder called "work", which further contains two folders called "A" and "B" wherein "A" and "B" , respectively contains text documents. The folders "work", "A", and "B" and the text documents are objects. The folder name "work" is the key to the folder denoted 300 of figure 4.

To execute "work", would result in

=> { "A": {v_obj l , v_obj2}, "B": {o_obj l , o_obj2}} {...} implies the object, and the string of keys "work.A" returns objects v_obj l=docla and v_obj2=doclb, i.e. the content of docla and doclb. The object is unaware that it is denoted "work".

To execute "work". "A" would result in =>{v_obj l , v_obj2}

The documents in "A" will be provided. Similarly, the string of keys "work.A" returns objects o_obj l=doc2a and o_obj2=doc2b, i.e. the content of doc2a and doc2b.

To execute work.B would result in =>{o_obj l, o_obj2}

The documents in "B" will be provided.

According to embodiments of the present invention, as illustrated schematically in figure 5, a method for searching for an object in a data structure comprising multiple objects and references, wherein the respective object is associated with a reference denoted key. The method comprises traversing 501 at least some of the objects of the data structure to find the sought object, storing 502 the keys associated with the objects providing a path to the sought object, and outputting 503 the keys providing the path to the sought object.

According to one embodiment, for a data structure where a certain object is a sought object, the embodiments can be implemented as described below and as illustrated in figure 6. The input to the method below is the sought object.

600. Setup an empty list, also referred to as key list.

601. For an object in the data structure, push the key of the object to the list.

602. If the object equals the sought object: 602a. Return the list.

602b. Output the returned list. 603. Otherwise, if the object has a reference to at least one child object:

603a. Push the key of the child object to the list and go to 602.

Otherwise, if the object has no reference to at least one child object: 603b. Remove the key from the list and go to a new object and start with 601.

The embodiment of the flowchart of figure 6 could be illustrated by an example where figure 3 is used. In this example, the front seat object is searched for.

An empty list is created and we start with the object denoted "car" (i.e. its key is "car"). => keylist = ["car"].

The object is not equal to the sought object ("car"≠"front seat") but has a reference to at least one child object.

Go to "wheels" => keylist = ["car", "wheels"], "wheels"≠"front seat".

I.e., "front seat" could not be found, remove key "wheels" => keylist = ["car"]

Go to a new object, i.e. "seat"=> keylist = ["car", "seat"] The object is not equal to the sought object ("seat"≠"front seat") but has a reference to at least one child object.

Go to the child object, and the sought object, "front seat" is found. => keylist = ["car", "seat", "front seat"].

The list ["car", "seat", "front seat"] is returned and output.

An alternative way of implementing the embodiments is described below and in figure 7 and in conjunction with figure 2:

701 First, setup an empty list.

For each node (object),

701a. If a node has at least one child, 701b. give the at least one child a reference to the node, referred to as parent.

702. Copy the reference to the sought object and denote the reference current node.

703. Go to the parent of the current node.

704. Which of the parent's children is the current node? Add the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated.

705. If the current node has a parent, go back to parent of the current node at step 703, let current_node point to its parent (i.e. the parent is now denoted the current node), current_node = current_node. parent, else do to step 706.

706. For each node, remove the reference to the parent node.

707. Return the list.

With reference to figure 2 where the sought object is exemplified as data2, the scheme above is exemplified by the following: Let's start on the node (also referred to as object) with the key "Ideas" with the children nodes denoted "Good" and "Bad". The children nodes are provided with a reference back to the parent node ("Ideas") referred to as "parent".

Hence the node "Good" has the children time machine (datal), smart phone (data2) och parent (Ideas). Let's say that there is a reference (variable) denoted "original" pointing at docs. ideas. good. smartphone. Let's copy the reference "original" to

"currentNode" e.g. by using a line like this: var currentNode = original;

Go to parent: docs. ideas. good. smartphone. parent => docs.ideas.good.

Check the parent's children (docs.ideas.good) => timemachine, smarthpone. Compare the children with docs.ideas.good. smartphone => smartphone (where we came from). Add the key of the current node to a list, also referred to as keylist, in this case the key=smartphone.

Go back to parent of the current node, but with currentNode = docs.ideas.good instead of currentNode = docs. ideas. good. smartphone. We are now one step closer to the root. We will then proceed with docs.ideas.good. parent => docs.ideas etc.

Then for each node, remove the reference to the parent node and return the key list comprising the keys providing the path to the sought object, e.g.

Docs. Ideas. Good. Smartphone (if the object data2 is the sought object as illustrated in figure 2). Alternatively, instead of creating parent references, is to directly give each object information about its key list. In this case, step la is replaced by: If a node has children, give all children that are object a property "key list" which is the key list of the node+the key list of the child.

A JavaScript implementation of the method illustrated in figure 6 is provided below: function pathForl tern (root, item) { var path = []; function find(obj) { for (var key in obj) { if (!obj.hasOwnProperty(key)) { continue;

} var val= obj [key]; path.push[key]; if [item == val) { return true;

} If (typeof val === "object") {

If (find(val)) { return true;

}

} path.popQ;

} return false;

} return find (root) ? path : null; }

It should be noted that the names of the variables above are only examples. Further, the function can be implemented in other programming languages. According to an aspect, a computer device 850 (also denoted 100 in figure 1) for searching for an object in a data structure comprising multiple objects and references is provided. The respective object is associated with a reference denoted key. The computer device 850 comprises a processor 810 and memory 820, said memory 820 containing instructions executable by said processor 810 whereby said computer device 850 is operative to:

traverse at least some of the objects of the data structure to find the sought object, store the keys associated with the objects providing a path to the sought object, and to output the keys providing the path to the sought object.

The keys providing the path to the sought object can be provided in a list as described in the embodiments illustrated in figures 6 and 7.

Further the computer device 850 as illustrated in figure 8 may also be operative to receive information of the sought object 870 e.g. by receiving a variable of object type. A user could enter information of the sought object, e.g. data 2, via an input interface 860 such as a keypad connected to the computer device. The list 880 with the path to the object (e.g. Docs. Ideas. Good. Smartphone) could be output via an output interface 860. Thus the computer device described herein could be implemented e.g. by one or more of a processing units and adequate software with suitable storage or memory.

According to an embodiment when a sought object is provided, the computer device 850 is further operative to: setup an empty list, also referred to as key list, a. for an object in the data structure, push the key of the object to the list, b. if the object equals the sought object: return the list, output the returned list, otherwise, and if the object has a reference to at least one child object: push the key of the child object to the list and proceed with b, otherwise, and if the object has no reference to at least one child object: remove the key from the list and go to a new object and proceed with a.

According to another embodiment, the computer device 850 is further operative to: set up an empty list. for each object, if an object has at least one child , to give the at least one child a reference to the object, referred to as parent, copy the reference to the sought object and denote the reference current node, go to the parent of the current node, add the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated, if the current node has a parent, the computer device is operative to denote the parent as the current node, to go to parent of the current node, and to add the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated, else the computer device is operative to: for each node, remove the reference to the parent node, and return the list. The computer device 850 of figure 8 comprises a processor 810, such as a DSP

(Digital Signal Processor) or CPU (Central Processing Unit). The processor 810 can be a single unit or a plurality of units for performing different steps of the method described herein. The computer device 850 also comprises an input/output (I/O) unit 860 for receiving information 870 of the object to be searched for and for outputting a list 880 with the path to the sought object, e.g. to a display. The I/O unit 860 has been illustrated as a single unit in figure 8 but can likewise be in the form of a separate input unit and a separate output unit.

Furthermore, the computer device 850 comprises at least one computer program product 820 in the form of a non-volatile memory, for instance an EEPROM

(Electrically Erasable Programmable Read-Only Memory), a flash memory or a disk drive. The computer program product 820 comprises a computer program 825, which comprises code means which when run on or executed by the computer, such as by the processor, causes the computer device to perform the steps of the method described in the foregoing in connection with figures 5-7. Hence, in an embodiment the code means in the computer program comprises a module 827 configured to implement embodiments as disclosed herein or

combinations thereof. This module 827 essentially performs the steps of the flow diagrams in figures 5-7 when run on the processor 810. Thus, when the module 827 is run on the processor 810 it corresponds to the corresponding units of figure 9. According to figure 9, the computer device comprises in one aspect a traversing unit 910 for traversing at least some of the objects of the data structure to find the sought object, a memory 920 for storing the keys associated with the objects providing a path to the sought object, and an output unit 930 for outputting the keys providing the path to the sought object. The traversing unit 910 is further adapted to traverse the objects of the structure according to the embodiments illustrated in figure 6 and figure 7.

Claims

Claims

1. A method for searching for an object in a data structure comprising multiple objects and references, wherein the respective object is associated with a reference denoted key, the method comprising:

-traversing (501) at least some of the objects of the data structure to find the sought object,

-storing (502) the keys associated with the objects providing a path to the sought object, and

-outputting (503) the keys providing the path to the sought object.

2. The method according to claim 1 , comprising the steps of: setting (600) up an empty list, a. for an object in the data structure, pushing (601) the key of the object to the list, b. if the object equals (602) the sought object: returning (602a) the list, outputting (602b) the returned list, otherwise, and if the object has a reference to at least one child object (603): pushing (603a) the key of the child object to the list and proceeding with b, otherwise, and if the object has no reference to at least one child object (603): removing (603b) the key from the list and go to a new object and proceeding with a.

3. The method according to claim 1 , comprising the steps of: -setting up (701) an empty list. for each object, if an object has at least one child (701a), -giving (701b) the at least one child a reference to the object, referred to as parent,

-copying (702) the reference to the sought object and denote the reference current node,

-going (703) to the parent of the current node,

-adding (704) the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated, if the current node has a parent (705), denoting (705a) the parent as the current node, going (703) to parent of the current node, and -adding (704) the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated, else perform the following: for each node, removing (706) the reference to the parent node, and

-returning (707) the list.

4. The method according to any of claims 2-3, wherein the method is implemented by a JavaScript.

5. A computer device (850) for searching for an object in a data structure comprising multiple objects and references, wherein the respective object is associated with a reference denoted key, the computer device comprises a processor (810) and memory (820), said memory (820) containing instructions executable by said processor (810) whereby said computer device (850) is operative to:

traverse at least some of the objects of the data structure to find the sought object, store the keys associated with the objects providing a path to the sought object, and to output the keys providing the path to the sought object.

6. The computer device (850) according to claim 5, wherein the computer device (850) is further operative to: setup an empty list, also referred to as key list, a. for an object in the data structure, push the key of the object to the list, b. if the object equals the sought object: return the list, output the returned list, otherwise, and if the object has a reference to at least one child object: push the key of the child object to the list and proceed with b, otherwise, and if the object has no reference to at least one child object: remove the key from the list and go to a new object and proceed with a.

7. The computer device (850) according to claim 5, wherein the computer device (850) is further operative to: set up an empty list. for each object, if an object has at least one child (701a), to give the at least one child a reference to the object, referred to as parent, copy the reference to the sought object and denote the reference current node, go to the parent of the current node, add the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated, if the current node has a parent, the computer device is operative to denote the parent as the current node, to go to parent of the current node, and to add the key of the current node as an entry in a list in a subsequent order, such that the path to the sought object is indicated, else the computer device is operative to: for each node, remove the reference to the parent node, and return the list.