Code mapping function point-based automatic accounting and completion settlement method and system, and medium

Abstract

The invention provides an automatic accounting and completion settlement method and system based on a code mapping function point and a medium, the automatic accounting and completion settlement method based on the code mapping function point comprises six steps from A) to F), and the system comprises a code collector, an analysis engine, a class role classifier, an element meter, an evidence chain and audit body and a report generator. The method is a function point automatic accounting and completion settlement technology oriented to a software project completion stage and based on source code role mapping. The core application scenarios of the method comprise function point list generation after software project completion, budget and completion difference reconciliation, reuse / secondary development cost conversion and multi-environment deployment pricing, the method can adapt to software systems developed by multiple programming languages such as Java, C # / . NET, Go, TS / Node, Python and the like, and objective and traceable technical support is provided for software cost auditing.

Description

Technical Field

[0001] This invention relates to the field of software engineering measurement and information system cost auditing, specifically to a method, system, and medium for automatic calculation and final settlement of function points based on source code class role mapping. Background Technology

[0002] Tender settlement refers to the economic document by which the successful bidder settles the project price with the bidding party based on the contract and the completed software engineering work. Software engineering development has a long cycle and consumes a large amount of funds. To ensure timely compensation for the funds incurred by the successful bidder in software development, an economic document settling the project price with the bidding party is necessary. There are various settlement methods, including interim settlements (progress payments), year-end settlements, and final settlements after the completion and acceptance of the entire project. Tender settlement is a very important part of the tendering and bidding process.

[0003] The software industry differs from traditional engineering construction. Software requires hundreds of thousands or even tens of millions of lines of code to function, and current software development projects often reference a large amount of open-source code. Therefore, in recent years, some final settlement audit software has emerged in the market, and the state has formulated the standard GB / T42449-2023 for software bidding and settlement.

[0004] After analysis, the applicant identified the following key technical pain points: 1. High reliance on manual labor and strong subjectivity: The current functional point accounting relies heavily on auditors manually compiling functional lists, requiring manual judgment of functional point types (such as ILF / EIF / EI, etc.) and measurement indicators (DET / RET). This is prone to omissions, double counting, or misjudgments due to differences in personal experience, and it is difficult to verify the consistency between the budget and the completed functional points.

[0005] 2. Lack of audit evidence chain: Traditional accounting methods lack full-chain traceability evidence of "code-data-interface-operation", and cannot directly link completed functional points with technical assets such as source code, database structure, and interface contracts, resulting in frequent settlement disputes and high review costs.

[0006] 3. Insufficient adaptability of static analysis tools: Existing code analysis tools mostly focus on technical indicators such as code volume (cyclomatic complexity, etc.) and have not established "code roles" and function point metrics, so they cannot directly output function point data that meets the requirements of settlement audit.

[0007] 4. Difficulty in implementing multi-scenario pricing rules: Software projects commonly involve multi-environment deployments (such as development, testing, and production), function reuse, or secondary development. Existing methods lack standardized conversion rules, which can easily lead to double-counting or opaque conversion logic.

[0008] Therefore, existing technologies are insufficient to meet the requirements of software final settlement audit for "automation, objectivity, traceability, and scenario adaptability," and there is an urgent need for an automatic calculation and settlement scheme for functional points based on source code.

[0009] The applicant has applied for a method for software bidding and settlement review, including a functional review module, a function point code decomposition module, a compliance module, a security module, an economic review module, and an open-source code management module. The application number is CN114240337B, and the publication date is March 25, 2022. This application aims to implement an automatic calculation and settlement scheme for function points based on source code, building upon the technology in CN114240337B. Summary of the Invention

[0010] To address the shortcomings of existing technologies, this invention provides a method, system, and medium for automatic calculation and final settlement of function points based on code mapping, solving the problems of "strong reliance on manual labor, lack of evidence chain, and poor scenario adaptability" in the function point calculation of existing software final settlement audits.

[0011] Specifically, it is a technology for automatic calculation and final settlement of function points based on source code role mapping, targeting the completion phase of software projects. Its core application scenarios include generating a list of function points after software project completion, reconciling budget and final cost differences, calculating reuse / secondary development costs, and pricing for multi-environment deployments. It is compatible with software systems developed in multiple programming languages ​​such as Java, C# / .NET, Go, TS / Node, and Python, providing objective and traceable technical support for software cost auditing.

[0012] To achieve the above objectives, this invention provides the following technical solution: an automatic function point calculation method based on class role mapping, comprising: A) obtaining the completed source code, database structure, and interface contract; B) parsing the source code to obtain classes, annotations, methods, dependencies, and data access relationships; C) classifying classes into entity classes, interface classes, operation classes, output classes, and query classes according to preset rules; D) mapping entity classes to ILF, interface classes to EIF, operation classes to EI, output classes to EO, and query classes to EQ; E) calculating the number of data elements (DET) and record type (RET) of ILF / EIF, calculating the number of input / output data elements (DET) of EI / EO / EQ, and determining the complexity and score according to function point measurement rules; F) summarizing unadjusted function points (UFP) and generating a completed function point list.

[0013] Furthermore, the class division in step C is based on a single or multiple factors, including packages / directories, annotations / decorators, method verbs, data flow, and transaction commits.

[0014] Furthermore, the DET of an entity class is counted by persistent fields, and the RET is determined by master-slave or strongly related clustering.

[0015] Furthermore, the interface class is determined through external contract binding or client proxy identification, and does not maintain data ownership.

[0016] Furthermore, the operation class uses write path, transaction commit, or event publication as the determination criteria.

[0017] Furthermore, the output class uses aggregate calculations and file / message writing as the criteria for judgment.

[0018] Furthermore, the query class uses a read-only path with no side effects as the criterion.

[0019] Furthermore, it also includes establishing a chain of evidence in the list: class / method—table / view—interface contract—build / log—commit hash.

[0020] Furthermore, it also includes calculating the File Type Reference Count (FTR) when system parameters are enabled, and updating the complexity determination and score accordingly.

[0021] A system comprising: a code collector, a parsing engine, a role classifier, an element meter, a chain of evidence and an audit ontology, and a report generator.

[0022] A code scraper is an automated tool primarily used to efficiently and accurately extract structured or unstructured data from the internet or local systems, such as data from software sharing platforms like Git and Gitee.

[0023] A parsing engine is a software system used to analyze, process, and understand input data or information. Its core function is to transform complex data into structured information, and to identify classes, annotations, methods, and data dependencies through multilingual AST parsing and metadata extraction.

[0024] The class role classifier is used to classify the classes identified by the parsing engine. The classification method is based on package path, annotation features, method semantics, and data flow features, and completes the mapping, dividing the code classes into: - Entity classes (mapped to ILF): Model classes containing ORM annotations, persistent fields, and primary keys - Interface classes (mapped to EIF): External service client / proxy classes that only consume external data - Operation classes (mapped to EI): Controller / command classes that trigger write operations, transaction commits, or event publications - Output classes (mapped to EO): Report / export classes that perform aggregation calculations and generate files / messages - Query classes (mapped to EQ): Read-only query classes with no side effects.

[0025] The element meter is used to calculate the DET / RET value of each element and determine the complexity and function point score according to the IFPUG rules.

[0026] The evidence chain and audit ontology are used to establish the association relationship and hash verification mechanism of "class-table-interface-construct". The audit ontology includes the settlement engine, which is used to perform budget difference reconciliation, reuse / secondary conversion and multi-environment pricing, and generate settlement calculation sheets. The report generator is used to output function point list, reconciliation table and audit report.

[0027] A computer-readable storage medium for storing instructions that, when executed by a processor, implement method steps for an automatic function point calculation method based on class role mapping.

[0028] This invention provides a method, system, and medium for automatic calculation and final settlement of function points based on code mapping. It has the following beneficial effects: 1. Improved objectivity: Based solely on source code, subjective biases in manual statistics are eliminated, and the accuracy of DET / RET calculation reaches over 95%; 2. Audit traceability: Construct a full-chain evidence system that supports reverse tracing from functional points back to lines of code and build artifacts; 3. Scene adaptability: Supports reuse reduction (coefficient 0-1), secondary development enhancement (coefficient ≥1), and multi-environment non-repeated pricing; 4. Cross-language compatibility: Supports mainstream development languages ​​such as Java / C# / Go / TS / Python, and is compatible with projects using multiple technology stacks; 5. Efficiency Optimization: 80% more efficient than traditional manual accounting, significantly reducing audit cycle and labor costs. Attached Figure Description Figure 1 This is a diagram of the overall system architecture of the present invention; Figure 2 This is a flowchart of the class role recognition process of the present invention; Figure 3 This is the process for calculating and determining the complexity of DET / RET in this invention; Figure 4 This is a schematic diagram of the evidence chain relationship in this invention; Figure 5 This is the IFPUG standard table 2020 of the present invention. Detailed Implementation

[0030] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0031] Example: like Figure 1-5 As shown, this embodiment of the invention provides a method, system, and medium for automatic calculation and final settlement based on code mapping function points, specifically: An automatic function point calculation method based on class role mapping includes: A) Obtaining the completed source code, database structure, and interface contract; B) Parsing the source code to obtain classes, annotations, methods, dependencies, and data access relationships; C) Dividing classes into entity classes, interface classes, operation classes, output classes, and query classes according to preset rules; D) Mapping entity classes to ILF, interface classes to EIF, operation classes to EI, output classes to EO, and query classes to EQ; E) Calculating the number of data elements (DET) and record types (RET) of ILF / EIF, calculating the number of input / output data elements (DET) of EI / EO / EQ, and determining the complexity and score according to function point measurement rules; F) Summarizing unadjusted function points (UFP) and generating a completed function point list.

[0032] A system comprising: a code collector, a parsing engine, a role classifier, an element meter, a chain of evidence and an audit ontology, and a report generator.

[0033] In this embodiment, the code collector completes step A) of an automatic function point calculation method based on class role mapping, specifically: locking the repository tag of the completed code repository, archiving the database DDL script, interface contract (OpenAPI / Proto) and build artifacts, and submitting the data to the hash algorithm to generate a hash value to ensure that the calculation basis cannot be tampered with.

[0034] The parsing engine completes step B) of a method for automatically calculating function points based on class role mapping by parsing the data obtained in step A). ​​Specifically, it obtains classes, annotations / decorators, methods, dependency graphs, and ORM / SQL data access logic from the source code through multi-language abstract syntax tree (AST) parsing and metadata extraction (supporting multiple languages ​​such as Java, C#, and Go).

[0035] The role classifier completes steps C) and D) of an automatic function point calculation method based on role mapping, classifying and mapping the parsed data obtained in step B). Specifically, it maps the parsed classes to the five elements of FSM according to preset rules, abbreviated as ILF, EIF, EI, EO, and EO, with the following correspondence: ILF (Internal Logic File) = Entity Class: Contains ORM model, ≥1 persistent field, primary key / unique key, and appears in database DDL / migration script; EIF (External Interface File) = Interface Class: Client / Proxy / SDK / Stub of external systems, which only consumes external data and is not maintained by this system. EI (External Input) = Operation Class: Class / method that triggers command / controller write operations (CUD), transaction commits, or event publications; EO (External Output) = Output Class: Classes / methods that implement export, report generation, and notification distribution (including data aggregation or formatting); EQ (External Query) = Query Class: A class / method that performs only read-only queries (without data modification side effects).

[0036] This embodiment uses mainstream languages ​​as an example to detail the specific steps of cross-language classification and mapping: • Java: JPA / MyBatis-Plus model → ILF; @FeignClient → EIF; @Post / Put / DeleteMapping + repo.save() → EI; export*() method → ​​EO; • C# / .NET: EF Core entities → ILF; Refit / gRPC clients → EIF; HttpPost / Put / Delete + DbContext.SaveChanges() → EI; • Go: struct+GORM / SQLC → ILF; grpc.ClientConn → EIF; DB writer handler → EI; • TS / Node: TypeORM / Mongoose model → ILF; axios external calls → EIF; routed writes to the database → EI; • Python: Django / SQLAlchemy models → ILF; external requests → EIF; write views → EI.

[0037] Common features in multilingualism are categorized as follows: Packages / directories: entity / model / domain→ILF; client / adapter / sdk / stub→EIF; controller / command / service (write)→EI; report / export / notify→EO; query / repository / dao (read-only)→EQ.

[0038] Annotations / Decorators: ORM Annotations / Base Class → ILF; @FeignClient / @GrpcClient / Retrofit → EIF; @Transactional(write) or CUD → EI; @GetMapping without write → EQ; Timed export / message delivery → EO.

[0039] Semantic dictionary: create / update / delete → EI; export / report / generate / notify → EO; find / get / search / list → EQ.

[0040] Data flow: Write path (persistence / state change) → EI; Read → formatted write file / distribution → EO; Pure read → EQ.

[0041] Boundaries: Read-only external → EIF; System maintenance → ILF; No new elements added for multiple skins with the same function.

[0042] Using the above rules, the role classifier completes the classification and mapping of the parsed data.

[0043] Generate the function points mentioned in CN114240337B; The element meter completes step E) of an automatic function point calculation method based on role mapping, and determines the complexity and score of the five elements and mapping data obtained from steps C) and D).

[0044] The element meter is an upgrade based on technical document CN114240337B. Please refer to CN114240337B.

[0045] Specifically: Define rules, calculate metrics, and determine complexity: The rules for measurement and complexity are as follows: Set the DET variable to count "business valid fields", and count arrays / objects by expansion; Set the RET variable statistics to "record type clustering", grouping by master / slave / strong association; The FTR variable is set to act as a switch; it is off by default. When turned on, it calls external parameters.

[0046] The specific measurement rules are as follows: In ILF / EIF features, DET = number of fields (excluding constants / temporary / duplicates); RET = record type clustering (master-detail / strongly related grouping, such as "order + order line" counts as 1 RET); In the EI / EO / EQ elements, DET = valid count of input / output parameter fields (required, after validation); After FTR is enabled, the FTR of EI / EO / EQ = the number of ILF / EIF accesses, and the FTR of ILF / EIF = the number of external files referenced.

[0047] Complexity: The complexity (simple / average / complex) and corresponding score of each element are determined according to the IFPUG standard table. The IFPUG (International Function Point User Group) standard is a functional size measurement method standard jointly developed by the International Organization for Standardization (ISO) and the International Electrotechnical Commission (IEC), mainly used for size measurement of software and systems engineering.

[0048] Here is a brief explanation of its core elements: complexity assessment. The complexity of a transaction function is determined by the data element type (DET) and the referenced file type (FTR).

[0049] The complexity of the data functionality is determined by the DET (Data Entry Type) and the Record Element Type (RET). The evidence chain and audit ontology describe the process of obtaining data to form an evidence chain and auditing it from steps A) to E) of an automatic function point calculation method based on role mapping. Specifically: Establish the association between "class / method → ​​database table / view → interface contract → build artifact / run log → code commit hash", and bind traceable technical evidence to each function.

[0050] refer to Figure 4 It should be noted that, Figure 4 The hash value in the table is for reference only, not the actual value.

[0051] The audit module is a built-in audit module of this system, including the settlement engine, which is used to perform budget difference reconciliation, reuse / reopen conversion and multi-environment pricing, and generate settlement calculation reports.

[0052] The conversion rules are as follows: The specific audit involved IFPUG using 14 basic characteristic impact values ​​(TDI) to adjust the function point count.

[0053] Implementation Standards: National Standard: GB / T42449-2023 is equivalent to ISO / IEC 20926:2009 and officially came into effect on October 1, 2023. This technical specification stipulates that in multi-environment / multi-tenant environments: function points are not counted repeatedly; workload is only counted for deployment, parameterization, and data initialization; specifically: Define a variable 'r' to record the degree of reuse. Define a variable q and record the coefficients of the second open source, where q ≥ 1. Multiplexing / Dual-opening conversion: OSS / OEM pure access is regarded as EIF; if dual-opening is carried out, it is included according to the EI / EO / EQ / ILF mapped by the transformation layer, and converted with r (multiplexing reduction of 0-1) and q (dual-opening coefficient ≥1).

[0054] • Basic transformation: Converts unadjusted function points (UFP) to adjusted function points (AFP, with optional introduction of CAF complexity adjustment factor); • Scenario discounting: Application reuse reduction factor r (0-1, the higher the degree of reuse, the smaller r is), secondary development factor q (≥1, the larger the amount of modification, the larger q is); multi-environment deployment only counts the workload of instantiation, parameterization and data initialization, and does not count function points repeatedly.

[0055] The anonymized evidence chain can be shared with external auditing software as required. The report generator completes step F) of an automatic function point calculation method based on class role mapping, and performs statistical analysis on the data obtained from the previous steps.

[0056] Specifically, this includes: outputting a list of completed functional points, a budget reconciliation statement, a settlement calculation sheet, and complete evidence files (supporting audit traceability).

[0057] Detailed explanation of the implementation process of this invention: S1: Version Fixing: Lock the completed tag (such as release_v1.0) in the Git repository, hash it as a1b2c3d, and archive order.sql (DDL), order-service-openapi.yaml (interface contract) and Jar build artifacts.

[0058] S2: Parsing and Extraction: Parse the source code using Eclipse JDT to extract classes such as Order.java, FreightApi.java, OrderController.java, and ReportService.java, as well as annotations such as @Entity, @FeignClient, and @PostMapping.

[0059] S3: Role Recognition • ILF: @Entity class Order{@Id private Long id; private String orderNo;private BigDecimal amount; ...} (Contains ORM annotations, persistent fields, and primary keys, appearing in order.sql); OrderItem.java (Strongly associated with Order, belonging to the same RET); • EIF: @FeignClient(name = "freight-service") interface FreightApi{...} (External logistics service client, only consumption data); • EI: @RestController public class OrderController{@PostMapping(" / orders") public ResponseEntity <ordervo>createOrder(@RequestBody @ValidOrderDTO orderDTO){orderRepo.save(order); ...}} (triggers write operations, including transaction commit); • EO: @Service public class ReportService{public voidexportMonthlyOrderCSV(Date month){List <order>orders = orderRepo.findByMonth(month); / / Aggregate data and write it to a CSV file...}} (Aggregate output to a file); • EQ: @GetMapping(" / orders") public ResponseEntity <List <ordervo>>listOrders(@RequestParam String userId){return ResponseEntity.ok(orderRepo.findByUserId(userId));} (Read-only query, no write operation).

[0060] S4: Chain of Evidence Construction: • Order.java → order table (CREATE TABLE order(...) in DDL) → / orders interface in order-service-openapi.yaml → Jar artifact (hash e4f5g6h) → Git commit hash a1b2c3d.

[0061] S5: Measurement Judgment • ILF (Order + OrderItem): DET = 8 valid fields of Order (excluding the temporary field tempFlag) + 5 valid fields of OrderItem = 13; RET = 1 (strong association clustering); complexity = average (according to the IFPUG table, DET = 13, RET = 1 → average complexity, score = 7). • EIF (FreightApi): DET=6 (Valid fields for output parameters of the logistics interface); RET=1; Complexity = Simple, Score = 5; • EI (createOrder): DET=7 (OrderDTO is a required field after validation); Complexity = Average, Score = 4; • EO (exportMonthlyOrderCSV): DET=10 (Valid fields in CSV output); Complexity = Complex, Score = 6; • EQ (listOrders): DET=3 (input parameter userId + output parameter OrderVO core field); complexity = simple, score = 3.

[0062] S6: Reconciliation and Classification: The ILF score of the Order module in the budget is 6, and the score of the completed project is 7 → Difference type "Change" (due to the addition of the amount field).

[0063] S7: Price Conversion: UFP = 7 (ILF) + 5 (EIF) + 4 (EI) + 6 (EO) + 3 (EQ) = 25; CAF = 1.0 (no special complexity adjustment) → AFP = 25; Reuse factor r = 0.9 (OrderItem reuses the basic product module entity logic); secondary development factor q = 1.0 (no secondary development); for multiple environments (development / testing / production), only the initialization workload is counted, and the conversion factor k_env = 0.1 → settlement price = 25 × 1.0 × 0.9 × 1.0 + 25 × 0.1 = 25.

[0064] S8: Report Generation: Outputs an Excel-formatted "As-Built Function Point List" (including information such as module "Order", class name "Order", element "ILF", DET=13, RET=1, etc.) and a "Settlement Calculation Sheet".

[0065] A computer-readable storage medium for storing instructions that, when executed by a processor, implement method steps for an automatic function point calculation method based on class role mapping.

[0066] A computer-readable storage medium for storing instructions and a storage system, wherein the system, when executed by a processor, implements method steps and a system thereof for an automatic function point calculation method based on class role mapping.

[0067] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.< / ordervo> < / order> < / ordervo>

Claims

1. A method for automatic calculation and final settlement of function points based on code mapping, characterized in that: The process includes the following steps: A) Obtaining the completed source code, database structure, and interface contracts; B) Parsing the source code to obtain classes, annotations, methods, dependencies, and data access relationships; C) Dividing the classes into entity classes, interface classes, operation classes, output classes, and query classes according to preset rules; D) Mapping entity classes to ILF, interface classes to EIF, operation classes to EI, output classes to EO, and query classes to EQ; E) Calculating the number of data elements (DET) and record types (RET) for ILF / EIF, calculating the number of input / output data elements (DET) for EI / EO / EQ, and determining the complexity and score according to the function point measurement rules; F) Summarizing the unadjusted function points (UFP) and generating a completed function point list.

2. The method for automatic calculation and final settlement based on code mapping function points according to claim 1, characterized in that: The class division in step C) is based on a single or multiple factors, including package / directory, annotation / decorator, method verb, data flow, and transaction commit.

3. The method for automatic calculation and final settlement based on code mapping function points according to claim 2, characterized in that: Interface classes are determined through external contract binding or client proxy identification and do not maintain data master responsibility; output classes use aggregation calculation and file / message writing as the judgment condition, and query classes use a read-only path without side effects as the judgment condition.

4. The method for automatic calculation and final settlement based on code mapping function points according to claim 1, characterized in that: It also includes establishing a chain of evidence in the list of classes / methods—tables / views—interface contracts—builds / logs—commit hashes.

5. The method for automatic calculation and final settlement based on code mapping function points according to claim 1, characterized in that: It also includes calculating the File Type Reference Count (FTR) when system parameters are enabled, and updating the complexity determination and score accordingly.

6. A system, characterized in that: A method for automatic accounting and final settlement based on code mapping function points according to any one of claims 1-5 includes a code collector, a parsing engine, a class role classifier, an element meter, an evidence chain and audit ontology, and a report generator. The code collector is mainly used to efficiently and accurately capture structured or unstructured data from the Internet or local systems. The parsing engine identifies classes, annotations, methods, and data dependencies through multi-language AST parsing and metadata extraction. The class role classifier is used to classify the classes identified by the parsing engine. The element meter is used to calculate the DET / RET value of each element and determine the complexity and function point score according to IFPUG rules. The evidence chain and audit ontology are used to establish the association relationship and hash verification mechanism of "class-table-interface-construct". The audit ontology includes a settlement engine used to perform budget difference reconciliation, reuse / redevelopment conversion, and multi-environment pricing to generate a settlement calculation report. The report generator is used to output a function point list, reconciliation table, and audit report.

7. The system according to claim 6, characterized in that: The code collector completes step A) of an automatic function point calculation method based on class role mapping, specifically: locking the repository tag of the completed code repository, archiving the database DDL script, interface contract (OpenAPI / Proto) and build artifacts, and submitting the data to the hash algorithm to generate a hash value to ensure that the calculation basis cannot be tampered with; the parsing engine completes step B) of an automatic function point calculation method based on class role mapping, by parsing the data obtained in step A), specifically: obtaining classes, annotations / decorators, methods, dependency graphs and ORM / SQL data access logic in the source code through multi-language abstract syntax tree (AST) parsing and metadata extraction (supporting multiple languages ​​such as Java, C# and Go).

8. A system according to claim 6, characterized in that: The classifier classifies the class of roles and completes steps C) and D) of an automatic function point calculation method based on class of roles and roles. It classifies and maps the parsed data obtained in step B) by classifying and mapping the parsed data. Specifically, it maps the parsed classes to the five elements of FSM according to preset rules, which are abbreviated as ILF, EIF, EI, EO and EO.

9. A system according to claim 6, characterized in that: The element meter completes step E) of an automatic function point calculation method based on class role mapping, determining the complexity and score of the five elements and mapping data obtained from steps C) and D). The evidence chain and audit ontology are used to establish the association relationship and hash verification mechanism of "class-table-interface-construct". The audit ontology includes a settlement engine used to perform budget difference reconciliation, reuse / secondary conversion and multi-environment pricing, and generate settlement calculation sheets; it outputs a list of completed function points, a budget reconciliation table, a settlement calculation sheet and a complete evidence archive (supporting audit traceability).

10. A computer-readable storage medium, characterized in that: The method and system for automatic calculation and final settlement of function points based on code mapping according to any one of claims 1-9 are used to store instructions and a storage system. When the system is executed by a processor, it implements the method steps and system of an automatic calculation method for function points based on class role mapping.

Images