Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
DETAILED ACTION
This Office Action is in response to the application filed on 9/16/2024. Claim(s) 1-20 are pending in this application. Claim(s) 1,13 and 19 are independent claims.
Priority
Receipt is acknowledged of certified copies of papers required by 37 CFR 1.55.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1-20 are rejected under 35 U.S.C. 101 because the claimed invention recites a judicial exception, is directed to that judicial exception, an abstract idea, it has not been integrated into practical application and the claims further do not recite significantly more than the judicial exception. Examiner has evaluated the claims under the framework provided in the 2019 Patent Eligibility Guidance published in the Federal Register 01/07/2019 and has provided such analysis below.
Regarding claim 1, the limitations, “parsing the target instruction to determine therefrom at least an operation type of the target instruction and an access path from the target object to target data comprised in the target object”, “searching the target data from the target object according to the access path” and “modifying the target data at least according to the operation type”, as drafted, are functions that, under its broadest reasonable interpretation, recite the abstract idea of a mental process. These limitations encompass a human mind carrying out these functions through observation, evaluation judgment and /or opinion, or even with the aid of pen and paper. For example, the “parsing” limitation can be carried out by a user reading an instruction and writing down the path value in the instruction. The searching limitation can be carried out by a user looking at a document of text and identifying a desired text based on a provided location within the document. The “modifying” limitation can be carried out by a user viewing information and making desired edits at specified points. Thus, these limitations recite and fall within the “Mental Processes” grouping of abstract ideas under Prong 1.
Under Prong 2, the judicial exception is not integrated into a practical application. The additional elements, “receiving a target instruction for modifying a target object”, does nothing more than add insignificant extra solution activity to the judicial exception of mere data gathering and outputting. Accordingly, the additional element does not integrate the recited judicial exception into a practical application, and the claim is therefore directed to the judicial exception. See MPEP 2106.05 (g).
Under Step 2B, the claims do not include additional elements that are sufficient to amount to significantly more than the judicial exception. As stated above in prong 2, the additional element, “receiving a target instruction for modifying a target object”, is merely gathering/outputting data which the courts have identified as well-understood, routine conventional activity. Therefore, the additional element recited in claim 1 do not integrate the judicial exception into a practical application under Prong 2, nor amount to significantly more under Step 2B; thus, cannot provide an inventive concept. Accordingly, the claims are not patent eligible under 35 USC 101.
Regarding claim 2, the elements, “wherein the access path comprises a plurality of fields in sequence, an initial field in the plurality of fields corresponds to the target object, a last field in the plurality of fields corresponds to the target data, and remaining fields in the plurality of fields correspond to intermediate objects between the target object to the target data, the intermediate objects comprise a single object or an array object, wherein a post field of a corresponding field of any array object corresponds to an array member of the array object”, can be classified as field of use and technical environment as the claim simply links the abstract idea to a particular set of field and object types, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim 3, the limitations, “sequentially parsing the plurality of fields from the access path,” and “an attribute corresponding to a post field of the field is searched from attributes comprised in the single object corresponding to the field;” and “and an attribute corresponding to the post field of the field is searched from attributes comprised in the array member” recites additional mental process under Prong 1. The additional elements, “wherein for each field before the last field, if a field corresponds to a single object, the single object corresponding to the field is obtained by reflection” and “If a field corresponds to an array object, the array member corresponding to the post field of the field is obtained by reflection according to the field and a subscript of the post field of the field”, can be classified as mere data gathering and outputting which does not integrate the judicial exception into a practical application under Prong 2, nor amount to significantly more under Step 2B for the reasons provided in the rejection of claim 1.
Regarding claim 4, the limitations, “the parsing the target instruction to determine therefrom at least an operation type of the target instruction and an access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value;” and “the modifying the target data at least according to the operation type comprises: changing a value of the target data according to the target value in response to the operation type being the replace operation”, recites additional mental process under Prong 1. The additional element “wherein the operation type comprises a replace operation;” can be classified as field of use and technical environment as the element simply links the abstract idea to a particular field type, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim 5, the limitation “wherein the changing the value of the target data according to the target value comprises: if a data type of the target data is a basic type, converting the data type of the target value into the basic type, and changing the value of the target data according to the converted target value” and recites additional mental process under Prong 1. The additional element,” if the data type of the target data is an object type, deserializing according to the target value”, merely recites instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea; which does not integrate the judicial exception into a practical application under Prong 2, nor amount to significantly more under Step 2B. See MPEP 2106.05(f). The additional element, “ obtain an instance of the object type, and endowing the instance to the target data”, can be classified as mere data gathering and outputting which does not integrate the judicial exception into a practical application under Prong 2, nor amount to significantly more under Step 2B for the reasons provided in the rejection of claim 1.
Regarding claim 6, the limitations, “the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; ” and “the modifying the target data at least according to the operation type comprises: adding array members or attributes comprised in the target data according to the target value in response to the operation type being the add operation”, recites additional mental process under Prong 1. The additional element “wherein the operation type comprises an add operation” can be classified as field of use and technical environment as the element simply links the abstract idea to a particular field type, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim 7, the limitation, “the modifying the target data at least according to the operation type comprises: setting the value of the target data as a default value in response to the operation type being the remove operation”, recites additional mental process under Prong 1. The additional element “wherein the operation type comprises a remove operation” can be classified as field of use and technical environment as the element simply links the abstract idea to a particular field type, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim 8, the limitations, “the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value;” and “the modifying the target data at least according to the operation type comprises: reordering array members comprised in the target data according to the target value in response to the operation type being the reorder operation”, recites additional mental process under Prong 1. The additional element “wherein the operation type comprises a reorder operation” can be classified as field of use and technical environment as the element simply links the abstract idea to a particular field type, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim 9, the limitations, “the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value;” and “wherein if the operation type is the nested operation, the target value comprises one or more sub-instructions, and an operation type of each sub-instruction comprises one selected from a group of an add operation, a remove operation, a replace operation, a reorder operation and a nested operation”, recites additional mental process under Prong 1. The additional element “wherein the operation type comprises a nested operation” can be classified as field of use and technical environment as the element simply links the abstract idea to a particular field type, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim 10, the additional element, ”if the search is unsuccessful, abandoning a modification of the target data”, merely recites instructions to implement an abstract idea on a generic computer, or merely uses a generic computer or computer components as a tool to perform the abstract idea; which does not integrate the judicial exception into a practical application under Prong 2, nor amount to significantly more under Step 2B. See MPEP 2106.05(f).
Regarding claim 11, the limitations, “if the search is successful, storing the access path and the modified target data in a predetermined cache in an associated manner, wherein, if the data type of the target data is an object, storing the access path, a parent object of the target data and the modified target data in the cache in an associated manner; and if the data type of the target data is a basic type, storing the access path, the modified target data and a class name to which the target data belongs in the cache in an associated manner”, which can be classified as mere data gathering and outputting, does not integrate the judicial exception into a practical application under Prong 2, nor amount to significantly more under Step 2B for the reasons provided in the rejection of claim 1.
Regarding claim 12, the additional elements, “wherein the target object is a pre-built global singleton object”, can be classified as field of use and technical environment as the claim simply links the abstract idea to a particular object type, which does not integrate the abstract idea into a practical application under Prong 2, nor amount to significantly more under step 2B. See MPEP 2106.05(h).
Regarding claim sets 13-18 and claims 19-20, the limitations recited in the claims are similar to those of claims 1-9 and thus are rejected for similar reasons as stated in the rejection of claims 1-9.
Claim 13, further recites, “An electronic device comprising a non-transitory memory and a processor, wherein executable codes are stored in the non-transitory memory, and the executable codes, when executed by the processor, cause the processor to” These elements are recited at a high level of generality such that they amount to no more than mere instructions to apply the exception using a generic computer and/or generic computer components. See MPEP 2106.05(f).
Claim 19, further recites, “A non-transitory computer-readable storage medium storing instructions that cause a processor to:”. These elements are recited at a high level of generality such that they amount to no more than mere instructions to apply the exception using a generic computer and/or generic computer components. See MPEP 2106.05(f).
Claim Rejections - 35 USC § 103
In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status.
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1-4, 6, 8-11, 13-16, and 18-20 are rejected under 35 U.S.C. 103 as being unpatentable over Bryan et al. ( RFC6902:JavaScript Object Notation (JSON) Patch, Published April 2013) hereafter Bryan in view of (US 9015728 B2) hereafter Hulick.
Regarding claim 1, Bryan teaches: A method of modifying data of a software object, comprising:
receiving a target instruction for modifying a target object ([3.Document Structure] “A JSON Patch document is a JSON [RFC4627] document that represents an array of objects. Each object represents a single operation to be applied to the target JSON document. The following is an example JSON Patch document, transferred in an HTTP PATCH request:
PNG
media_image1.png
287
492
media_image1.png
Greyscale
”)
The transferred Json patch request that represents an array of objects, each object representing a single operation (e.g. “remove”, “add”, “replace”, “move”, “copy”) to be applied to the target JSON document corresponds to, a method of modifying data of a software object, comprising: receiving a target instruction for modifying a target object.
and parsing the target instruction to determine therefrom at least an operation type of the target instruction and an access path from the target object to target data comprised in the target object; [] , modifying the target data at least according to the operation type([4. Operations] “Evaluation of a JSON Patch document begins against a target JSON document. Operations are applied sequentially in the order they appear in the array. Each operation in the sequence is applied to the target document; Each operation in the sequence is applied to the target document; the resulting document becomes the target of the next operation. Evaluation continues until all operations are successfully applied or until an error condition is encountered…Operation objects MUST have exactly one "op" member, whose value indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors….Additionally, operation objects MUST have exactly one "path" member. That member's value is a string containing a JSON-Pointer value [RFC6901] that references a location within the target document (the "target location") where the operation is performed.”) Each operation object of the Json patch request must contain a value indicating the operation and the path member; otherwise the system determines an error based on the missing fields of the object. Thus, evaluating the Json patch request by sequentially applying the operations of each array object, wherein the operation specified by the “op” field is applied on the location of the target data within the target document (target location) specified by the “path” field , corresponds to, parsing the target instruction to determine therefrom at least an operation type of the target instruction and an access path from the target object to target data comprised in the target object; modifying the target data at least according to the operation type
Bryan does not explicitly teach: and searching the target data from the target object according to the access path, and if the search is successful []
However, Hulick teaches: and searching the target data from the target object according to the access path, and if the search is successful [].
([ Col 9, Lines 15 - 48] “As an example, an expression can have the following form or syntax in which each portion of the expression is separated by a dot character ‘.’:<Object Instance Identifier>.<Textual Object Element Identifier 1>.<Textual Object Element Identifier 2>.<Textual Object Element Identifier 3>.…Script reflection engine 410 can access each textual object element identifier and sequentially request the object element associated with each textual object element identifier in expression 440 reflectively (i.e., the object element associated with each textual object element identifier is requested using that textual object element identifier). Each successive reflective request can be relative to (or at) an object instance received in response to a previous request for an object element.
Thus, the object element associated with <Textual Object Element Identifier 1> can be requested at a first object instance associated with <Object Instance Identifier> and that request can return a second object instance identifier. Next, the object element associated with <Textual Object Element Identifier 2> can be requested at the object instance associated with the second object instance identifier and that request can return a third object instance identifier. Finally, the object element associated with <Textual Object Element Identifier 3> can be requested at the object instance associated with the third object instance identifier and that request can return a value associated with a third object instance. That value can be provided, for example, to a user of script reflection engine 410 to expose a runtime value or property of instrumented application module 430 to the user. In other words, a user of script reflection engine 410 can receive runtime values, properties, parameters, and/or other runtime information from instrumented application module 430 even though instrumented application module 430 does not expose or export those runtime values, properties, parameters, and/or other runtime information.”) The expression is a “.” delimited string representing an object hierarchy which corresponds to an access path to a desired target data. The initial field of the expression “<Object Instance Identifier>” corresponds to a target object. The last field of the expression “<Textual Object Element Identifier 3> “ corresponds to target data . Parsing the expression to sequentially access each field of the expression, and requesting the corresponding object element reflectively until the data of the last field is returned to the user, corresponds to, and searching the target data from the target object according to the access path, and if the search is successful.
Therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan with, and searching the target data from the target object according to the access path, and if the search is successful, as taught by Hulick; In order implement a reflective searching mechanism that is able to retrieve the target data via nested path objects . Thereby allowing developers to implement modifications to application data even during application runtime.
Regarding claim 2, Bryan and Hulick teach the method of claim 1. Bryan further teaches:
wherein the access path comprises a plurality of fields in sequence, an initial field in the plurality of fields corresponds to the target object, a last field in the plurality of fields corresponds to the target data,
PNG
media_image2.png
768
684
media_image2.png
Greyscale
(see Appendix A.6)
Figure A.6 displays a target Json document to be modified by a Json patch request and the resulting document subsequent to the change. The Json patch request contains an operation for moving data to a target location specified by the path which is a sequence of “/” delimited objects, which corresponds to, wherein the access path comprises a plurality of fields in sequence. Item “A” referencing the initial field “qux” of the path is the target object, Item “B” referencing the last field “thud” of the path is the target data to modify by inserting a value, which corresponds to, an initial field in the plurality of fields corresponds to the target object, a last field in the plurality of fields corresponds to the target data.
and remaining fields in the plurality of fields correspond to intermediate objects between the target object to the target data,
PNG
media_image1.png
287
492
media_image1.png
Greyscale
( See 3.Document Structure)
As stated in the rejection of claim 1, the initial field of a path field corresponds to the target object, and the last field corresponds to the target data. It is well understood in the field of software development that within sequential delimited object paths pointing to data as seen above, fields between the target object and the target data such as “b” in each path are intermediate objects in a hierarchical structure, which corresponds to, and remaining fields in the plurality of fields correspond to intermediate objects between the target object to the target data.
the intermediate objects comprise a single object or an array object,
PNG
media_image1.png
287
492
media_image1.png
Greyscale
( See 3.Document Structure)
([4. Operations] “Additionally, operation objects MUST have exactly one "path" member. That member's value is a string containing a JSON-Pointer value [RFC6901] that references a location within the target document (the "target location") where the operation is performed.”[4.1 add] “ The "add" operation performs one of the following functions, depending upon what the target location references: If the target location specifies an array index, a new value is inserted into the array at the specified index. If the target location specifies an object member that does not already exist, a new member is added to the object.) Json-pointer values are strings of tokens specifying objects or indexes into arrays by default. as illustrated in A.7 by the value fields wherein the types of data are strings, integers and arrays. It is well understood in the field of software development that object types of the underlying path objects including intermediate objects must at least correspond to the data type of the value to be inserted in order to be compatible and successfully insert the value. Thus any object of the path may be an array, value or string depending on the target object’s type and structure which corresponds to, the intermediate objects comprise a single object or an array object. See also Appendix A.1 - A.9 for operations on objects and arrays.
wherein a post field of a corresponding field of any array object corresponds to an array member of the array object.
PNG
media_image3.png
440
554
media_image3.png
Greyscale
(see Appendix A.7)
Fig A.7 displays a target Json document to be modified by a Json patch request, and the resulting document subsequent to the change. Item “A” is a subsequent field (post field) corresponding to the array field “foo” which represents the index of the data to move via the request, which corresponds to, wherein a post field of a corresponding field of any array object corresponds to an array member of the array object.
Regarding claim 3, Bryan and Hulick teach the method of claim 1.
Bryan does not teach: wherein the searching the target data from the target object according to the access path comprises: sequentially parsing the plurality of fields from the access path, wherein for each field before the last field, if a field corresponds to a single object, the single object corresponding to the field is obtained by reflection, and an attribute corresponding to a post field of the field is searched from attributes comprised in the single object corresponding to the field; if a field corresponds to an array object, the array member corresponding to the post field of the field is obtained by reflection according to the field and a subscript of the post field of the field, and an attribute corresponding to the post field of the field is searched from attributes comprised in the array member.
However, Hulick teaches: wherein the searching the target data from the target object according to the access path comprises: sequentially parsing the plurality of fields from the access path,
([Col 9, Lines 15 – 32] “As an example, an expression can have the following form or syntax in which each portion of the expression is separated by a dot character ‘.’:<Object Instance Identifier>.<Textual Object Element Identifier 1>.<Textual Object Element Identifier 2>.<Textual Object Element Identifier 3>.…Script reflection engine 410 can access each textual object element identifier and sequentially request the object element associated with each textual object element identifier in expression 440 reflectively (i.e., the object element associated with each textual object element identifier is requested using that textual object element identifier). Each successive reflective request can be relative to (or at) an object instance received in response to a previous request for an object element. “)
The expression is a “.” delimited string representing an object hierarchy which corresponds to an access path to a desired target data. The initial field of the expression “<Object Instance Identifier>” corresponds to a target object. The last field of the expression “<Textual Object Element Identifier 3> “ corresponds to target data . Accessing each textual object element identifier and sequentially requesting the object element associated with each textual object element identifier in the expression reflectively, corresponds to, wherein the searching the target data from the target object according to the access path comprises: sequentially parsing the plurality of fields from the access path
wherein for each field before the last field, if a field corresponds to a single object, the single object corresponding to the field is obtained by reflection, and an attribute corresponding to a post field of the field is searched from attributes comprised in the single object corresponding to the field; if a field corresponds to an array object, the array member corresponding to the post field of the field is obtained by reflection according to the field and a subscript of the post field of the field, and an attribute corresponding to the post field of the field is searched from attributes comprised in the array member.
([Col 6, Lines 45-50] “ More specifically, the script reflection engine can request access to the object element by invoking a getFieldValue( ) method with the identifier of the derived object instance and the textual object element identifier of the object element as arguments to access a value of a field (i.e., where the object element is a field)” [Col 9, Lines 24 – 31] “Script reflection engine 410 can access each textual object element identifier and sequentially request the object element associated with each textual object element identifier in expression 440 reflectively (i.e., the object element associated with each textual object element identifier is requested using that textual object element identifier). Each successive reflective request can be relative to (or at) an object instance received in response to a previous request for an object element. “) Reflectively invoking the getFieldValue() access at the object instance for a field identifier, corresponds to , if a field corresponds to a single object, the single object corresponding to the field is obtained by reflection. Making the successive reflective request at the object instance returned by the first the getFieldValue() which may be a primitive object or an array until the target data is reached , corresponds to, wherein for each field before the last field, if a field corresponds to a single object, the single object corresponding to the field is obtained by reflection, and an attribute corresponding to a post field of the field is searched from attributes comprised in the single object corresponding to the field; if a field corresponds to an array object, the array member corresponding to the post field of the field is obtained by reflection according to the field and a subscript of the post field of the field, and an attribute corresponding to the post field of the field is searched from attributes comprised in the array member.
Therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan with wherein the searching the target data from the target object according to the access path comprises: sequentially parsing the plurality of fields from the access path, wherein for each field before the last field, if a field corresponds to a single object, the single object corresponding to the field is obtained by reflection, and an attribute corresponding to a post field of the field is searched from attributes comprised in the single object corresponding to the field; if a field corresponds to an array object, the array member corresponding to the post field of the field is obtained by reflection according to the field and a subscript of the post field of the field, and an attribute corresponding to the post field of the field is searched from attributes comprised in the array member, as taught by Hulick; In order implement a reflective searching mechanism that is able to retrieve the target data via nested path objects . Thereby allowing developers to implement modifications to application data even during application runtime.
Regarding claim 4, Bryan and Hulick teach the method of claim 1. Bryan further teaches:
wherein the operation type comprises a replace operation;
the parsing the target instruction to determine therefrom at least an operation type of the target instruction and an access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and the modifying the target data at least according to the operation type comprises: changing a value of the target data according to the target value in response to the operation type being the replace operation.([4. Operations] “Evaluation of a JSON Patch document begins against a target JSON document. Operations are applied sequentially in the order they appear in the array. Each operation in the sequence is applied to the target document; Each operation in the sequence is applied to the target document; the resulting document becomes the target of the next operation. Evaluation continues until all operations are successfully applied or until an error condition is encountered… Operation objects MUST have exactly one "op" member, whose value indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test"; … Additionally, operation objects MUST have exactly one "path" member. That member's value is a string containing a JSON-Pointer value [RFC6901] that references a location within the target document (the "target location") where the operation is performed.”[4.3. replace] “The "replace" operation replaces the value at the target location with a new value. The operation object MUST contain a "value" member whose content specifies the replacement value. The target location MUST exist for the operation to be successful. For example: { "op": "replace", "path": "/a/b/c", "value": 42 } This operation is functionally identical to a "remove" operation for a value, followed immediately by an "add" operation at the same location with the replacement value.”)
When the value of “op” is “replace”, the operation corresponds to, wherein the operation type comprises a replace operation. The replace operation object of the Json patch request must contain fields indicating the operation , the path member and the replacement value; otherwise the system determines an error based on the missing fields of the object. Each operation object of the Json patch request must contain a value indicating the operation and the path member otherwise the system determines an error based on the missing fields of the object. Thus, evaluating the Json patch request by sequentially applying the operations of each array object, wherein the operation specified by the “op” field is applied on the location of the target data within the target document (target location) specified by the “path field”, using the replacement value, corresponds to, the parsing the target instruction to determine therefrom at least an operation type of the target instruction and an access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and the modifying the target data at least according to the operation type comprises: changing a value of the target data according to the target value in response to the operation type being the replace operation.
Regarding claim 6, Bryan and Hulick teach the method of claim 1. Bryan further teaches:
wherein the operation type comprises an add operation;
the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and the modifying the target data at least according to the operation type comprises: adding array members or attributes comprised in the target data according to the target value in response to the operation type being the add operation.([4. Operations] “Evaluation of a JSON Patch document begins against a target JSON document. Operations are applied sequentially in the order they appear in the array. Each operation in the sequence is applied to the target document; Each operation in the sequence is applied to the target document; the resulting document becomes the target of the next operation. Evaluation continues until all operations are successfully applied or until an error condition is encountered… Operation objects MUST have exactly one "op" member, whose value indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test"; … Additionally, operation objects MUST have exactly one "path" member. That member's value is a string containing a JSON-Pointer value [RFC6901] that references a location within the target document (the "target location") where the operation is performed.”[4.1. add] “The "add" operation performs one of the following functions, depending upon what the target location references: If the target location specifies an array index, a new value is inserted into the array at the specified index. If the target location specifies an object member that does not already exist, a new member is added to the object… The operation object MUST contain a "value" member whose content specifies the value to be added. For example: { "op": "add", "path": "/a/b/c", "value": [ "foo", "bar" ] }”) When the value of “op” is “add” , the operation corresponds to, wherein the operation type comprises an add operation; The add operation object of the Json patch request must contain fields indicating the operation , the path member and the add value; otherwise the system determines an error based on the missing fields of the object. Thus, evaluating the Json patch request by sequentially applying the operations of each array object, wherein the operation specified by the “op” field is applied on the location of the target data within the target document (target location) specified by the “path field”, using the add value, corresponds to, the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and the modifying the target data at least according to the operation type comprises: adding array members or attributes comprised in the target data according to the target value in response to the operation type being the add operation.
Regarding claim 8, Bryan and Hulick teach the method of claim 1. Bryan further teaches:
wherein the operation type comprises a reorder operation;
the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and the modifying the target data at least according to the operation type comprises: reordering array members comprised in the target data according to the target value in response to the operation type being the reorder operation.([4. Operations] “Evaluation of a JSON Patch document begins against a target JSON document. Operations are applied sequentially in the order they appear in the array. Each operation in the sequence is applied to the target document; Each operation in the sequence is applied to the target document; the resulting document becomes the target of the next operation. Evaluation continues until all operations are successfully applied or until an error condition is encountered… Operation objects MUST have exactly one "op" member, whose value indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test"; … Additionally, operation objects MUST have exactly one "path" member. That member's value is a string containing a JSON-Pointer value [RFC6901] that references a location within the target document (the "target location") where the operation is performed.”[4.4. move] “The "move" operation removes the value at a specified location and adds it to the target location. The operation object MUST contain a "from" member, which is a string containing a JSON Pointer value that references the location in the target document to move the value from.”)
PNG
media_image4.png
332
588
media_image4.png
Greyscale
(See Appendix A.7)
A.7 is an example of a move operation on an array . When the value of “op” is “move” as applied to arrays , the operation corresponds to, wherein the operation type comprises a reorder operation; The move operation object of the Json patch request must contain fields indicating the operation , the path member and the from field, otherwise the system determines an error based on the missing fields of the object. Thus, evaluating the Json patch request by sequentially applying the operations of each array object, wherein the operation specified by the “op” field is applied on the location of the target data within the target document (target location) specified by the “path field”, using the from field, corresponds to, wherein the operation type comprises a reorder operation; the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and the modifying the target data at least according to the operation type comprises: reordering array members comprised in the target data according to the target value in response to the operation type being the reorder operation.
Regarding claim 9, Bryan and Hulick teach the method of claim 1. Bryan further teaches: wherein the operation type comprises a nested operation;
the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and wherein if the operation type is the [] operation, the target value comprises one or more sub-instructions, and an operation type of each sub-instruction comprises one selected from a group of an add operation, a remove operation, a replace operation, a reorder operation and a [] operation. ([4. Operations] “Evaluation of a JSON Patch document begins against a target JSON document. Operations are applied sequentially in the order they appear in the array. Each operation in the sequence is applied to the target document; Each operation in the sequence is applied to the target document; the resulting document becomes the target of the next operation. Evaluation continues until all operations are successfully applied or until an error condition is encountered…
- Operation objects MUST have exactly one "op" member, whose value indicates the operation to perform. Its value MUST be one of "add", "remove", "replace", "move", "copy", or "test"; …
- Additionally, operation objects MUST have exactly one "path" member. That member's value is a string containing a JSON-Pointer value [RFC6901] that references a location within the target document (the "target location") where the operation is performed. [4.1. add] The "add" operation performs one of the following functions, depending upon what the target location references: If the target location specifies an array index, a new value is inserted into the array at the specified index. If the target location specifies an object member that does not already exist, a new member is added to the object… The operation object MUST contain a "value" member whose content specifies the value to be added. For example: { "op": "add", "path": "/a/b/c", "value": [ "foo", "bar" ] }”
PNG
media_image1.png
287
492
media_image1.png
Greyscale
( See 3.Document Structure)
Json patch requests may comprise more than one operation object within each request as seen above where the remove , add, replace, move and copy objects correspond to sub instructions of a request because the instructions are still executed in sequence. Sub instructions may be from any supported operations for example. The add operation object of the Json patch request contains fields indicating the operation , the path member and the add value.
Evaluating the Json patch request by sequentially applying the operations of each array object, wherein the operation specified by the “op” field is applied on the location of the target data within the target document (target location) specified by the “path field”, using the “op” value, corresponds to, the parsing the target instruction to determine therefrom at least the operation type of the target instruction and the access path from the target object to target data comprised in the target object comprises: parsing the target instruction to determine therefrom the operation type of the target instruction, the access path from the target object to target data in the target object, and a target value; and wherein if the operation type is the [] operation, : the target value comprises one or more sub-instructions, and an operation type of each sub-instruction comprises one selected from a group of an add operation, a remove operation, a replace operation, a reorder operation [].
While Bryan and Hulick do not explicitly teach that the value field can contain a nested operation identifier , the same nested order of operations can be achieved by sequentially ordering operation objects .
Regarding claim 10, Bryan and Hulick teach the method of claim 1. Bryan does not explicitly teach: if the search is unsuccessful, abandoning a modification of the target data.
However, Hulick teaches: if the search is unsuccessful, abandoning a modification of the target data.([Col 2, Lines 43-61] “Reflection can be useful, for example, to determine whether a dynamic instance of an object within an application module includes an element such as a method or field with a particular name statically included in that application module… If the object instance includes an object element with the specified name, the application module can receive a reference to that object element and can access that object element (e.g., invoke for a method or get a data value for a field) using the reference. If the object instance does not include an object element with the specified name, an error, exception, or failure notification can be provided to the application module to inform the application module that the object does not include an object element with the specified name.”)
Searching via reflection and outputting a failure message if the object was not found corresponds to, if the search is unsuccessful, abandoning a modification of the target data.
Therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan with, and if the search is unsuccessful, abandoning a modification of the target, as taught by Hulick; in order to end the search when the object is not found and take appropriate actions to notify the user.
Regarding claim 11, Bryan and Hulick teach the method of claim 1.
Bryan does not teach: if the search is successful, storing the access path and the modified target data in a predetermined cache in an associated manner, wherein, if the data type of the target data is an object, storing the access path, a parent object of the target data and the modified target data in the cache in an associated manner; and if the data type of the target data is a basic type, storing the access path, the modified target data and a class name to which the target data belongs in the cache in an associated manner.
However, Hulick teaches: if the search is successful, storing the access path and the [] target data in a predetermined cache in an associated manner,
if the data type of the target data is an object, storing the access path, a [] object of the target data and the [] target data in the cache in an associated manner;
and if the data type of the target data is a basic type, storing the access path, the [] target data and a class name to which the target data belongs in the cache in an associated manner.([Col 13, Lines 36 - 51 ] “A value associated with the object element requested at block 542 is cached at block 544. For example, the object instance identifier received at block 543 or a value of a field or method of the object instance associated with that object instance identifier can be stored at a cache within a memory. For example, the value can be stored within a cache indexed by an identifier such as a hash value or digest of the expression including the textual object element identifier requested at block 542. The cache can be accessed in response to subsequent requests for that object element at that object instance. For example, the cache at which the value is stored at block 544 can be the cache accessed at block 530. Such a cache can be particularly useful in high-performance or time-critical systems to decrease the amount of time to access an object element (or a data value associated with that object element).”) When an object associated with a request is found e.g. the object element requested at block 542 , the object instance identifier received at block 543 or a value of a field or method of the object instance associated with that object instance identifier can be stored at a cache within a memory indexed by the expression of the request . Objects can be of object type or primitive types. Hulick allows for the cache to store in the cache a field or method of the object instance associated with that object instance identifier which corresponds to, : if the search is successful, storing the access path and the [] target data in a predetermined cache in an associated manner, if the data type of the target data is an object, storing the access path, a parent object of the target data and the [] target data in the cache in an associated manner; and if the data type of the target data is a basic type, storing the access path, the [] target data and a class name to which the target data belongs in the cache in an associated manner.
While Hulick does not explicitly teach that the data stored is “modified” target data, when combined with the modification operations of Bryan the data identified through search corresponds to “modified” target data.
Therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan with: if the search is successful, storing the access path and the modified target data in a predetermined cache in an associated manner, if the data type of the target data is an object, storing the access path, a parent object of the target data and the modified target data in the cache in an associated manner; and if the data type of the target data is a basic type, storing the access path, the [] target data and a class name to which the target data belongs in the cache in an associated manner, as taught by Hulick; in order to decrease the amount of time to access an object element for future retrievals.
Regarding claim 13, it is a device claim having similar limitations cited in the rejection of claim 1. Thus claim 13 is also rejected under the same rationale as cited in the rejection of claim 1 above.
Regarding claim 14, it is a device claim having similar limitations cited in the rejection of claim 2. Thus claim 14 is also rejected under the same rationale as cited in the rejection of claim 2 above.
Regarding claim 15, it is a device claim having similar limitations cited in the rejection of claim3. Thus claim 15 is also rejected under the same rationale as cited in the rejection of claim 3 above.
Regarding claim 16, it is a device claim having similar limitations cited in the rejection of claim 4. Thus claim 16 is also rejected under the same rationale as cited in the rejection of claim 4 above.
Regarding claim 18, it is a device claim having similar limitations cited in the rejection of claim 11. Thus claim 18 is also rejected under the same rationale as cited in the rejection of claim 11 above.
Regarding claim 19, it is a non-transitory claim having similar limitations cited in the rejection of claim 1. Thus claim 19 is also rejected under the same rationale as cited in the rejection of claim 1 above.
Regarding claim 20, it is a non-transitory claim having similar limitations cited in the rejection of claim 2. Thus claim 20 is also rejected under the same rationale as cited in the rejection of claim 2 above.
Claims 5 and 17 are rejected under 35 U.S.C. 103 as being unpatentable over Bryan et al. ( RFC6902:JavaScript Object Notation (JSON) Patch, Published April 2013) hereafter Bryan in view of (US 9015728 B2) hereafter Hulick and further in view of (CN 201210480564 A) hereafter Jiang.
Regarding claim 5, Bryan and Hulick teach the method of claim 4.
Bryan and Hulick do not teach: wherein the changing the value of the target data according to the target value comprises: if a data type of the target data is a basic type, converting the data type of the target value into the basic type, and changing the value of the target data according to the converted target value; and if the data type of the target data is an object type, deserializing according to the target value to obtain an instance of the object type, and endowing the instance to the target data.
However, Jiang suggests: wherein the changing the value of the target data according to the target value comprises: if a data type of the target data is a basic type, converting the data type of the target value into the basic type, and changing the value of the target data according to the converted target value; (see uploaded translation [21] “if preset simple types, obtaining the byte stream in the other bytes corresponding to the identification byte, and the other byte is the corresponding object. judging whether the target object and the type of the corresponding object is the same, if they are the same, then the corresponding object assigned to the target object, if not the same, then the type of the corresponding object is the type of the target object. and assigning the converted the corresponding object to the target object,” ) When the source data resolves to a preset simple type , the corresponding object is compared against the target object’s type and when the types differ the corresponding object is converted to the type of the target object prior to assignment , which corresponds to, wherein the changing the value of the target data according to the target value comprises: if a data type of the target data is a basic type, converting the data type of the target value into the basic type, and changing the value of the target data according to the converted target value;
and if the data type of the target data is an object type, deserializing according to the target value to obtain an instance of the object type, and endowing the instance to the target data.([21-22] “if is not the predetermined simple type, acquiring the descriptive data from the byte stream, and acquiring information of the target property of the target object in the description data query and the target attribute of the same name described by attribute. The description data serializing out object, judging the type and object serialization of said target object is the same, if they are the same, then the antitone attribute of the object corresponding to the target object, if they are different, then the type of the antitone object into the type of the target object, and assigning the converted object attribute corresponding to the target object. In the technology solution, the serializing process, it can through object conversion device, with respect to data of the target objects of different types to be converted, the type same as the target object, and obtaining data from byte processing de-serializing treatment, relative de-serializing method of less time, so antitone with high efficiency.”) When the source data is not a preset simple type , descriptive data is retrieved and matched top the target objects attribute, an object is deserialized from the descriptive data and the resulting object’s value is assigned to the corresponding attribute of the target object, which corresponds to, therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan and Hulick with, wherein the changing the value of the target data according to the target value comprises: if a data type of the target data is a basic type, converting the data type of the target value into the basic type, and changing the value of the target data according to the converted target value; and if the data type of the target data is an object type, deserializing according to the target value to obtain an instance of the object type, and endowing the instance to the target data, as taught by Jiang in order to reduce error produce by attempting to insert into incompatible field types.
Regarding claim 17, it is a device claim having similar limitations cited in the rejection of claim 5. Thus claim 17 is also rejected under the same rationale as cited in the rejection of claim 5 above.
Claim 7 is rejected under 35 U.S.C. 103 as being unpatentable over Bryan et al. ( RFC6902:JavaScript Object Notation (JSON) Patch, Published April 2013) hereafter Bryan in view of (US 9015728 B2) hereafter Hulick and further in view of (How to perform partial resource updates with JSON Patch and ASP.NET Core, Published April 11, 2016) hereafter Foster.
Regarding claim 7, Bryan and Hulick teach the method of claim 1.
Bryan and Hulick do not explicitly teach: wherein the operation type comprises a remove operation; the modifying the target data at least according to the operation type comprises: setting the value of the target data as a default value in response to the operation type being the remove operation.
However, Foster teaches: wherein the operation type comprises a remove operation; the modifying the target data at least according to the operation type comprises: setting the value of the target data as a default value in response to the operation type being the remove operation.
([Resetting property values] ”To reset a property value we use the remove operation. Again this is due to the fact that we cant actually remove the property from the C# class definition so instead the ASP.NET Core implementation will set a property back to its default value i.e. default(T).”) The remove operation which sets a property back to its default value corresponds to , wherein the operation type comprises a remove operation; the modifying the target data at least according to the operation type comprises: setting the value of the target data as a default value in response to the operation type being the remove operation.
Therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan with, wherein the operation type comprises a remove operation; the modifying the target data at least according to the operation type comprises: setting the value of the target data as a default value in response to the operation type being the remove operation, as taught by Foster; in order to ensure that the use of the remove operation is applicable to a plurality of technological domains (e.g. replacing data in C# code ) without violating the structural constraints imposed by the domain (e.g. ensuring that deleted values don’t cause errors from missing type declarations).
Claim 12 is rejected under 35 U.S.C. 103 as being unpatentable over Bryan et al. ( RFC6902:JavaScript Object Notation (JSON) Patch, Published April 2013) hereafter Bryan in view of (US 9015728 B2) hereafter Hulick and further in view of Konkus et al. (US 10015242 B2) hereafter Konkus.
Regarding claim 12, Bryan and Hulick teach the method of claim 1. Bryan and Hulick do not teach: wherein the target object is a pre-built global singleton object.
However, Konkus teaches: wherein the target object is a pre-built global singleton object.
([Col 10, Lines 32-36] “a domain bean has a collection of server beans. mandatory singletons—e.g. a server bean always has an ssl bean which is automatically created and cannot be deleted.”[Col 22, Lines 41-57] “In accordance with an embodiment, to modify an application server bean, a JSON object can be constructed containing the values to change then the http POST method can be invoked on a corresponding REST URL, passing in that JSON object as the request body. … Modification of the application server bean is similar to an http PATCH operation where only part of the bean is modified, rather than sending in all of the bean's properties each time.”) The server bean is a global singleton in a collection which corresponds to, wherein the target object is a pre-built global singleton object.
Therefore, it would have been obvious to one of ordinary skill in the art to which said subject matter pertains before the effective filing date of the claimed invention to combine Bryan and Hulick with, wherein the target object is a pre-built global singleton object, as taught by Konkus; because applying the JSON modification to the singleton beans allows for a lightweight modification of REST resources as compared to alternative formats thereby conserving system resources as evidenced by Konkus [Col 9, Line 63 – Col 10, Line 6]
Prior Art Made of Record
The prior art made of record and not relied upon is considered pertinent to
applicant's disclosure:
US 11449470 B2 – Discloses a method for making modifications to JSON documents. Relevant to claim 1.
US 11023674 B2 - Discloses a method for merging Json documents. Relevant to claim 1.
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to LAWRENCE O'CONNOR EMANUEL whose telephone number is (571)272-8975. The examiner can normally be reached M-F 9:00 - 5:00 pm .
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Chat Do can be reached at (571) 272-3721. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/L.S.O./Examiner, Art Unit 2193
/Chat C Do/Supervisory Patent Examiner, Art Unit 2193
Prosecution Insights