Claims:WE CLAIM:


1. A computer implemented system, comprising:
a memory storing instructions, and a semantic knowledge base, wherein said semantic knowledge base comprises a plurality of web ontology language files having a plurality of concepts, and a plurality of properties specific to each of said plurality of concepts,
a hardware processor communicatively coupled to said memory, wherein said hardware processor is configured by the instructions to:
generate a soft model of said semantic knowledge base using at least one application programming interface (API),
parse said soft model against a corresponding concept from the plurality of concepts,
generate a concept hierarchy for said corresponding concept when said soft model is parsed against said corresponding concept from the plurality of concepts,
create a first data representation file for said corresponding concept based on said concept hierarchy, wherein said data representation file represents a connected information graph around said corresponding concept, and wherein said data representation file comprises a set of strings, an array of data representation objects, and a set of data representation objects arrays, and
generate a plurality of customizable and actionable components when a data representation object structure of said data representation file is parsed.
2. The computer implemented system as claimed in claim 1, wherein said concept hierarchy comprises at least one of a plurality of properties, a plurality of individuals, a plurality of annotations, and a plurality of restrictions associated with said corresponding concept.
3. The computer implemented system as claimed in claim 2, wherein said hardware processor is further configured by said instructions to:
process an input comprising at least one of an addition, a modification, a deletion corresponding to at least one of said plurality of properties, said plurality of individuals, said plurality of annotations, and said plurality of restrictions associated with said corresponding concept in said plurality of customizable and actionable components to obtain at least one of a new data and a modified data, and
generate a second data representation file comprising a new triple or a modified triple based on at least one of said new data and said modified data.


4. The computer implemented system as claimed in claim 3, wherein said hardware processor is further configured by said instructions to: store said new triple or said modified triple of said second data representation file into said semantic knowledge base.

5. The computer implemented system as claimed in claim 3, wherein said hardware processor is further configured by said instructions to:
process said input comprising at least one of an addition of a class in said concept hierarchy and a creation of an instance specific to an existing class in said concept hierarchy, and
generate a third data representation file and parse said third data representation file to create a corresponding customizable and actionable component.

6. The computer implemented system as claimed in claim 1, wherein said hardware processor is further configured by said instructions to:
retrieve an annotation in at least one class for said soft model, wherein said at least one class comprises a set of sub-classes, when said annotation is retrieved from said at least one class, and
create an object representation array such that said object representation array comprises each of said set of sub-classes, and
add a set of individuals of said at least one class to said object representation array.

7. The computer implemented system as claimed in claim 6, wherein said hardware processor is further configured by said instructions to:
display a plurality of properties from said at least one class, and
identify at least one property from said plurality of properties to obtain an identified property, wherein said identified property comprises an annotation tag.

8. The computer implemented system as claimed in claim 7, wherein when a value said annotation tag is set to true, said hardware processor is further configured by said instructions to:
process a value for said identified property to obtain a property value, and
render said identified property into a customizable and actionable component.

9. The computer implemented system as claimed in claim 7, wherein when a value of said annotation tag is set to false, said hardware processor is further configured by said instructions to: refrain from rendering said identified property into a customizable and actionable component.


10. The computer implemented system as claimed in claim 7, wherein said hardware processor is further configured by said instructions to:
determine whether said identified property is an object property,
obtain a set of range of concepts associated with said identified property, when said identified property is determined as said object property, and
invoke an instance of said first data representation file and store a return value in said property value.

11. The computer implemented system as claimed in claim 10, wherein said hardware processor is further configured by said instructions to:
determine whether said property value is NULL, and
identify at least one another property from said plurality of properties when said property value is NULL.

12. The computer implemented system as claimed in claim 11, when said property value is other than NULL, wherein said hardware processor is further configured by said instructions to:
determine whether said object property is functional, and
add said object property to a data representation object from said array of data representation objects when said object property is functional.

13. The computer implemented system as claimed in claim 12, when said object property is other than functional, said hardware processor is further configured by said instructions to:
check a cardinality for said object property,
create an object representation array as a temporary array,
add a property value for said object property with at least one of a maximum cardinality and a minimum cardinality,
add and set an object representation property value to said temporary array, and
add said object property to a data representation object from said array of data representation objects.

14. The computer implemented system as claimed in claim 10, when said identified property is other than said object property, said hardware processor is configured by said instructions to:
determine a cardinality for said identified property,
set said property value for said identified property with at least one of a maximum cardinality and a minimum cardinality, and
add said identified property to a data representation object from said array of data representation objects.


15. The computer implemented system as claimed in claim 3, wherein said hardware processor is further configured by said instructions to:
initialize at least one class and at least one data representation variable associated with at least one data representation object from said array of data representation objects,
identify an object name and an object value for said at least one data representation object from said array of data representation objects,
determine whether said at least one data representation object from said array of data representation objects has more than one object name,
set an identified property to said object name,
obtain an individual by invoking a service when an object value of identified property is said at least one data representation object and said identified property is an object property, wherein said individual comprises a property, a range and a value, and
create a triple based on said individual and add said triple to said semantic knowledge base, wherein said triple comprises an instance, a property, and said individual.

16. The computer implemented system as claimed in claim 15, when said object value of identified property is a data representation object array, wherein said data representation object array comprises a plurality of data representation elements, and wherein said hardware processor is further configured by said instructions to:
determine whether each data representation object element from said plurality of data representation object elements is an data representation object, when said identified property is an object property,
obtain an individual by invoking a service when each data representation object element from said plurality of data representation object elements is data representation object, wherein said individual comprises a property, a range and a value, and
create a triple based on said individual and add said triple to said semantic knowledge base, wherein said triple comprises an instance, a property, and said individual.

17. The computer implemented system as claimed in claim 15, when said object value of said identified property is other than a data representation array, wherein said hardware processor is further configured by said instructions to:
convert said object value to a literal comprising at least one of a string and a primitive with data type of said identified property, and
create a triple and add said triple into said semantic knowledge base, wherein said triple comprises an instance, said identified property, and said literal.


18. The computer implemented system as claimed in claim 16, when said identified property is other than said object property, said hardware processor is further configured by said instructions to:
convert each of said data representation object element to the literal, comprising at least one of a string and a primitive with data type of said identified property, and
create a triple and add sixth triple into said semantic knowledge base, wherein said sixth triple comprises an instance, said identified property, and said literal.

19. The computer implemented system as claimed in claim 16, when each of said data representation object element from said plurality of data representation object elements is other than an data representation object, wherein said hardware processor is further configured by said instructions to:
obtain an individual from said soft model with each of said data representation object element as a uniform resource identifier (URI), and
create a triple based on said individual and add said seventh triple to said semantic knowledge base, wherein said triple comprises an instance, a property, and said individual.

20. A computer implemented method, comprising:
generating a soft model of a semantic knowledge base using at least one application programming interface (API), wherein said semantic knowledge base comprises a plurality of web ontology language files, a plurality of concepts, and a plurality of properties specific to each of said plurality of concepts;
parsing said soft model against a corresponding concept from the plurality of concepts;
generating a concept hierarchy for said corresponding concept when said soft model is parsed against said corresponding concept from the plurality of concepts;
creating a first data representation file for said corresponding concept based on said concept hierarchy, wherein said first data representation file represents a connected information graph around said corresponding concept, and wherein said first data representation file comprises a set of strings, an array of data representation objects, and a set of data representation arrays; and
generating a plurality of customizable and actionable components when a structure of said first data representation file is parsed.

21. The computer implemented method as claimed in claim 20, wherein said concept hierarchy comprises at least one of a plurality of properties, a plurality of individuals, a plurality of annotations, and a plurality of restrictions associated with said corresponding concept.
22. The computer implemented method as claimed in claim 21, further comprising:
processing an input comprising at least one of an addition, a modification, a deletion corresponding to at least one of said plurality of properties, said plurality of individuals, said plurality of annotations, and said plurality of restrictions associated with said corresponding concept in said plurality of customizable and actionable components to obtain at least one of a new data and a modified data; and
generating a second data representation file comprising a new triple or a modified triple based on at least one of said new data and said modified data.

23. The computer implemented method as claimed in claim 21, further comprising: storing said new triple or said modified triple of said second data representation file into said semantic knowledge base.

24. The computer implemented method as claimed in claim 23, further comprising
processing said input comprising at least one of an addition of a class in said concept hierarchy and a creation of an instance specific to an existing class in said concept hierarchy; and
generating a third data representation file and parse said third data representation file to create a corresponding customizable and actionable component.

25. The computer implemented method as claimed in claim 20, further comprising:
retrieving an annotation in at least one class for said soft model, wherein said at least one class comprises a set of sub-classes, when said annotation is retrieved from said at least one class;
creating an object representation array such that said object representation array comprises each of said set of sub-classes; and
adding a set of individuals of said at least one class to said object representation array.
26. The computer implemented method as claimed in claim 25, further comprising
displaying a plurality of properties from said at least one class; and
identifying at least one property from said plurality of properties to obtain an identified property, wherein said identified property comprises an annotation tag.

27. The computer implemented method as claimed in claim 26, wherein when a value of said annotation tag is set to true, said method comprising
processing a value for said identified property to obtain a property value; and
rendering said identified property into a customizable and actionable component.

28. The computer implemented method as claimed in claim 26, wherein when a value of said annotation tag is set to false, said method further comprising refraining from rendering said identified property into a customizable and actionable component.

29. The computer implemented method as claimed in claim 26, further comprising
determining whether said identified property is an object property;
obtaining a set of range of concepts associated with said identified property when said identified property is determined as said object property; and
invoking an instance of said first data representation file and store a return value in said property value.

30. The computer implemented method as claimed in claim 29, further comprising
determining whether said property value is NULL; and
identifying at least one another property from said plurality of properties when said property value is NULL.
31. The computer implemented method as claimed in claim 30, when said property value is other than NULL, said method further comprising
determining whether said object property is functional; and
adding said object property to a data representation object from said array of data representation objects when said object property is functional.

32. The computer implemented method as claimed in claim 31, when said object property is other than functional, said method further comprising
checking a cardinality for said object property;
creating an object representation array as a temporary array;
adding a property value for said object property with at least one of a maximum cardinality and a minimum cardinality;
adding and setting a object representation property value to said temporary array; and
adding said object property to a data representation object from said array of data representation objects.

33. The computer implemented method as claimed in claim 29, when said identified property is other than said object property, said method further comprising
determining a cardinality for said identified property;
setting said property value for said identified property with at least one of a maximum cardinality and a minimum cardinality; and
adding said identified property to a data representation object from said array of data representation objects.


34. The computer implemented method as claimed in claim 22, further comprising
initializing at least one class and at least one data representation variable associated with at least one data representation object from said array of data representation objects;
identifying an object name and an object value for said at least one data representation object from said array of data representation objects;
determining whether said at least one data representation object from said array of data representation objects has more than one object name;
setting an identified property to said object name;
obtaining an individual by invoking a service when said object value of said identified property is said at least one data representation object and said identified property is an object property, wherein said individual comprises a property, a range and a value; and
creating a triple based on said individual and adding said triple to said semantic knowledge base, wherein said triple comprises an instance, a property, and said individual.
35. The computer implemented method as claimed in claim 34, when said object value of identified property is a data representation array, wherein said object representation array comprises a plurality of data representation object elements, and said method further comprising
determining whether each data representation object element from said plurality of data representation object elements is a data representation object, when said identified property is an object property;
obtaining an individual by invoking a service when each data representation element from said plurality of data representation elements is data representation object, wherein said individual comprises a property, a range and a value; and
creating a triple based on said individual and adding said triple to said semantic knowledge base, wherein said triple comprises an instance, a property, and said individual.
36. The computer implemented method as claimed in claim 34, when said object value of said identified property is other than a data representation array, said method further comprising
converting said object value to a literal comprising at least one of a string and a primitive with data type of said identified property; and
creating a triple and adding said triple into said semantic knowledge base, wherein said triple comprises an instance, said identified property, and said literal.

37. The computer implemented method as claimed in claim 35, when said identified property is other than said object property, said method further comprising
converting each of said data representation object element to the literal, comprising at least one of a string and a primitive with data type of said identified property; and
creating a triple and adding said triple into said semantic knowledge base, wherein said triple comprises an instance, said identified property, and said literal.

38. The computer implemented method as claimed in claim 35, when each of said data representation element from said plurality of data representation elements is other than an data representation object, said method further comprising
obtaining an individual from said soft model with each of said data representation object element as a uniform resource identifier (URI); and
creating a triple based on said individual and adding said triple to said semantic knowledge base, wherein said triple comprises an instance, a property, and said individual.
, Description:FORM 2

THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENT RULES, 2003

COMPLETE SPECIFICATION
(See Section 10 and Rule 13)

Title of invention:
SYSTEM AND METHOD FOR AUTO-GENERATING CUSTOMIZABLE AND ACTIONABLE COMPONENTS FOR USER INTERFACE

Applicant:
Tata Consultancy Services Limited
A company Incorporated in India under the Companies Act, 1956
Having address:
Nirmal Building, 9th floor,
Nariman point, Mumbai 400021,
Maharashtra, India

The following specification particularly describes the embodiments and the manner in which it is to be performed.

TECHNICAL FIELD
[0001] The embodiments herein generally relate to user interface generating systems, and, more particularly, to system and method for auto-generating customizable and actionable components for a user interface based on semantic knowledge base.

BACKGROUND
[0002] Semantic web technology is a technology which attempts to make a machine understand data, concepts, context, and relationship between concepts, their dependencies, and constraints, etc. automatically without any manual intervention. Based on that understanding and reasoning, the machine is expected to infer new facts, and if required may come to a decision. In semantic web paradigm, all the physical entities are conceptualized as class in a knowledge base, typically called ontology. Relations between these concepts (or classes) are stored via data type property and object property in the ontology.
[0003] These relations can be of many types e.g., functional, inverse, symmetric etc. Along with this, there are restriction and axioms to accommodate other relevant knowledge about a set of concepts. All the instances of these classes are called individuals which represent real data or facts. All these data and relations are usually stored in triple format. A “Reasoner” usually runs on these whole set of triples to validate and infer new facts/triples from the database.
[0004] There are many available tools like Protégé®, TopBraid Composer®, etc., which assist in creating a whole ontology and editing a part of the whole ontology. Considering the complexity involved in defining relations (e.g., properties) between classes, properly annotating them, setting their types etc. requires a lot of expertise; otherwise the net result may not be useful. Furthermore, correcting errors after validation by the reasoner adhering to the defined set of relation/axioms/restrictions proves to be tough task for a random user.
[0005] For a person, who wants to take advantage of semantic technologies in a particular domain, need to understand all these typical complexities in order to create or edit the ontology and hence correctly populate it with data. This requires a lot of manual effort and expert involvement, thereby requiring end users to acquire detailed learning which might be an overhead for user of that ontology. For example, an application developer need to focus on his application logic, but to do that on a semantic environment, presently he/she needs to not only know details of ontology involved, but also the ontology editing techniques.
[0006] Thus, to separate the concerns of user and ontology expert, i.e., to enable the user to use semantic technologies without going into details technical knowledge, some automation is required. Existing technologies have made attempt to resolve this problem. Some of them define separate language like Object Definition Language (ODL) for ontology creation and asks users to use that language to create/edit ontology but this involves same problem as stated above i.e. users have to learn and gain expertise on that language.
[0007] Although conventional systems and tools allow creating ontology, but they are not presented in the form of ontology modification but more in the form of use of ontology in domain process. This requires understanding of model and it does not allow user to directly access the ontology.

SUMMARY
[0008] The following presents a simplified summary of some embodiments of the disclosure in order to provide a basic understanding of the embodiments. This summary is not an extensive overview of the embodiments. It is not intended to identify key/critical elements of the embodiments or to delineate the scope of the embodiments. Its sole purpose is to present some embodiments in a simplified form as a prelude to the more detailed description that is presented below.
[0009] In view of the foregoing, an embodiment herein provides a computer implemented system, comprising: a memory storing instructions, and a semantic knowledge base, wherein the semantic knowledge base comprises a plurality of web ontology language files having a plurality of concepts, and a plurality of properties specific to each of the plurality of concepts, a hardware processor communicatively coupled to the memory, wherein the hardware processor is configured by the instructions to: generate a soft model of the semantic knowledge base using at least one application programming interface (API), parse the soft model against a corresponding concept from the plurality of concepts and optionally at least one property associated with the corresponding concept, generate a concept hierarchy for the corresponding concept when the soft model is parsed against the corresponding concept from the plurality of concepts, create a first data representation file for the corresponding concept based on the concept hierarchy, wherein the data representation file represents a connected information graph around the corresponding concept, and wherein the data representation file comprises a set of strings, an array of data representation objects, and a set of data representation objects arrays, and generate a plurality of customizable and actionable components when a data representation object structure of the data representation file is parsed, following a simple generic protocol (e.g., creating annotation tags like generatedAs, generatedLike, and/or IsPartOfUI, and assigning some boolean values to them). The concept hierarchy comprises at least one of a plurality of properties, a plurality of individuals, a plurality of annotations, and a plurality of restrictions associated with the corresponding concept.
[0010] Further, the hardware processor is configured by the instructions to: process an input comprising at least one of an addition, a modification, a deletion corresponding to at least one of the plurality of properties, the plurality of individuals, the plurality of annotations, and the plurality of restrictions associated with the corresponding concept in the plurality of customizable and actionable components to obtain at least one of a new data and a modified data, and generate a second data representation file comprising a new triple or a modified triple based on at least one of the new data and the modified data.
[0011] The hardware processor is further configured by the instructions to: store the new triple or the modified triple of the second data representation file into the semantic knowledge base, process the input comprising at least one of an addition of a class in the concept hierarchy and a creation of an instance specific to an existing class in the concept hierarchy, and generate a third data representation file (or the same first data representation file when it is not modified) and parse the third data representation file (or the same first data representation file when it is not modified) to create a corresponding customizable and actionable component. The third data representation file is generated following the same protocol that has been used in case of generation of the first data representation file.
[0012] The hardware processor is further configured by the instructions to: retrieve an annotation in at least one class for the soft model, wherein the at least one class comprises a set of sub-classes, when the annotation is retrieved from the at least one class, and create an object representation array such that the object representation array comprises each of the set of sub-classes, and add a set of individuals of the at least one class to the object representation array. The hardware processor is further configured by the instructions to: display a plurality of properties from the at least one class, and identify at least one property from the plurality of properties to obtain an identified property, wherein the identified property comprises an annotation tag.
[0013] When a value of the annotation tag is set to true, the hardware processor is further configured by the instructions to: process a value for the identified property to obtain a property value, and render the identified property into a customizable and actionable component. When a value of the annotation tag is set to false, the hardware processor is further configured by the instructions to: refrain from rendering the identified property into a customizable and actionable component.
[0014] The hardware processor is further configured by the instructions to: determine whether the identified property is an object property, obtain a set of range of concepts associated with the identified property, when the identified property is determined as the object property, and invoke an instance of the first data representation file and store a return value in the property value. It is further determined whether the property value is NULL, and identify at least one another property from the plurality of properties when the property value is NULL. When the property value is other than NULL, wherein the hardware processor is further configured by the instructions to: determine whether the object property is functional, and add the object property to a data representation object from the array of data representation objects when the object property is functional.
[0015] When the object property is other than functional, the hardware processor is further configured by the instructions to: check a cardinality for the object property, create an object representation array as a temporary array, add a property value for the object property with at least one of a maximum cardinality and a minimum cardinality, add and set an object representation property value to the temporary array, and add the object property to a data representation object from the array of data representation objects.
[0016] When the identified property is other than the object property (i.e., when the identified property is a data type property), the hardware processor is configured by the instructions to: determine a cardinality for the identified property, set the property value for the identified property with at least one of a maximum cardinality and a minimum cardinality, and add the identified property to a data representation object from the array of data representation objects. The hardware processor is further configured by the instructions to: initialize at least one class and at least one object representation variable associated with at least one data representation object from the array of data representation objects, identify an object name and an object value for the at least one data representation object from the array of data representation objects, determine whether the at least one data representation object from the array of data representation objects has more than one object name, set an identified property to the object name, obtain an individual by invoking a service when an object value of identified property is the at least one data representation object and the identified property is an object property, wherein the individual comprises a property, a range and a value, and create a triple based on the individual and add the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, the individual.
[0017] When the object value of identified property is a data representation object array, and the data representation object array comprises a plurality of data representation elements, the hardware processor is further configured by the instructions to: determine whether each data representation object element from the plurality of data representation object elements is an data representation object, when the identified property is an object property, obtain an individual by invoking a service when each data representation object element from the plurality of data representation object elements is data representation object, wherein the individual comprises a property, a range and a value, and create a triple based on the individual and add the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0018] When the object value of the identified property is other than a data representation array, the hardware processor is further configured by the instructions to: convert the object value to a literal comprising at least one of a string and a primitive with data type of the identified property, and create a triple and add the triple into the semantic knowledge base, wherein the triple comprises an instance, the identified property, and the literal.
[0019] When the identified property is other than the object property (i.e., when the identified property is the data type property), the hardware processor is further configured by the instructions to: convert each of the data representation object element to the literal, comprising at least one of a string and a primitive with data type of the identified property, and create a triple and add sixth triple into the semantic knowledge base, wherein the sixth triple comprises an instance, the identified property, and the literal.
[0020] When each of the data representation object element from the plurality of data representation object elements is other than a data representation object, the hardware processor is further configured by the instructions to: obtain an individual from the soft model with each of the data representation object element as a uniform resource identifier (URI), and create a triple based on the individual and add the seventh triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0021] In another embodiment, a computer implemented method is provided. The method comprising: generating a soft model of a semantic knowledge base using at least one application programming interface (API), wherein the semantic knowledge base comprises a plurality of web ontology language files, a plurality of concepts, and a plurality of properties specific to each of the plurality of concepts, parsing the soft model against (i) a corresponding concept from the plurality of concepts, and (ii) optionally at least one property associated with the corresponding concept, generating a concept hierarchy for the corresponding concept when the soft model is parsed against the corresponding concept from the plurality of concepts, creating a first data representation file for the corresponding concept based on the concept hierarchy, wherein the first data representation file represents a connected information graph around the corresponding concept, and wherein the first data representation file comprises a set of strings, an array of data representation objects, and a set of data representation arrays, and generating a plurality of customizable and actionable components when a structure of the first data representation file is parsed following a simple generic protocol. The concept hierarchy comprises at least one of a plurality of properties, a plurality of individuals, a plurality of annotations, and a plurality of restrictions associated with the corresponding concept.
[0022] The method further comprises processing an input comprising at least one of an addition, a modification, a deletion corresponding to at least one of the plurality of properties, the plurality of individuals, the plurality of annotations, and the plurality of restrictions associated with the corresponding concept in the plurality of customizable and actionable components to obtain at least one of a new data and a modified data, and generating a second data representation file comprising a new triple or a modified triple based on at least one of the new data and the modified data, and storing the new triple or the modified triple of the second data representation file into the semantic knowledge base.
[0023] The method further comprises processing the input comprising at least one of an addition of a class in the concept hierarchy and a creation of an instance specific to an existing class in the concept hierarchy, and generating a third data representation file (or the same first data representation file when it is not modified) and parse the third data representation file (or the same first data representation file when it is not modified) to create a corresponding customizable and actionable component. The third data representation file is generated following the same protocol that has been used in case of generation of the first data representation file.
[0024] The method further comprises retrieving an annotation in at least one class for the soft model, wherein the at least one class comprises a set of sub-classes, when the annotation is retrieved from the at least one class, creating an object representation array such that the object representation array comprises each of the set of sub-classes, and adding a set of individuals of the at least one class to the object representation array.
[0025] The method further comprises displaying a plurality of properties for the at least one class, and identifying at least one property from the plurality of properties to obtain an identified property, wherein the identified property comprises an annotation tag. When a value of the annotation tag is set to true, the method comprises processing a value for the identified property to obtain a property value, and rendering the identified property into a customizable and actionable component. When the value of the annotation tag is set to false, the method further comprises refraining from rendering the identified property into a customizable and actionable component.
[0026] The method further comprises determining whether the identified property is an object property, obtaining a set of range of concepts associated with the identified property when the identified property is determined as the object property, and invoking an instance of the first data representation file and store a return value in the property value. The method further comprises determining whether the property value is NULL, and identifying at least one another property from the plurality of properties when the property value is NULL. When the property value is other than NULL, it is determined whether the object property is functional, and the object property is added to a data representation object from the array of data representation objects, when the object property is functional.
[0027] When the object property is other than functional, the method further comprises checking a cardinality for the object property, creating an object representation array as a temporary array, adding a property value for the object property with at least one of a maximum cardinality and a minimum cardinality, adding and setting an object representation property value to the temporary array, and adding the object property to a data representation object from the array of data representation objects.
[0028] When the identified property is other than the object property (i.e., when the identified property is a data type property), the method further comprises determining a cardinality for the identified property, setting the property value for the identified property with at least one of a maximum cardinality and a minimum cardinality, and adding the identified property to a data representation object from the array of data representation objects.
[0029] The computer implemented method further comprises initializing at least one class and at least one object representation variable associated with at least one data representation object from the array of data representation objects, identifying an object name and an object value for the at least one data representation object from the array of data representation objects, determining whether the at least one data representation object from the array of data representation objects has more than one object name, setting an identified property to the object name, obtaining an individual by invoking a service when the object value of the identified property is the at least one data representation object and the identified property is an object property, wherein the individual comprises a property, a range and a value, and creating a triple based on the individual and adding the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, the individual.
[0030] When the object value of identified property is a data representation array, and the object representation array comprises a plurality of data representation object elements, it is determined whether each data representation object element from the plurality of data representation object elements is a data representation object when the identified property is an object property, and an individual is obtained by invoking a service when each data representation element from the plurality of data representation elements is data representation object, wherein the individual comprises a property, a range and a value, and thereby creating a triple based on the individual and adding the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0031] When the object value of the identified property is other than a data representation array, the method further comprises converting the object value to a literal comprising at least one of a string and a primitive with data type of the identified property, and creating a triple and adding the triple into the semantic knowledge base, wherein the triple comprises an instance, the identified property, and the literal.
[0032] When the identified property is other than the object property (i.e., when the identified property is a data type property), the method further comprises converting each of the data representation object element to the literal, comprising at least one of a string and a primitive with data type of the identified property, and creating a triple and adding the triple into the semantic knowledge base, wherein the triple comprises an instance, the identified property, and the literal.
[0033] When each of the data representation element from the plurality of data representation elements is other than a data representation object, the method further comprises obtaining an individual from the soft model with each of the data representation object element as a uniform resource identifier (URI), and creating a triple based on the individual and adding the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0034] In yet another embodiment, one or more non-transitory machine readable information storage mediums comprising one or more instructions is provided. The one or more instructions which when executed by one or more hardware processors causes a method to be performed. The method comprises instructions: generating a soft model of a semantic knowledge base using at least one application programming interface (API), wherein the semantic knowledge base comprises a plurality of web ontology language files, a plurality of concepts, and a plurality of properties specific to each of the plurality of concepts, parsing the soft model against (i) a corresponding concept from the plurality of concepts, and (ii) optionally at least one property associated with the corresponding concept, generating a concept hierarchy for the corresponding concept when the soft model is parsed against the corresponding concept from the plurality of concepts, creating a first data representation file for the corresponding concept based on the concept hierarchy, wherein the first data representation file represents a connected information graph around the corresponding concept, and wherein the first data representation file comprises a set of strings, an array of data representation objects, and a set of data representation arrays, and generating a plurality of customizable and actionable components when a structure of the first data representation file is parsed following a simple generic protocol as described above. The concept hierarchy comprises at least one of a plurality of properties, a plurality of individuals, a plurality of annotations, and a plurality of restrictions associated with the corresponding concept.
[0035] The method further comprises instructions: processing an input comprising at least one of an addition, a modification, a deletion corresponding to at least one of the plurality of properties, the plurality of individuals, the plurality of annotations, and the plurality of restrictions associated with the corresponding concept in the plurality of customizable and actionable components to obtain at least one of a new data and a modified data, and generating a second data representation file comprising a new triple or a modified triple based on at least one of the new data and the modified data, and storing the new triple or the modified triple of the second data representation file into the semantic knowledge base.
[0036] The method further comprises instructions: processing the input comprising at least one of an addition of a class in the concept hierarchy and a creation of an instance specific to an existing class in the concept hierarchy, and generating a third data representation file (or the same first data representation file when it is not modified) and parse the third data representation file (or the same first data representation file when it is not modified) to create a corresponding customizable and actionable component. The third data representation file is generated following the same simple generic protocol that has been used in case of generation of the first data representation file. The method further comprises retrieving an annotation in at least one class for the soft model, wherein the at least one class comprises a set of sub-classes, when the annotation is retrieved from the at least one class, creating an object representation array such that the object representation array comprises each of the set of sub-classes, and adding a set of individuals of the at least one class to the object representation array.
[0037] The method further comprises instructions: displaying a plurality of properties for the at least one class, and identifying at least one property from the plurality of properties to obtain an identified property, wherein the identified property comprises an annotation tag. When a value of the annotation tag is set to true, the method comprises processing a value for the identified property to obtain a property value, and rendering the identified property into a customizable and actionable component. When a value of the annotation tag is set to false, the method further comprises refraining from rendering the identified property into a customizable and actionable component.
[0038] The method further comprises instructions: determining whether the identified property is an object property, obtaining a set of range of concepts associated with the identified property when the identified property is determined as the object property, and invoking an instance of the first data representation file and store a return value in the property value. The method further comprises determining whether the property value is NULL, and identifying at least one another property from the plurality of properties when the property value is NULL. When the property value is other than NULL, it is determined whether the object property is functional, and the object property is added to a data representation object from the array of data representation objects when the object property is functional.
[0039] When the object property is other than functional, the method further comprises instructions: checking a cardinality for the object property, creating an object representation array as a temporary array, adding a property value for the object property with at least one of a maximum cardinality and a minimum cardinality, adding and setting an object representation property value to the temporary array, and adding the object property to a data representation object from the array of data representation objects.
[0040] When the identified property is other than the object property (i.e., when the identified property is a data type property), the method further comprises instructions: determining a cardinality for the identified property, setting the property value for the identified property with at least one of a maximum cardinality and a minimum cardinality, and adding the identified property to a data representation object from the array of data representation objects.
[0041] The method further comprises instructions: initializing at least one class and at least one object representation variable associated with at least one data representation object from the array of data representation objects, identifying an object name and an object value for the at least one data representation object from the array of data representation objects, determining whether the at least one data representation object from the array of data representation objects has more than one object name, setting an identified property to the object name, obtaining an individual by invoking a service when the object value of the identified property is the at least one data representation object and the identified property is an object property, wherein the individual comprises a property, a range and a value, and creating a triple based on the individual and adding the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0042] When the object value of identified property is an object representation array, and the object representation array comprises a plurality of data representation object elements, it is determined whether each data representation object element from the plurality of data representation object elements is a data representation object when the identified property is an object property, and an individual is obtained by invoking a service when each data representation element from the plurality of data representation elements is data representation object, wherein the individual comprises a property, a range and a value, and thereby creating a triple based on the individual and adding the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0043] When the object value of the identified property is other than a data representation array, the method further comprises instructions: converting the object value to a literal comprising at least one of a string and a primitive with data type of the identified property, and creating a triple and adding the triple into the semantic knowledge base, wherein the triple comprises an instance, the identified property, and the literal.
[0044] When the identified property is other than the object property (i.e., when the identified property is a data type property), the method further comprises instructions: converting each of the data representation object element to the literal, comprising at least one of a string and a primitive with data type of the identified property, and creating a triple and adding the triple into the semantic knowledge base, wherein the triple comprises an instance, the identified property, and the literal.
[0045] When each of the data representation element from the plurality of data representation elements is other than a data representation object, the method further comprises instructions: obtaining an individual from the soft model with each of the data representation object element as a uniform resource identifier (URI), and creating a triple based on the individual and adding the triple to the semantic knowledge base, wherein the triple comprises an instance, a property, and the individual.
[0046] It should be appreciated by those skilled in the art that any block diagram herein represent conceptual views of illustrative systems embodying the principles of the present subject matter. Similarly, it will be appreciated that any flow charts, flow diagrams, state transition diagrams, pseudo code, and the like represent various processes which may be substantially represented in computer readable medium and so executed by a computing device or processor, whether or not such computing device or processor is explicitly shown.

BRIEF DESCRIPTION OF THE DRAWINGS
[0047] The embodiments herein will be better understood from the following detailed description with reference to the drawings, in which:
[0048] FIG. 1 illustrates a user interacting with a customizable and actionable components (CAC) generation system according to an embodiment of the present disclosure;
[0049] FIG. 2A is a block diagram of the CAC generation system of FIG. 1 according to an embodiment of the present disclosure;
[0050] FIG. 2B illustrates a 2-way process of CAC generation from stored semantic data and storing back captured data into a semantic knowledge base using the generated CACs according to an embodiment of the present disclosure;
[0051] FIG. 3A is a flow chart illustrating working of the CAC generation system of FIG. 1 according to an embodiment of the present disclosure;
[0052] FIG. 3B illustrates an interaction between a semantic server and a web application in order to create CACs according to an embodiment of the present disclosure;
[0053] FIG. 4A-4B is a flow diagram illustrating a method of creating a data representation file using the CAC generation system of FIG. 1 according to an embodiment of the present disclosure;
[0054] FIGS. 5A-5B illustrate object type properties for class and corresponding data representation snippet according to an embodiment of the present disclosure;
[0055] FIG. 6 is a flow diagram illustrating a method of checking a cardinality on ontological properties before creating corresponding data representation according to an embodiment of the present disclosure;
[0056] FIG. 7A-7B illustrate data type properties for class and corresponding data representation snippet according to an embodiment of the present disclosure;
[0057] FIG. 8A-8B illustrate functional object properties and corresponding data representation snippet according to an embodiment of the present disclosure;
[0058] FIG. 9A-9B illustrate non-functional object properties and corresponding data representation snippet according to an embodiment of the present disclosure;
[0059] FIG. 10A-10B illustrate a whole sample data representation after a complete run of one cycle according to an embodiment of the presentation disclosure;
[0060] FIG. 11 illustrates a resultant sample user interface containing actionable components for the data representation according to an example embodiment of the present disclosure;
[0061] FIG. 12 shows a sample tree structure from a semantic knowledge base stored in a memory and rendered using data representation which is an output of a web service according to an example embodiment of the present disclosure;
[0062] FIG. 13A-13B illustrates a data representation created from the user input using the user interface (UI); and
[0063] FIG. 14A-14B is a flow diagram illustrating a method for inserting data into a triple store by parsing the data representation using the CAC generation system of FIG. 1 according to an embodiment of the present disclosure.

DETAILED DESCRIPTION OF EMBODIMENTS
[0064] The embodiments herein and the various features and advantageous details thereof are explained more fully with reference to the non-limiting embodiments that are illustrated in the accompanying drawings and detailed in the following description. The examples used herein are intended merely to facilitate an understanding of ways in which the embodiments herein may be practiced and to further enable those of skill in the art to practice the embodiments herein. Accordingly, the examples should not be construed as limiting the scope of the embodiments herein.
[0065] As used herein the term “data representation” refers to the methods used internally to represent information stored in a computer/system. In the embodiments described herein data representation techniques like JavaScript Object Notation (JSON), Extensible Markup Language (XML), YAML, etc., are used to represent an information graph (i.e., a concept, individuals and corresponding relationships) into a serializable form for easy interpretation and use.
[0066] As used herein the term “Semantic knowledge base” refers to an information store in a form of graph of information with respect to a schema defined by an ontology. This helps to provide a graph based view based on the relationships defined among the concepts also known as “things”.
[0067] As used herein the term “Concept” refers to different entities of a domain that form roots and other relevant features of various taxonomic trees. Concepts can be synonymous with classes in terms of object oriented programming paradigm. Concepts can be inherited, extended and can have various types of properties linking a given concept with other concepts. Classes/concepts should correspond to naturally occurring sets of things in a domain of discourse.
[0068] As used herein the term “Property” refers to elements that enables assertion of general facts about the members of classes and specific facts about the individuals.
[0069] As used herein the term “Soft model” refers to an in memory represent of a semantic knowledgebase
[0070] As used herein the term “Concept hierarchy” refers to a taxonomy of concepts correspond to naturally occurring sets of things in a domain of discourse
[0071] As used herein the term “Individuals” refers to members of a class or more than one class. A class is a name and collection of properties that describe a set of individuals. And Individuals are members of those set. Individuals are actual entities that can be grouped into some classes.
[0072] As used herein the term “Restriction” in a property restriction is a special kind of class description. It describes an anonymous class, namely a class of all individuals that satisfy the restriction. OWL distinguishes two kinds of property restrictions: value constraints – to constraint the range of values the property can take for a given class description; and cardinality constraints - puts constraints on the number of values a property can take, in the context of the particular class description.
[0073] As used herein the term “Annotation Property” refers to the type of properties defined in OWL syntax that help in providing metadata information about the concepts, individuals, properties, etc.
[0074] As used herein the term “Triple” refers to a data entity (statement) composed of subject-predicate-object where a subject is an entity in concern, having a relationship identified by a predicate and object is the value corresponding predicate.
[0075] As used herein the term “Instance” refers to Individual, and is construed to have similar definition.
[0076] As used herein the term “Cardinality Restrictions”, the Cardinality Restrictions are used to define a specific number of values to be taken by the individuals for a given property.
[0077] As used herein the term “Literal” refers to values for datatype property are termed as literals. Literals can either be plain (no datatype) or typed (user defined or built-in primitive datatypes defined XML schema)
[0078] As used herein the term “Primitive datatype”, the Primitive data types are predefined types of data, which are supported by the programming language. For example, integer, character, and string are all primitive data types. Programmers can use these data types when creating variables in their programs.
[0079] Referring now to the drawings, and more particularly to FIGS. 1 through 14B, where similar reference characters denote corresponding features consistently throughout the figures, there are shown preferred embodiments and these embodiments are described in the context of the following exemplary system and/or method.
[0080] FIG. 1 illustrates a user 102 interacting with a customizable and actionable components (CAC) generation system 104 according to an embodiment of the present disclosure. The customizable and actionable components (CAC) generation system 104 is herein after referred to as the CAC generation system 104. The CAC generation system 104 creates one or more triples based on a semantic knowledge base stored in a memory (not shown in FIG. 1). The CAC generation system 104 further generates a soft model of the semantic knowledge base based on the one or more triples using at least one application programming interface (API).
[0081] The soft model is further parsed by the CAC generation system 104 against a corresponding concept from the plurality of concepts stored in the memory. This enables the CAC generation system 104 to generate a concept hierarchy for the corresponding concept, and thereby a first data representation file for the corresponding concept is created based on the concept hierarchy. The CAC generation system 104 further generates one or more customizable and actionable components, when a data representation object structure of the first data representation file is parsed following a simple generic protocol. The customizable and actionable components are also referred as user interface components. The customizable and actionable components and the user interface components are interchangeably used herein. The user 102 provides one or more user inputs comprising at least one action. The action comprises, but is not limited to an addition, a modification, a deletion of at least one of a property, an individual, an annotation, a restriction or similar ontological components. The action results in obtaining a new data and/or a modified data, which leads to generation of similar data representations.
[0082] With reference to FIG. 1, FIG. 2A is a block diagram of the CAC generation system 104 according to an embodiment of the present disclosure. The CAC generation system 104 comprises, but is not limited to, a memory 202, a hardware processor 204, and an input/output (I/O) interface 206. The memory 202 may further include one or more modules. The memory 202, the hardware processor 204, the input/output (I/O) interface 206, and/or the modules may be coupled by a system bus or a similar mechanism.
[0083] The memory 202, may store instructions, any number of pieces of information, and data, used by a computer system, for example the CAC generation system 104 to implement the functions as described herein. The memory 202 further stores the semantic knowledge base. The semantic knowledge base comprises one or more web ontology language files, where each web ontology language file comprises one or more concepts, one or more properties specific each of the one or more concepts.
[0084] The memory 202 may include for example, volatile memory and/or non-volatile memory. Examples of volatile memory may include, but are not limited to volatile random access memory (RAM). The non-volatile memory may additionally or alternatively comprise an electrically erasable programmable read only memory (EEPROM), flash memory, hard drive, or the like. Some examples of the volatile memory includes, but are not limited to, random access memory, dynamic random access memory, static random access memory, and the like. Some example of the non-volatile memory includes, but are not limited to, hard disks, magnetic tapes, optical disks, programmable read only memory, erasable programmable read only memory, electrically erasable programmable read only memory, flash memory, and the like. The memory 202 may be configured to store information, data, applications, instructions or the like for enabling the CAC generation system 104 to carry out various functions in accordance with various example embodiments. Additionally or alternatively, the memory 202 may be configured to store instructions which when executed by the hardware processor 204 causes the CAC generation system 104 to behave in a manner as described in various embodiments. The memory 202 stores for example, the semantic knowledge base that comprises one or more web ontology language files having one or more concepts, and one or more properties specific to each of the one or more concepts.
[0085] The hardware processor 204 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Further, the hardware processor 204 may comprise a multi-core architecture. Among other capabilities, the hardware processor 204 is configured to fetch and execute computer-readable instructions or modules stored in the memory 202. The hardware processor 204 may include circuitry implementing, among others, audio and logic functions associated with the communication. For example, the hardware processor 204 may include, but are not limited to, one or more digital signal processors (DSPs), one or more microprocessor, one or more special-purpose computer chips, one or more field-programmable gate arrays (FPGAs), one or more application-specific integrated circuits (ASICs), one or more computer(s), various analog to digital converters, digital to analog converters, and/or other support circuits. The hardware processor 204 thus may also include the functionality to encode messages and/or data or information. The hardware processor 204 may include, among other things, a clock, an arithmetic logic unit (ALU) and logic gates configured to support operation of the hardware processor 204. Further, the hardware processor 204 may include functionality to execute one or more software programs, which may be stored in the memory 202 or otherwise accessible to the hardware processor 204.
[0086] As mentioned in FIG. 1, the hardware processor 204 is configured to generate a soft model of the semantic knowledge base based on the triple using at least one application programming interface (API). The hardware processor 204 is further configured to generate a concept hierarchy for a corresponding concept when the soft model is parsed against the corresponding concept from the one or more concepts stored in the memory 202. The hardware processor 204 then creates a first data representation file for the corresponding concept based on the concept hierarchy.
[0087] The first data representation file represents a connected information graph around the corresponding concept. The first data representation file comprises, but is not limited to, a set of strings, an array of data representation objects, a set of data representation objects arrays, and so on. The hardware processor 204 is further configured by the instructions to generate one or more customizable and actionable components (e.g., one or more user interface (UI) components), when a data representation object structure of the first data representation file is parsed by following a simple generic protocol. Similarly, the CAC generation system 104 or the hardware processor 204 operates in 2-ways. User Interface is herein after referred as UI, and is interchangeably used. For example, the CAC generation system 104 can create customizable and actionable components (UI components) from the semantic knowledge base and reverse mechanism can be used to write back to the semantic knowledge base after capturing data from the customizable and actionable components (UI components). The structure of data representation and its special syntax will dictate this 2-way process.
[0088] The CAC generation system 104 (or the hardware processor 204) execute the modules comprising a soft model generation module that generates a soft model of the semantic knowledge base using at least one application programming interface (API). The modules may further comprise a parsing module (not shown in FIG) that parses the soft model against a corresponding concept from the plurality of concepts. The parsing module parses the soft model against a corresponding concept from the plurality of concepts and optionally against at least one property associated with the corresponding concept.
[0089] The modules further comprise a concept hierarchy generation module (not shown in FIG) that generates a concept hierarchy for the corresponding concept when the soft model is parsed against the corresponding concept from the plurality of concepts. The modules further comprises a data representation creation module (not shown in FIG) that creates one or more data representation files for corresponding concepts based on the concept hierarchy. The modules further comprise a user interface generation module (or also referred herein as a customizable and actionable components generation module) that generate one or more customizable and actionable components (or one or more user interface components or a user interface) when a data representation object structure of the one or more data representation file are parsed following a generic protocol.
[0090] The modules for example, but are not limited to, the soft model generation module, the parsing module, the concept hierarchy generation module, the data representation creation module, the user interface generation module (or the customizable and actionable components generation module) are implemented as at least one of a logically self-contained part of a software program, a self-contained hardware component, and/or, a self-contained hardware component, with a logically self-contained part of a software program embedded into each of the hardware component that when executed perform the above and below method(s) described herein, in one embodiment.
[0091] The CAC generation system 104 may provide a web interface that can act or facilitate an Ontology marketplace (e.g., a web service). The Ontology creators may submit their respective Ontology in web interface, where end users can select from a list of these Ontologies to use for their purpose. The selection may be based solely on viewing a user interface (UI) based on Ontology. Further, two or more Ontologies (for example, one technique Ontology and one sensor Ontology) can be used/stitched together through the UI, if required for end user's purpose. This may be used for UI mode.
[0092] Furthermore, an Ontology may be used by multiple users, which can be populated with instances of their own. In such cases, separate session and database (named graph) may be maintained for each user and Ontology. For example, a pair such as pair is maintained for each user. Moreover, upon populating one Ontology with the UI, users can export the Ontology and related named graph to other system(s) to modify it further with the help of Ontology expert (or any domain expert). The data representation, for example, a JSON, that creates the UI can be interpreted differently to get a different variants of UI. This data representation comprises the datatype of the field and that will be a hint for the user to understand what UI component matches with a particular data type (for e.g., when it is a string then UI component can be textbox, and so on). The above aspect providing a web interface by the CAC generation system 104 may be packaged or implemented as “Semantic UI as a Services”.
[0093] FIG. 2B, with reference to FIGS. 1 through 2A, illustrates a 2-way process of CAC generation from stored semantic data and storing back captured data into a semantic knowledge base using the generated CACs according to an embodiment of the present disclosure. The semantic knowledge base (e.g., an ontology), contains the main expert domain knowledge for any domain in an ontology web language (OWL) file in triple format, where ‘S’ is subject, ‘P’ being Predicate, and ‘O’ being object. Other ontology creation languages (for example, Turtle, N3, etc.) other than OWL can be used to create the semantic knowledge base. The soft model of the semantic knowledge base is created, and then is parsed against a given concept (or class), and all its relations for example, properties, individuals, annotations, restrictions, and so on are listed. Frameworks, for example, but are not limited to, JENA (e.g., an open source Semantic Web framework for Java), Sesame, OWL API, etc., can be used for generation of a concept hierarchy.
[0094] Based on the concept hierarchy (or the listing against a concept), a particular tag protocol may be defined to determine whether the property or individual associated with a concept will be shown in a user interface or not. Along with tags, a data representation file (e.g., the first data representation file) is created which represents the connected information graph around a given concept. This output data representation file comprises, but is not limited to, simple strings, array of data representation objects, data representation arrays, and so on. The information graph is mapped into a standard data representation format for any given concept of any given semantic knowledge base thus making it a generic CAC generation system. The tags, include, for example, annotations such as “generatedAs”, “isPartOfUI”, and so on. These annotation tags are supplied by a creator (e.g., a domain expert) of the semantic knowledge base i.e., the ontology at the time of creation of semantic knowledge base.
[0095] Upon creation of the first data representation file, a structure of the first data representation file is parsed to create customizable and actionable components (UI components), for example, but are not limited to, text box, combo box, tabs, labels, and so on. The UI or the UI components are free of semantic nomenclatures, for example, but not limited to, class, data type property, object type property, and so on. The customizable and actionable components (UI or the UI components) may be used by an end user to perform one or more actions.
[0096] The CAC generation system 104 then processes the one or more actions, for example, adding, modifying, deleting new properties, individuals, and so on, without knowing exactly what he/she is doing in terms of semantic technologies, which enables to capture new data (e.g., an individual) or modified data. When the new data or the modified data is captured, the CAC generation system 104 creates a new data representation file from these inputs (e.g., the new data or the modified data). The structure of the new data representation file remains identical (or same) as that of the previous data representation file. The newly created data representation file flows in a reverse order through storing a triple, and creating a semantic knowledge base, where the data is saved back into the semantic knowledge base as depicted in FIG. 2B.
[0097] FIG. 3A, with reference to FIGS. 1 through 2B, is a flow chart illustrating working of the CAC generation system 104 of FIG. 1 according to an embodiment of the present disclosure. In step 302, a triple database is created. In step 304, a soft model is generated for the semantic knowledge base. The soft model is generated (or created), by providing an ontology file, written in OWL language, as one among the inputs. In step 306, data representation file is generated for semantic knowledge base class (or concept) hierarchy. The data representation file may receive a web application as one among the inputs. In step 308, the data representation file is then parsed to create a data representation tree (e.g., JavaScript Object Notation tree). In step 310, an input is obtained that is specific to a selection of registration or an instantiation (e.g., respective web service calls are “SubclassJSON(classURI)” and “InstanceJSON(classURI)”). When a new class registration (e.g., which is equivalent to adding a new concept in the hierarchy), a data representation file is generated for a SubClassDetails, in step 312.
[0098] When a new instance against a class is instantiated, a data representation is generated for an instance of the SelectedClassDetails, in step 314. For example, a third data representation file is generated and parsed to create a corresponding customizable and actionable components. The third data representation file is same as the first data representation file when it is not modified. After making one of these two choices, user selects one concept or class from that hierarchy.
[0099] In step 316, the data representation file is then parsed to create a user interface (or a form). One or more inputs are obtained to fill (or populate) the form, in step 318, and the filled form is parsed to create a new data representation file. In step 320, the newly created data representation file is parsed and inserted into the soft model, and then the process is terminated.
[0100] FIG. 3B, with reference to FIGS. 1 through 3A, illustrates an interaction between a semantic server and a web application to create CACs according to an embodiment of the present disclosure. In an embodiment, the semantic server is part of the CAC generation system 104. FIG. 3B depicts an interaction between the semantic server and the same web application, and the steps as described and depicted in FIG. 3A.
[0101] FIG. 4A-4B, with reference to FIGS. 1 through 3B, is a flow diagram illustrating a method of creating a data representation file using the CAC generation system 104 of FIG. 1 according to an embodiment of the present disclosure. In step 402, class and data representation variables are initialized. In step 404, it is determined that whether the concept has an annotation and annotation tag value is set to individuals. When the concept has the annotation, and annotation tag value is set to individuals, a new sub-data representation array is initialized in step 406, and individuals of concept are added to the data representation array in step 408. In step 410, the data representation array is returned, and the process is terminated. Alternatively, an annotation in the at least one class is retrieved for the soft model. The at least one class comprises a set of sub-classes, when the annotation is determined retrieved from the at least one class. An object representation array is created such that the object representation array comprises each of the set of sub-classes, and a set of individuals of the at least one class is added to the object representation array.
[0102] In step 412, one or more properties of the concept (or class) are listed. In step 414, at least one property is selected from the one or more properties. In step 416, it is determined whether the at least one property has an annotation tag “IsPartOfUI”. In other words, at least one property is identified from the one or more properties to obtain an identified property. It is determined whether the identified property comprises the annotation tag. When the identified property has the annotation tag “IsPartOfUI” and it’s value is set to “True” then a pair is added to the data representation, where the identified property’s name is set as key for the pair in step 418. For instance, when the annotation tag is set to true, a value for the identified property is processed to obtain a property value, and the identified property is rendered into a customizable and actionable component.
[0103] Further, when the annotation tag is set to false, the CAC generation system 104 refrains from rendering the identified property into the customizable and actionable component. When the identified property does not comprise an annotation tag, it is determined whether there are further properties in step 420, and when there are further properties, the step 414 is repeated. When are there no further properties, then data representation object is returned in step 422, and the process is terminated.
[0104] In step 424, it is determined by the CAC generation system 104 that whether the identified property is an object property. In step 426, when the identified property is determined as the object property, a set of range of concepts associated with identified property are obtained. The range of concepts can also be obtained from the restrictions defined on the identified object property as well. Restrictions on a given concept with respect to a given property, defines an anonymous class as the range for the property under consideration. In the purview of value constraints, an ontology (or the semantic knowledge base(s)) can have multiple types of value constraints namely: “allValuesFrom”, “someValuesFrom”, and “hasValue”, etc., and these can be also be parsed based on the type of the restriction. Depending on the type of restriction being used, a corresponding object representation is created and appended. When the restriction over a property is a "hasValue" restriction, then a pair with property as key and the individual or data value as value is added to the object representation. When the restriction is a “someValuesFrom” or “allValuesFrom” type restriction, then individuals/data values of all the concept/s listed in the restriction clause(s) are provided as an array list for the choice of inputs (i.e., similar to generatedAs:Individuals tag) to be made by the user and then added to the object representation. In other words, when the CAC generation system 104 (or the data representation creation module) encounters a restriction for a given property, it is parsed to obtain the range of values to obtain the range of the given property”. In step 428, data representation for an instance of the range concept is invoked and a return value is stored in a property value. In step 430, it is determined whether the property value is NULL.
[0105] When the property value is NULL, the step 420 is repeated, and followed by repeating the step 414. When the property value is not NULL (or other than NULL), it is determined whether the identified object property is functional in step 432. When the identified object property is functional, the property value is added to a data representation object in step 434, and the step of 420 is repeated, and followed by repeating the step 414. When the identified object property is other than functional (or not functional), a cardinality for the identified object property is checked in step 436. Upon checking for the cardinality, an object representation array is created as a temporary array, in step 438, and a property value for the identified object property is added with at least one of a maximum cardinality and a minimum cardinality, in step 440. In step 442, a property value is set to the temporary array, thereby repeating the step of 434 which is adding the identified object property value to a data representation object and the step of 420 is repeated, and followed by repeating the step 414. When the identified property is determined as other than the object property (i.e., when the identified property is a data type property), a cardinality for the identified property is checked in step 444, and the property value for the identified property is set with a maximum cardinality and a minimum cardinality in step 446, and the step 434 is repeated, followed by which the step 420 is repeated.
[0106] FIGS. 5A-5B, with reference to FIGS. 1 through 4B, illustrate object properties for class and corresponding data representation snippet according to an embodiment of the present disclosure. More particularly, FIG. 5A-5B depict a relation diagram and data representation array that depicts technique as a concept used by the CAC generation system 104 of FIG. 1. In FIG. 5A, dotted line signifies properties, and solid lines are annotations. As described in the above FIGS. 1 through 4B, the CAC generation system 104 invokes “ClassFromModel()” which creates a semantic knowledge base model for the concerned class. Then the CAC generation system 104 checks whether the class has a “generatedAs” annotation associated with it. If yes, then the class has been made like enumerated class but actually they are individuals of the parent class. Consequently, it creates a data representation (e.g., JSON) array and each of the items is made as an entry into that the data representation (e.g., JSON) array.
[0107] As can be seen from FIG. 5A, one such case is the “hasProgrammingLanguage” property of “Technique” class. Here the range is “ProgrammingLanguage” class. Corresponding < S, P, O > representation comprises < Technique, hasProgrammingLanguage, ProgrammingLanguage >. Though this class may have a detailed property list of its own, but as the purpose of “Technique” semantic knowledge base is not to dive into details of programming language so a decision is made by the CAC generation system 104 to stop (or terminate) creating such properties and restrict to a mere list consisting individuals like C, C++, JAVA and R, and so on. The “ProgrammingLanguage” class is annotated as “generatedAs” = “Individuals”. Upon close observation of this data representation (e.g., JSON) array, the CAC generation system 104 predicts that this list will be rendered as customizable and actionable components such as, a combo box/ list box in a user interface (UI).
[0108] Next, the CAC generation system 104 lists all the properties of the concerned class and in recursion checks all the properties until the property list ends. If the property has an annotation tag “isPartOfUI” set to “false”, then it means the property need not be rendered in the UI and not needed to be populated by the end user; instead it will be populated by the CAC generation system 104; and hence may be ignored (or disregarded) during data representation creation process. Examples of such properties are “hasTimeComplexity”, “hasSpaceComplexity”, “hasProfileInformation”, “hasRank”, etc. for “Technique” class. When “isPartOfUI” is set to “true”, then that property value is supplied by the end user through a graphical user interface (GUI) screen and hence it will be rendered into the screen. To enable this for a data-type property (where range of the property is not another concept, rather literals like string, and/or integer, etc.), the CAC generation system 104 adds that as an entry into the main data representation object with property value = “UI (Cmin,Cmax)”.
[0109] FIG. 6, with reference to FIGS. 5 through 5B, is a flow diagram illustrating a method of checking a cardinality on ontological properties before creating corresponding data representation according to an embodiment of the present disclosure. More particularly, FIG. 6 depicts the step 436 of FIG. 4. As described in FIG. 5B, to enable this for a data-type property (where range of the property is not another concept, rather literals like string, integer etc.), the CAC generation system 104 adds that as an entry into the main data representation (e.g., JSON) object with property value = “UI(Cmin,Cmax)”. For this one function checkCardinality(propname) is called. Cmin and Cmax are cardinality variables which stores the minimum and maximum number of permissible values (as mentioned in semantic knowledge base) against a property. When these cardinality constraints are not mentioned in semantic knowledge base, then these variables are used to represent the functional nature (also mandatory nature) of the property.
[0110] To elaborate with values, when the semantic knowledge base (or ontology) asserts that one technique should have at least two authors and can have maximum five authors then (Cmin ,Cmax) is set to (2, 5) for the property “hasAuthor” of Technique class. Correspondingly, the CAC generation system 104 understands/realizes that there has to be provision for adding 5 authors (and not more) and accordingly provision for such is created in UI (for e.g., one “add more” button beside the input box provided for inserting names of authors). When such cardinality constraints are absent but the property “hasAuthor” is mentioned to be functional (which means there can be at maximum one value for author against one technique), then this tuple (Cmin ,Cmax) will take values like (0, 1), which also means that in the UI, one value has to be inserted for this property. Accordingly, the CAC generation system 104 may create a mandatory text input box for this property. Below table shows possible example value sets of (Cmin,Cmax) and their corresponding meaning. In this way, the CAC generation system 104 parses UI(Cmin,Cmax) set from the data representation (e.g., JSON) and interprets it accordingly.

Cmin Cmax Meaning
0 0 Not mandatory and as many values as possible
0 1 Not mandatory, only one value
1 0 Mandatory and as many value as possible
1 1 Mandatory with only one value
2 5 Mandatory and minimum 2 values and maximum 5 values

[0111] The resultant input boxes with necessary validation are then rendered in the UI where one or more inputs are received (e.g., a user can enter the values). Examples of such properties of “Technique” class are “hasAuthor”, “hasCompilerVersion”, “hasDescription” and so on, which are depicted in FIG. 7A-7B.
[0112] FIG. 7A-7B, with reference to FIGS. 1 through 6, illustrate data type properties for a class and corresponding data representation snippet according to an embodiment of the present disclosure. More particularly, FIG. 7A-7B illustrates relation diagrams and data representation structure according to an embodiment of the present disclosure. In FIG. 7A, dotted line signifies properties, and solid lines are annotations. To enable the same for an object property, the CAC generation system 104 checks the range class of the property and calls the same function in a recursive manner so that when that range has other object properties associated with it then they are crawled until the leaf node (representing the data type property of the last class node) comes out and that property will be handled as discussed above. One such example is the chain of object properties as shown in FIG. 8A.
[0113] FIG. 8A-8B, with reference to FIGS. 1 through 7B, illustrate functional object properties and corresponding data representation snippet according to an embodiment of the present disclosure. More particularly, FIG. 8A-8B illustrates relation diagrams and data representation structure according to an embodiment of the present disclosure. In FIG. 8A, dotted line signifies properties, and solid lines are annotations. Here the “Technique” class has object type property “hasExecutionInformation” which has a range “ExecutionInformation”. This range class has three data-type properties namely “hasLinks”, “hasIncludes” and “hasLibraries” and each of them needs to be rendered into the UI (i.e., all of them are tagged “isPartOfUI” =”true”). Thus the resultant data representation (e.g., JSON) object representing this case will look like a representation depicted in FIG. 8B.
[0114] To describe the object property case, another example is discussed. Here the “Technique” class has object type property “hasInputParameter” with range class being “Input”. This class has two data type properties, namely “hasParameterName” and “hasParameterDescription” and one object type property “hasParameterType” which again has a range class named “ParameterType”. This class has tag like “generatedAs” = “individuals” and has some individuals like “string”, and/or “float”, etc. The resultant relation diagram and data representation (e.g., JSON) structure is shown in FIG. 9A-9B.
[0115] FIG. 9A-9B, with reference to FIGS. 1 through 8B, illustrate non-functional object properties and corresponding data representation snippet according to an embodiment of the present disclosure. In FIG. 9A, dotted line signifies properties, and solid lines are annotations Once the flow is finished, the final output data representation (e.g., JSON) structure is created (as shown in FIG. 10A-10B).
[0116] FIG. 10A-10B, with reference to FIGS. 1 through 9B, illustrate a whole sample data representation after a complete run of one cycle. More particularly, FIG. 10A-10B depicts an output of data representation (e.g., JSON) of Instances(classURI).
[0117] FIG. 11, with reference to FIGS. 1 through 10B, illustrates a resultant user interface containing actionable components for the same data representation (e.g., JSON) according to an example embodiment of the present disclosure. More particularly, FIG. 11 depicts a user interface that is created against above data representation (e.g., JSON) (for the Technique class). Upon selection of an input parameter option 1102, one or more fields are displayed for which one or more inputs are received. For example, when the input parameter option is clicked (using an input/output interface), the ParameterDescription field 1104, the ParameterName field 1106, and the ParameterType field 1108 are displayed. One or more inputs are received for the ParameterDescription field 1104, the ParameterName field 1106, and the ParameterType field 1108. For example, when an input say, “SamplingRate” is obtained, then the field “ParameterName” is populated with that value, “ParameterDescription” is populated with say “Rate of sampling in time” and “ParameterType” can be “int”. Similarly, another input parameter “SamplingFrequency” can be populated. For receiving (or obtaining) an input for the ParameterType, a drop down list may be provided, and appropriate input is received. The drop down list may comprise string, int, float, double, long short, Boolean, date, dateTime, time, and/or any URI, etc. as depicted in FIG. 9B. An input may further be received on ‘OK’ button as shown in FIG. 11 for submission.
[0118] FIG. 12 shows a sample tree structure from a semantic knowledge base stored in the memory 202 and rendered using data representation (e.g., JSON) which is an output of the web service “classHierarchy()” according to an example embodiment of the present disclosure. More particularly, FIG. 12 depicts a user interface of ontology class hierarchy created from data representation (e.g., JSON) out of “classHierarchy()”, in an example embodiment.
[0119] Once the user interface (UI) is created by aforementioned process flow, the users enter or modify data using that form. On completion of data entry, a reverse process in CAC generation system 104 creates a data representation (e.g., JSON) that may describe the UI-data. The CAC generation system 104 re-uses UI(Cmin, Cmax) data to validate the data and creates the data representation (JSON) accordingly. The structure of this JSON is exactly same except the fact that there are values in this JSON while there were options or indication in the earlier JSON. One example of this newly created JSON out of the UI is depicted in FIG. 13A-13B.
[0120] FIG. 13A-13B, with reference to FIGS. 1 through 12B, illustrates a data representation (e.g., JSON) created from the user input using the UI, based on which the CAC generation system 104 works in reverse mode to send the data to the semantic knowledge base which is depicted in FIG. 14A-14B.
[0121] FIG. 14A-14B, with reference to FIGS. 1 through 13B, is a flow diagram illustrating a method for inserting data into a triple store by parsing the data representation (e.g., JSON) using the CAC generation system 104 of FIG. 1 according to an embodiment of the present disclosure. More particularly, FIG. 14A-14B illustrates creation of individuals for classes, putting (or inserting) values for data type properties, etc. The CAC generation system 104 creates one data representation (for example, JSON) object (e.g., a jObject) and gradually populates the semantic knowledge base by parsing the key-value structure of the data representation (e.g., JSON). At each key-value pair, the CAC generation system 104 checks the value structure: when the value is a data representation (e.g., JSON) array then it means there is a data-type property. When it is a simple one layer data representation (e.g., JSON) object then it means object property. When it is multi-layer data representation (e.g., JSON) object, i.e. it contains an array of data representation (e.g., JSON) objects, then the process recursively calls itself unless each and every layer is found out. Finally, one “insertInstance (prop.range, value)” service is called (or invoked) and corresponding triple is entered into the semantic knowledge base.
[0122] In step 1402, initializing class and data representation variables are initialized which is similar to the step of 402. In step 1404, an object name and an object value are identified for the at least one data representation object from the array of data representation objects. In step 1406, it is determined whether the at least one data representation object from the array of data representation objects has more than one object name. When the at least one data representation object does not have more than one object name, the process is terminated. Else, in step 1408, an identified property is set to the object name. In step 1410, it is determined whether (i) an object value of the identified property is the at least one data representation object, and (ii) the identified property is an object property. In step 1412, when (i) the object value of the identified property is the at least one data representation object, and (ii) the identified property is the object property, an individual is obtained by invoking a service (e.g., insertInstance). The individual comprises a property, a range and a value. In step 1414, a triple is created based on the individual, and the triple is added to the semantic knowledge base. The triple in this case, comprises, an instance, a property, and the individual, and the step 1406 is repeated.
[0123] In step 1416, when (i) the object value of the identified property is not the at least one data representation object, and (ii) the identified property is not the object property, it is determined whether the object value is a data representation array. When the object value is the data representation array, for each element in data representation array, it is determined, whether each data representation (DR) array has more elements, in step 1422. When the object value is other than a data representation array (or not a data representation array), the object value is converted to a literal with data type of the identified property, in step 1418. In step 1420, a triple is created and added to the semantic knowledge base.
[0124] In step 1424, it is determined whether the identified property is an object property. In step 1426, when the identified property is other than the object property (or when the identified property is a data type property), object value (e.g., or each element) is converted to a literal comprising at least one of a string and a primitive with data type of the identified property. In other words, when the identified property is a data type property), object value is converted to a literal comprising at least one of a string and a primitive with data type of the identified property. The primitive may comprise, but is not limited to, int, float, double, long, short, Boolean, date, dateTime, time, and anyURI, etc. In step 1428, a triple is created, upon converting each object value (or each element) to a literal, and the triple is added to the semantic knowledge base, and the step 1422 is repeated. In step 1430, when the identified property is the object property, it is determined whether each element is a data representation object. When each element is a data representation object, an individual is obtained by invoking a service (e.g., calling or invoking an insertInstance service), in step 1432. In step 1434, a triple is created, upon obtaining the individual by invoking a service (e.g., calling or invoking an insertInstance service), and the triple is added to the semantic knowledge base, and the step 1422 is repeated. In step 1436, when each element is other than a data representation object (or when element is not a data representation object), an individual is obtained from the generated soft model with each object representation element as a uniform resource identifier (URI), and the step 1434 is repeated, followed by which the step 1422 is repeated.
[0125] The CAC generation system 104 generates customizable and actionable components/user interfaces independent of the underlying semantic knowledge base to represent a domain knowledge to any naive user. The CAC generation system 104 implements a separation of concerns for semantic knowledge base creator and application user, and thus covering the underlying technicalities; complexities involved in defining classes, their inter-relations, their properties, annotation etc., and represent the knowledge base in an easily usable manner to users who does not need to know aforesaid complexities. The CAC generation system 104 can be implemented to use the data representation (e.g., JSON) in order to represent any domain concept of any domain ontology to communicate with the front end thus making it generic and universal CAC generation system 104 to be used across platforms. This is implemented by way of using one or more protocols to construct the data representation (e.g., JSON) representing a domain concept in the semantic knowledge base, which makes the CAC generation system 104 dynamic to the changes in the semantic knowledge base.
[0126] Adhering to the protocols used in constructing data representation (e.g., JSON), enables one or more users to process various inputs that makes the CAC generation system 104 to create custom user interface (including customizable and actionable components) according to end user requirements. This is achieved by implementing annotation schemes that are followed while creating the underlying semantic knowledge base. Unlike convention systems and methods, the CAC generation system 104 operates 2-ways i.e., it can create customizable and actionable components (user interface components for UI) from the semantic knowledge base and reverse mechanism can be used to write back to the semantic knowledge base after capturing data from the customizable and actionable components (or user interface components) as depicted in FIG. 2B. The structure of data representation (e.g., JSON) and its special syntax will dictate this 2-way process. The concept of class, object properties, data properties, restriction etc., are made transparent to UI user, where he/she does not need to know about nature of any entity shown in screen.
[0127] The written description describes the subject matter herein to enable any person skilled in the art to make and use the embodiments. The scope of the subject matter embodiments is defined by the claims and may include other modifications that occur to those skilled in the art. Such other modifications are intended to be within the scope of the claims if they have similar elements that do not differ from the literal language of the claims or if they include equivalent elements with insubstantial differences from the literal language of the claims.
[0128] It is, however to be understood that the scope of the protection is extended to such a program and in addition to a computer-readable means having a message therein; such computer-readable storage means contain program-code means for implementation of one or more steps of the method, when the program runs on a server or mobile device or any suitable programmable device. The hardware device can be any kind of device which can be programmed including e.g. any kind of computer like a server or a personal computer, or the like, or any combination thereof. The device may also include means which could be e.g. hardware means like e.g. an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or a combination of hardware and software means, e.g., an ASIC and an FPGA, or at least one microprocessor and at least one memory with software modules located therein. Thus, the means can include both hardware means and software means. The method embodiments described herein could be implemented in hardware and software. The device may also include software means. Alternatively, the embodiments may be implemented on different hardware devices, e.g. using a plurality of CPUs.
[0129] The embodiments herein can comprise hardware and software elements. The embodiments that are implemented in software include but are not limited to, firmware, resident software, microcode, etc. The functions performed by various modules described herein may be implemented in other modules or combinations of other modules. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can comprise, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
[0130] The medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk-read only memory (CD-ROM), compact disk-read/write (CD-R/W) and DVD.
[0131] A data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.
[0132] Input/output (I/O) devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers. Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modem and Ethernet cards are just a few of the currently available types of network adapters.
[0133] A representative hardware environment for practicing the embodiments may include a hardware configuration of an information handling/computer system in accordance with the embodiments herein. The system herein comprises at least one processor or central processing unit (CPU). The CPUs are interconnected via system bus to various devices such as a random access memory (RAM), read-only memory (ROM), and an input/output (I/O) adapter. The I/O adapter can connect to peripheral devices, such as disk units and tape drives, or other program storage devices that are readable by the system. The system can read the inventive instructions on the program storage devices and follow these instructions to execute the methodology of the embodiments herein.
[0134] The system further includes a user interface adapter that connects a keyboard, mouse, speaker, microphone, and/or other user interface devices such as a touch screen device (not shown) to the bus to gather user input. Additionally, a communication adapter connects the bus to a data processing network, and a display adapter connects the bus to a display device which may be embodied as an output device such as a monitor, printer, or transmitter, for example.
[0135] The preceding description has been presented with reference to various embodiments. Persons having ordinary skill in the art and technology to which this application pertains will appreciate that alterations and changes in the described structures and methods of operation can be practiced without meaningfully departing from the principle, spirit and scope.