Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 820296f

Browse files
backkembackkem
authored
Move encode/decode type key functions to openscreen-common (#16)
* Move encode/decode type key functions to openscreen-common Closes #15
1 parent c70fb2a commit 820296f

4 files changed

Lines changed: 59 additions & 70 deletions

File tree

‎openscreen-application/src/messages.rs‎

Lines changed: 3 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -21,11 +21,11 @@
2121
//!
2222
//! Reference: ref/w3c_ref/messages_appendix.cddl
2323
24-
use bytes::Buf;
2524
use heapless::Vec;
2625
use minicbor::{Decoder, Encoder};
27-
use openscreen_common::quinn_varint::{Codec, VarInt};
28-
use openscreen_common::{MessageError, MAX_STRING_LENGTH, MAX_URLS};
26+
use openscreen_common::{
27+
decode_type_key, encode_type_key, MessageError, MAX_STRING_LENGTH, MAX_URLS,
28+
};
2929

3030
/// A wrapper around heapless::Vec that implements minicbor's Write trait
3131
struct VecWriter<'a, const N: usize> {
@@ -48,38 +48,6 @@ impl<'a, const N: usize> minicbor::encode::Write for VecWriter<'a, N> {
4848
}
4949
}
5050

51-
/// Encode a type key as RFC 9000 variable-length integer into a heapless::Vec
52-
fn encode_type_key<const N: usize>(
53-
type_key: u16,
54-
buf: &mut Vec<u8, N>,
55-
) -> Result<(), MessageError> {
56-
let varint = VarInt::from(type_key);
57-
let size = varint.size();
58-
59-
// Ensure we have space
60-
if buf.len() + size > N {
61-
return Err(MessageError::BufferFull);
62-
}
63-
64-
// Encode varint to a small stack buffer, then copy
65-
let mut temp = [0u8; 8];
66-
let mut slice = &mut temp[..];
67-
varint.encode(&mut slice);
68-
buf.extend_from_slice(&temp[..size])
69-
.map_err(|_| MessageError::BufferFull)
70-
}
71-
72-
/// Decode a type key as RFC 9000 variable-length integer from a byte slice.
73-
/// Returns the type key and the number of bytes consumed.
74-
fn decode_type_key(data: &[u8]) -> Result<(u16, usize), MessageError> {
75-
let mut cursor = data;
76-
let varint = VarInt::decode(&mut cursor).map_err(|_| MessageError::DecodeFailed)?;
77-
let consumed = data.len() - cursor.remaining();
78-
let value = varint.into_inner();
79-
let type_key = u16::try_from(value).map_err(|_| MessageError::InvalidMessageType)?;
80-
Ok((type_key, consumed))
81-
}
82-
8351
/// Maximum size for a single CBOR message
8452
pub const MAX_MESSAGE_SIZE: usize = 1024;
8553

‎openscreen-common/src/lib.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,9 @@
2121
2222
mod error;
2323
pub mod quinn_varint;
24+
mod type_key;
2425
mod types;
2526

2627
pub use error::*;
28+
pub use type_key::*;
2729
pub use types::*;

‎openscreen-common/src/type_key.rs‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,53 @@
1+
// Copyright 2025 Google LLC
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
//! Type key encoding/decoding using RFC 9000 variable-length integers.
16+
17+
use bytes::Buf;
18+
use heapless::Vec;
19+
20+
use crate::error::MessageError;
21+
use crate::quinn_varint::{Codec, VarInt};
22+
23+
/// Encode a type key as RFC 9000 variable-length integer into a heapless::Vec
24+
pub fn encode_type_key<const N: usize>(
25+
type_key: u16,
26+
buf: &mut Vec<u8, N>,
27+
) -> Result<(), MessageError> {
28+
let varint = VarInt::from(type_key);
29+
let size = varint.size();
30+
31+
// Ensure we have space
32+
if buf.len() + size > N {
33+
return Err(MessageError::BufferFull);
34+
}
35+
36+
// Encode varint to a small stack buffer, then copy
37+
let mut temp = [0u8; 4];
38+
let mut slice = &mut temp[..];
39+
varint.encode(&mut slice);
40+
buf.extend_from_slice(&temp[..size])
41+
.map_err(|_| MessageError::BufferFull)
42+
}
43+
44+
/// Decode a type key as RFC 9000 variable-length integer from a byte slice.
45+
/// Returns the type key and the number of bytes consumed.
46+
pub fn decode_type_key(data: &[u8]) -> Result<(u16, usize), MessageError> {
47+
let mut cursor = data;
48+
let varint = VarInt::decode(&mut cursor).map_err(|_| MessageError::DecodeFailed)?;
49+
let consumed = data.len() - cursor.remaining();
50+
let value = varint.into_inner();
51+
let type_key = u16::try_from(value).map_err(|_| MessageError::InvalidMessageType)?;
52+
Ok((type_key, consumed))
53+
}

‎openscreen-network/src/messages.rs‎

Lines changed: 1 addition & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -23,11 +23,9 @@
2323
//!
2424
//! Reference: ref/w3c_ref/messages_appendix.cddl
2525
26-
use bytes::Buf;
2726
use heapless::Vec;
2827
use minicbor::{Decoder, Encoder};
29-
use openscreen_common::quinn_varint::{Codec, VarInt};
30-
use openscreen_common::MessageError;
28+
use openscreen_common::{decode_type_key, encode_type_key, MessageError};
3129

3230
/// A wrapper around heapless::Vec that implements minicbor's Write trait
3331
/// This allows us to encode directly into the Vec without stack allocations
@@ -51,38 +49,6 @@ impl<'a, const N: usize> minicbor::encode::Write for VecWriter<'a, N> {
5149
}
5250
}
5351

54-
/// Encode a type key as RFC 9000 variable-length integer into a heapless::Vec
55-
fn encode_type_key<const N: usize>(
56-
type_key: u16,
57-
buf: &mut Vec<u8, N>,
58-
) -> Result<(), MessageError> {
59-
let varint = VarInt::from(type_key);
60-
let size = varint.size();
61-
62-
// Ensure we have space
63-
if buf.len() + size > N {
64-
return Err(MessageError::BufferFull);
65-
}
66-
67-
// Encode varint to a small stack buffer, then copy
68-
let mut temp = [0u8; 8];
69-
let mut slice = &mut temp[..];
70-
varint.encode(&mut slice);
71-
buf.extend_from_slice(&temp[..size])
72-
.map_err(|_| MessageError::BufferFull)
73-
}
74-
75-
/// Decode a type key as RFC 9000 variable-length integer from a byte slice.
76-
/// Returns the type key and the number of bytes consumed.
77-
fn decode_type_key(data: &[u8]) -> Result<(u16, usize), MessageError> {
78-
let mut cursor = data;
79-
let varint = VarInt::decode(&mut cursor).map_err(|_| MessageError::DecodeFailed)?;
80-
let consumed = data.len() - cursor.remaining();
81-
let value = varint.into_inner();
82-
let type_key = u16::try_from(value).map_err(|_| MessageError::InvalidMessageType)?;
83-
Ok((type_key, consumed))
84-
}
85-
8652
/// Maximum size for a single CBOR message
8753
pub const MAX_MESSAGE_SIZE: usize = 1024;
8854

0 commit comments

Comments
 (0)