Struct Cnpj 

pub struct Cnpj { /* private fields */ }

A validated CNPJ (Cadastro Nacional da Pessoa Jurídica).

Cnpj is a 14-byte, Copy, allocation-free value object. Once constructed, it is guaranteed to satisfy the structural rules and Módulo 11 checksum required by the crate — there is no way to obtain a Cnpj that hasn’t passed validation.

Internally, the identifier is stored as raw uppercase ASCII bytes ('0'...='9' or 'A'...='Z'). This keeps the compact representation lossless and makes borrowed access to the normalized form cheap.

Constructing a Cnpj

Constructor	Accepts
Cnpj::parse / Cnpj::new	Punctuated or compact strings, any ASCII case
Cnpj::from_bytes	Exactly 14 pre-normalized ASCII bytes, no punctuation
FromStr / TryFrom<&str>	Same as parse, for use in generic code

All of them run the same validation and return CnpjError on failure. See the module-level documentation for the field layout, format history, and design rationale.

Implementations

impl Cnpj

pub fn parse(input: &str) -> Result<Self, CnpjError>

Parses a CNPJ from a string.

The parser accepts the conventional AA.AAA.AAA/AAAA-DD form as well as the compact 14-character form. It also tolerates surrounding and embedded ASCII spaces and folds ASCII letters to uppercase before validation.

This is the primary constructor; Cnpj::new, FromStr, and TryFrom<&str> all delegate to it.

Errors

Returns CnpjError if the input is empty, does not contain exactly 14 meaningful characters after formatting is removed, contains a character invalid for its position, consists of a single repeated character, or fails the checksum.

Examples

use ftracker_identifiers::Cnpj;

assert!(Cnpj::parse("00.000.000/0001-91").is_ok());
assert!(Cnpj::parse("00000000000191").is_ok());
assert!(Cnpj::parse("12abc34501de35").is_ok()); // lowercase is folded automatically
assert!(Cnpj::parse("not-a-cnpj").is_err());

pub fn new(input: &str) -> Result<Self, CnpjError>

Alias for Cnpj::parse.

Errors

See Cnpj::parse.

Examples

use ftracker_identifiers::Cnpj;

assert_eq!(Cnpj::new("00000000000191"), Cnpj::parse("00000000000191"));

pub fn from_bytes(bytes: [u8; 14]) -> Result<Self, CnpjError>

Constructs a Cnpj directly from 14 raw ASCII bytes.

Each byte must already be an ASCII digit, and for the first 12 positions may also be an uppercase ASCII letter. Use Cnpj::parse if the input might contain punctuation or lowercase letters.

Numeric-only CNPJs remain fully supported. Pass ASCII digit bytes (b'0'...=b'9'), not raw numeric values.

Errors

Returns CnpjError under the same conditions as Cnpj::parse, except that length is guaranteed by the [u8; 14] type itself: CnpjError::InvalidLength cannot occur here.

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::from_bytes(*b"00000000000191").unwrap();
assert_eq!(cnpj.as_str(), "00000000000191");

// A malformed checksum is rejected just like it would be through `parse`.
assert!(Cnpj::from_bytes(*b"00000000000192").is_err());

pub fn as_bytes(&self) -> &[u8; 14]

Returns the 14 raw ASCII bytes backing this CNPJ.

The returned bytes are in compact form, without punctuation (for example, b"12ABC34501DE35").

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::parse("00000000000191").unwrap();
assert_eq!(cnpj.as_bytes(), b"00000000000191");

pub fn as_str(&self) -> &str

Returns the compact CNPJ as a &str.

This never allocates: the bytes are guaranteed to be valid ASCII by construction.

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::parse("00.000.000/0001-91").unwrap();
assert_eq!(cnpj.as_str(), "00000000000191");

pub fn formatted(&self) -> FormattedCnpj

Renders the punctuated AA.AAA.AAA/AAAA-DD form without heap allocation.

See FormattedCnpj. Cnpj’s own Display implementation delegates to this, so cnpj.to_string() and cnpj.formatted().to_string() are equivalent.

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::parse("00000000000191").unwrap();
assert_eq!(cnpj.formatted().as_str(), "00.000.000/0001-91");
assert_eq!(cnpj.to_string(), cnpj.formatted().as_str());

pub fn root(&self) -> &str

Returns the 8-character root segment.

This identifies the entity itself and is shared by the company and all of its branches.

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::parse("00000000000191").unwrap();
assert_eq!(cnpj.root(), "00000000");

pub fn branch_code(&self) -> &str

Returns the 4-character branch/order segment.

"0001" conventionally denotes the head office (matriz); see Cnpj::is_root.

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::parse("11.222.333/0002-62").unwrap();
assert_eq!(cnpj.branch_code(), "0002");

pub fn is_root(&self) -> bool

Returns true when the branch/order segment is "0001".

Examples

use ftracker_identifiers::Cnpj;

assert!(Cnpj::parse("00000000000191").unwrap().is_root());
assert!(!Cnpj::parse("11.222.333/0002-62").unwrap().is_root());

pub fn branch_number(&self) -> Option<u16>

Returns the branch/order segment as a number when it is purely numeric.

Returns None when the segment contains a letter, which is only possible for alphanumeric-format CNPJs. Numeric CNPJs, including the conventional matriz marker ("0001"), always parse successfully.

Examples

use ftracker_identifiers::Cnpj;

let matriz = Cnpj::parse("00000000000191").unwrap();
assert_eq!(matriz.branch_number(), Some(1));

let alphanumeric_branch = Cnpj::parse("12ABC34501DE35").unwrap();
assert_eq!(alphanumeric_branch.branch_code(), "01DE");
assert_eq!(alphanumeric_branch.branch_number(), None);

pub fn check_digits(&self) -> (u8, u8)

Returns the two verification digits as numeric values.

Examples

use ftracker_identifiers::Cnpj;

let cnpj = Cnpj::parse("00000000000191").unwrap();
assert_eq!(cnpj.check_digits(), (9, 1));

Trait Implementations

impl<'a> Arbitrary<'a> for Cnpj

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl AsRef<[u8]> for Cnpj

fn as_ref(&self) -> &[u8]

Equivalent to Cnpj::as_bytes, borrowed as a slice.

impl AsRef<str> for Cnpj

fn as_ref(&self) -> &str

Equivalent to Cnpj::as_str.

impl Clone for Cnpj

fn clone(&self) -> Cnpj

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Cnpj

impl Debug for Cnpj

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Cnpj

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Cnpj

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Cnpj

impl FromStr for Cnpj

fn from_str(s: &str) -> Result<Self, Self::Err>

Delegates to Cnpj::parse, enabling input.parse::<Cnpj>() and use in generic code bounded by FromStr.

type Err = CnpjError

The associated error which can be returned from parsing.

impl Hash for Cnpj

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for Cnpj

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn json_schema(_: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl Ord for Cnpj

fn cmp(&self, other: &Cnpj) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Cnpj

fn eq(&self, other: &Cnpj) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialEq<&str> for Cnpj

fn eq(&self, other: &&str) -> bool

Compares against a string slice by its compact 14 character representation (not the punctuated form).

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialEq<Cnpj> for str

fn eq(&self, other: &Cnpj) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialEq<Cnpj> for &str

fn eq(&self, other: &Cnpj) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialEq<str> for Cnpj

fn eq(&self, other: &str) -> bool

Compares against a string slice by its compact 14 character representation (not the punctuated form).

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Cnpj

fn partial_cmp(&self, other: &Cnpj) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Cnpj

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Cnpj

impl TryFrom<&[u8]> for Cnpj

fn try_from(value: &[u8]) -> Result<Self, Self::Error>

Validates a byte slice as a CNPJ. The slice must be exactly 14 pre normalized ASCII bytes, without punctuation; any other length yields CnpjError::InvalidLength. Once the length is confirmed, this behaves like Cnpj::from_bytes.

type Error = CnpjError

The type returned in the event of a conversion error.

impl TryFrom<&str> for Cnpj

fn try_from(value: &str) -> Result<Self, Self::Error>

Delegates to Cnpj::parse, enabling Cnpj::try_from(input) and use in generic code bounded by TryFrom<&str>.

type Error = CnpjError

The type returned in the event of a conversion error.

impl TryFrom<[u8; 14]> for Cnpj

fn try_from(value: [u8; 14]) -> Result<Self, Self::Error>

Delegates to Cnpj::from_bytes. The bytes must already be pre normalized ASCII, without punctuation.

type Error = CnpjError

The type returned in the event of a conversion error.