acadrust 0.6.7

A pure Rust library for reading and writing CAD files in DXF format (ASCII and Binary) and DWG format (Binary).
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Common-header encoding for newly constructed Arch records.

use super::DwgObjectWriter;
use crate::classes::arch::ArchObject;
use crate::entities::EntityCommon;
use crate::io::dwg::dwg_stream_readers::object_reader::{
    entities::read_proxy_payload, DwgObjectReader,
};
use crate::io::dwg::dwg_stream_writers::DwgMergedWriter;
use crate::objects::{ProxyObjectReference, ProxyPayload};
use crate::types::{DxfVersion, Handle};

struct ArchitectureObjectBody {
    type_code: i16,
    has_ds_data: bool,
    eed: Vec<(u64, Vec<u8>)>,
    payload: ProxyPayload,
    text: ProxyPayload,
    references: Vec<ProxyObjectReference>,
}

impl DwgObjectWriter<'_> {
    fn architecture_object_body(
        object: &ArchObject,
        version: DxfVersion,
    ) -> crate::error::Result<ArchitectureObjectBody> {
        let raw = object.raw_dwg_data.as_deref().ok_or_else(|| {
            crate::error::DxfError::NotImplemented(format!(
                "Arch object {} has no DWG class body",
                object.dxf_name
            ))
        })?;
        let objects = DwgObjectReader::new(Vec::new(), version, Default::default())?;
        let (type_code, mut reader) = objects.read_raw_record(raw, object.raw_dwg_handle_bits)?;
        let common = objects.read_common_non_entity_data(&mut reader, type_code);
        reader.check_error()?;
        let (payload, text, references) = read_proxy_payload(&mut reader, common.common.handle);
        reader.check_error()?;
        Ok(ArchitectureObjectBody {
            type_code,
            has_ds_data: common.has_ds_data,
            eed: common.common.eed_raw,
            payload,
            text,
            references,
        })
    }

    pub(crate) fn validate_architecture_object(
        object: &ArchObject,
        version: DxfVersion,
    ) -> crate::error::Result<()> {
        Self::architecture_object_body(object, version).map(|_| ())
    }

    pub(super) fn write_architecture_object(&mut self, object: &ArchObject) {
        let body = Self::architecture_object_body(object, self.dxf_version)
            .expect("Arch object record was validated before writing");
        let type_code = self.class_type_code(&object.dxf_name, body.type_code);
        let source_eed = if self.document.eed_by_handle.contains_key(&object.handle) {
            Vec::new()
        } else {
            body.eed
        };
        self.write_complete_non_entity_data(
            type_code,
            object.handle,
            object.owner,
            &object.reactors,
            &object.xdictionary_handle,
            source_eed,
            body.has_ds_data,
        );
        self.write_registered_payload(&body.payload, &body.references);
        let text = body.text.data();
        for bit in 0..body.text.bit_count as usize {
            self.writer
                .write_text_bit(text[bit / 8] & (0x80 >> (bit % 8)) != 0);
        }
        self.register_object(object.handle);
    }

    pub(crate) fn encode_architecture_entity(
        &mut self,
        type_code: i16,
        common: &EntityCommon,
        body: impl FnOnce(&mut DwgMergedWriter),
    ) -> (Vec<u8>, i64) {
        self.write_common_entity_data(
            type_code,
            common.handle,
            common.owner_handle,
            &common.layer,
            &common.color,
            &common.line_weight,
            &common.transparency,
            common.invisible,
            common.linetype_scale,
            &common.linetype,
            &common.linetype_handle,
            &common.extended_data,
            &common.reactors,
            &common.xdictionary_handle,
            common.graphic_data.as_deref(),
            common.entity_mode,
            common.material_flags,
            &common.material_handle,
            common.shadow_flags,
            common.plotstyle_flags,
            &common.plotstyle_handle,
            &common.color_book_handle,
            &common.full_visual_style_handle,
            &common.face_visual_style_handle,
            &common.edge_visual_style_handle,
        );
        body(&mut self.writer);
        self.finish_architecture_record()
    }

    pub(crate) fn encode_architecture_object(
        &mut self,
        type_code: i16,
        handle: Handle,
        owner: Handle,
        body: impl FnOnce(&mut DwgMergedWriter),
    ) -> (Vec<u8>, i64) {
        self.write_common_non_entity_data(type_code, handle, owner, &[owner], &None);
        body(&mut self.writer);
        self.finish_architecture_record()
    }

    fn finish_architecture_record(&mut self) -> (Vec<u8>, i64) {
        let raw = self.writer.merge();
        let handle_bits = raw.len() as i64 * 8 - self.writer.handle_start_bits();
        self.writer.reset();
        self.pending_type_code = None;
        (raw, handle_bits)
    }
}