rs95 0.2.0

A Rust library implementing the ISA-95 domain models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# rs95

A Rust library implementing the **ISA-95** (Enterprise-Control System Integration) domain models for manufacturing
operations management.

This library provides a type-safe, flexible implementation of the ISA-95 object models for Personnel, Equipment,
Physical Assets, Materials, the Equipment Hierarchy, Operational Locations, Process Segments, and Operations
(definitions, scheduling, performance, and capability). Most references are implemented using identifiers to allow
flexibility in calling applications.

## Features and Details

The implementation is split across modules available in `rs95::core`. All models are parameterised by an `ID` type,
allowing you to use `Uuid`, `String`, `u64`, or any custom type as identifiers; if you've got external identifiers from
other systems, like resource URIs, you can bring these in. You can use the declarative macros in `rs95::macros` to
generate concrete, non-generic versions of the models for your specific identifier type.

Optional `Serialize` and `Deserialize` support is available via the `serde` feature flag. This will derive `Serialize`
and `Deserialize` implementations for all models — useful for interacting with outside systems. You'll need to make sure
you do this for your own identifiers as well.

## Usage

### Using Default Models (UUID)

By default, the library provides a set of pre-generated models using `uuid::Uuid` in the `default_models` module.

```rust
use rs95::default_models::personnel::Person;
use uuid::Uuid;

let person = Person {
    id: Uuid::new_v4(),
    name: "John Doe".to_string(),
    personnel_classes: vec![],
    properties: vec![],
};
```

### Using Generic Models

If you want to use a custom ID type (e.g. a URL string), use the `core` module directly:

```rust
use rs95::core::equipment::Equipment;

let cnc_machine = Equipment::<String> {
    id: "http://factory.com/assets/cnc-01".to_string(),
    name: "CNC 01".to_string(),
    equipment_classes: vec!["http://factory.com/classes/milling".to_string()],
    properties: vec![],
    sub_equipment: vec![],
};
```

### Generating Custom Modules

You can use the provided macros to generate a specialised module for your ID type, removing the need for generic
parameters in your application code:

```rust
pub mod my_models {
    rs95::declare_physical_asset_models!(String);
}

use my_models::PhysicalAsset;

let asset = PhysicalAsset {
    id: "ID-123".to_string(),
    name: "My Asset".to_string(),
    physical_asset_class_id: "CLASS-A".to_string(),
    properties: vec![],
    sub_assets: vec![],
};
```

## Feature Flags

- `serde`: Enables `Serialize` and `Deserialize` derivations for all models. It also enables the `serde` feature for the
  `uuid` dependency.

```toml
[dependencies]
rs95 = { version = "0.2.0", features = ["serde"] }
```