Flutter数据解析插件leodt_parser的使用

Flutter数据解析插件leodt_parser的使用

简介

LeoDT Parser 是一个用于解析和解释 LeoDT 格式决策树结构的 Dart 包。它为需要决策能力的应用程序提供了强大的解决方案，特别适用于医疗诊断、故障排除系统或任何一系列决策导致最终结果的场景。

主要功能

  • 将 LeoDT（Leo 决策树）格式的数据解析为可用的决策树结构。
  • 支持在决策树中进行前进和后退导航。
  • 管理已访问节点的历史记录以跟踪决策路径。
  • 提供检索节点信息和树统计信息的工具。

LeoDT 文档

LeoDT 文档是一种决策树的结构化表示，旨在引导用户通过一系列决策和结果。每个节点代表一个决策点，选项基于用户的决定导向不同的路径。

示例 LeoDT 文档

[
  {
    "id": "1",
    "isRoot": true,
    "decision": "Does the patient have respiratory symptoms?",
    "options": [
      {
        "id": "1.1",
        "when": "Yes",
        "then": "2"
      },
      {
        "id": "1.2",
        "when": "No",
        "then": "3"
      }
    ]
  },
  {
    "id": "2",
    "isLeaf": true,
    "result": "J00-J99 (Respiratory Diseases)"
  },
  {
    "id": "3",
    "decision": "Does the patient have symptoms related to the digestive system?",
    "options": [
      {
        "id": "3.1",
        "when": "Yes",
        "then": "4"
      },
      {
        "id": "3.2",
        "when": "No",
        "then": "5"
      }
    ]
  },
  {
    "id": "4",
    "isLeaf": true,
    "result": "K00-K95 (Digestive Diseases)"
  },
  {
    "id": "5",
    "decision": "Does the patient have symptoms related to the nervous system?",
    "options": [
      {
        "id": "5.1",
        "when": "Yes",
        "then": "6"
      },
      {
        "id": "5.2",
        "when": "No",
        "then": "7"
      }
    ]
  },
  {
    "id": "6",
    "isLeaf": true,
    "result": "G00-G99 (Nervous System Diseases)"
  },
  {
    "id": "7",
    "isLeaf": true,
    "result": "Further Assessment Needed"
  }
]

开始使用

首先，在您的 Dart 或 Flutter 项目中添加 leodt_parser 作为依赖项：

dependencies:
  leodt_parser: ^current_version

使用示例

以下是一个完整的 Flutter 示例 demo，展示如何使用 leodt_parser 解析并展示决策树：

import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:leodt_parser/leodt_parser.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'LeoDT parser demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: const ICD10Classification(),
    );
  }
}

class ICD10Classification extends StatefulWidget {
  const ICD10Classification({super.key});

  [@override](/user/override)
  State<ICD10Classification> createState() => _ICD10ClassificationState();
}

class _ICD10ClassificationState extends State<ICD10Classification> {
  DecisionTreeImpl? decisionTreeImpl;
  Node? currentNode;

  [@override](/user/override)
  void initState() {
    super.initState();

    final decisionTreeRead = jsonDecode(icd10DecisionTreeJson);
    decisionTreeImpl = DecisionTreeImpl()
      ..initialize(decisionTree: List<Map<String, dynamic>>.from(decisionTreeRead));

    currentNode = decisionTreeImpl?.getRootNode();
    decisionTreeImpl?.addNodeToHistory(node: currentNode ?? RootNode(id: '', decision: '', options: {}));
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return SafeArea(
      child: Scaffold(
        appBar: AppBar(title: const Text('LeoDT Parser Demo')),
        body: Center(
          child: Padding(
            padding: const EdgeInsets.symmetric(horizontal: 32.0),
            child: ConstrainedBox(
              constraints: const BoxConstraints(maxWidth: 1920 / 2),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.center,
                children: [
                  Expanded(
                    child: SingleChildScrollView(
                      child: Column(
                        crossAxisAlignment: CrossAxisAlignment.center,
                        children: _buildNodeWidgets(currentNode, context),
                      ),
                    ),
                  ),
                ],
              ),
            ),
          ),
        ),
      ),
    );
  }

  List<Widget> _buildNodeWidgets(Node? node, BuildContext context) {
    if (node == null) return [];

    return [
      if (node is LeafNode) _buildLeafNode(node, context),
      if (node is DecisionNode) ..._buildDecisionNode(node, context),
      if (node is RootNode || node is InternalNode) ..._buildOptionsNode(node as DecisionNode, context),
      if (node is! RootNode) ..._buildNavigationButtons(node),
    ];
  }

  Widget _buildLeafNode(LeafNode node, BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(12.0),
      child: Text(node.result, style: Theme.of(context).textTheme.titleLarge),
    );
  }

  List<Widget> _buildDecisionNode(DecisionNode node, BuildContext context) {
    return [
      Padding(
        padding: const EdgeInsets.symmetric(vertical: 6.0),
        child: Text(node.decision, style: Theme.of(context).textTheme.titleLarge),
      ),
    ];
  }

  List<Widget> _buildOptionsNode(DecisionNode node, BuildContext context) {
    List<Widget> widgets = [];
    if (node is InternalNode) {
      widgets.addAll(_buildInternalNodeDetails(node, context));
    }
    widgets.addAll(node.options.values.map((option) => Padding(
          padding: const EdgeInsets.symmetric(vertical: 12.0),
          child: ListTileButton(
            title: Text(option.when),
            onTap: () => setState(() => currentNode = decisionTreeImpl?.goForward(id: option.then)),
          ),
        )));
    return widgets;
  }

  List<Widget> _buildInternalNodeDetails(InternalNode node, BuildContext context) {
    List<Widget> widgets = [];

    if (node.information != null) {
      widgets.add(_buildInfoTile(node.information!, 'Information', Icons.info_outline, Colors.lightBlueAccent));
    }

    if (node.hint != null) {
      widgets.add(_buildInfoTile(node.hint!, 'Hint', Icons.warning_outlined, Colors.amber));
    }

    return widgets;
  }

  Widget _buildInfoTile(String text, String title, IconData icon, Color iconColor) {
    return Padding(
      padding: const EdgeInsets.only(bottom: 12.0),
      child: ExpansionTile(
        title: Row(
          mainAxisAlignment: MainAxisAlignment.start,
          children: [
            Icon(icon, color: iconColor),
            const SizedBox(width: 12.0),
            Text(title),
          ],
        ),
        children: [
          Row(
            mainAxisAlignment: MainAxisAlignment.start,
            children: [
              Expanded(child: Text(text)),
            ],
          )
        ],
      ),
    );
  }

  List<Widget> _buildNavigationButtons(Node node) {
    return [
      Column(
        crossAxisAlignment: CrossAxisAlignment.stretch,
        children: [
          const SizedBox(height: 32.0),
          ElevatedButton(onPressed: () => setState(() => currentNode = decisionTreeImpl?.goBack()), child: const Text('Back')),
          const SizedBox(height: 12.0),
          ElevatedButton(onPressed: () => setState(() => currentNode = decisionTreeImpl?.restart()), child: const Text('Restart')),
          const SizedBox(height: 12.0),
        ],
      ),
    ];
  }
}

class ListTileButton extends StatelessWidget {
  const ListTileButton({
    Key? key,
    required this.title,
    required this.onTap,
    this.subtitle,
    this.leading,
  }) : super(key: key);

  final Widget title;
  final Widget? subtitle;
  final Widget? leading;
  final void Function() onTap;

  [@override](/user/override)
  Widget build(BuildContext context) {
    return ConstrainedBox(
      constraints: const BoxConstraints(maxWidth: 350.0, minHeight: 150.0),
      child: ListTile(
        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(10.0), side: const BorderSide(width: 2.0)),
        leading: leading,
        title: Padding(padding: const EdgeInsets.only(bottom: 12.0), child: title),
        subtitle: subtitle,
        onTap: onTap,
      ),
    );
  }
}

const String icd10DecisionTreeJson = '''
[
  {
    "id": "1",
    "isRoot": true,
    "decision": "Does the patient have respiratory symptoms?",
    "options": [
      {
        "id": "1.1",
        "when": "Yes",
        "then": "2"
      },
      {
        "id": "1.2",
        "when": "No",
        "then": "3"
      }
    ]
  },
  {
    "id": "2",
    "isLeaf": true,
    "result": "J00-J99 (Respiratory Diseases)"
  },
  {
    "id": "3",
    "decision": "Does the patient have symptoms related to the digestive system?",
    "information": "Abdominal pain or discomfort, Nausea and vomiting and more are possible symptoms.",
    "options": [
      {
        "id": "3.1",
        "when": "Yes",
        "then": "4"
      },
      {
        "id": "3.2",
        "when": "No",
        "then": "5"
      }
    ]
  },
  {
    "id": "4",
    "isLeaf": true,
    "result": "K00-K95 (Digestive Diseases)"
  },
  {
    "id": "5",
    "decision": "Does the patient have symptoms related to the nervous system?",
    "hint": "Care about: Patient History, Medical History and more if necessary.",
    "options": [
      {
        "id": "5.1",
        "when": "Yes",
        "then": "6"
      },
      {
        "id": "5.2",
        "when": "No",
        "then": "7"
      }
    ]
  },
  {
    "id": "6",
    "isLeaf": true,
    "result": "G00-G99 (Nervous System Diseases)"
  },
  {
    "id": "7",
    "isLeaf": true,
    "result": "Further Assessment Needed"
  }
]
''';

更多关于Flutter数据解析插件leodt_parser的使用的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter数据解析插件leodt_parser的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


当然，以下是如何在Flutter项目中使用leodt_parser插件进行数据解析的示例代码。leodt_parser是一个假设的插件名，用于数据解析（请注意，实际中你可能需要查找并确认具体插件的正确名称和用法，因为leodt_parser可能并不是真实存在的插件名）。

1. 添加依赖

首先，在你的pubspec.yaml文件中添加leodt_parser依赖：

dependencies:
  flutter:
    sdk: flutter
  leodt_parser: ^1.0.0  # 假设版本号为1.0.0，请根据实际情况调整

然后运行flutter pub get来安装依赖。

2. 导入插件

在你的Dart文件中导入leodt_parser插件：

import 'package:leodt_parser/leodt_parser.dart';

3. 使用插件进行数据解析

假设你有一个JSON字符串需要解析，以下是如何使用leodt_parser插件进行解析的示例：

import 'package:flutter/material.dart';
import 'package:leodt_parser/leodt_parser.dart';  // 导入插件

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('leodt_parser Example'),
        ),
        body: Center(
          child: DataParserExample(),
        ),
      ),
    );
  }
}

class DataParserExample extends StatefulWidget {
  @override
  _DataParserExampleState createState() => _DataParserExampleState();
}

class _DataParserExampleState extends State<DataParserExample> {
  String jsonData = '''
  {
    "name": "John Doe",
    "age": 30,
    "email": "john.doe@example.com"
  }
  ''';

  Map<String, dynamic> parsedData = {};

  @override
  void initState() {
    super.initState();
    // 使用插件解析JSON数据
    parsedData = LeodtParser.parseJson(jsonData);
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: <Widget>[
        Text('Name: ${parsedData['name']}'),
        Text('Age: ${parsedData['age']}'),
        Text('Email: ${parsedData['email']}'),
      ],
    );
  }
}

注意事项

  1. 插件实际名称：请确保你使用的插件名称是正确的。如果leodt_parser不是一个真实存在的插件，你需要替换为实际的插件名称。
  2. 插件功能：不同的数据解析插件可能有不同的API和功能。请查阅你使用的插件的官方文档，以了解如何正确使用该插件。
  3. 错误处理：在实际应用中，你可能需要添加错误处理逻辑，以确保在解析失败时能够优雅地处理错误。

示例总结

上述代码展示了如何在Flutter项目中使用一个假设的数据解析插件leodt_parser来解析JSON数据，并将其显示在屏幕上。在实际项目中，你需要根据具体的插件文档来调整代码。

回到顶部