Enum KindCode 

pub enum KindCode {
    A1,
    A2,
    A9,
    B1,
    B2,
    C1,
    C2,
    C3,
    E1,
    S1,
    P1,
    P2,
    P3,
    P4,
    P9,
    H1,
    Unknown,
}

Patent and Patent-application document kind codes (WIPO ST.16 style).

This enum focuses on currently used codes for USPTO patent-related documents (utility, design, plant, reissue, reexamination, etc.).

Notes

• Codes follow WIPO ST.16 and USPTO practice (e.g., “US 7,654,321 B2”)
• Trademark-only codes (e.g., X3, X4, X5, X8) are not included
• Some codes are legacy but still appear on older documents (e.g., H, H1)

Variants

A1

Utility patent application, first publication (pre‑grant)

A2

Second or subsequent publication of a utility patent application

A9

Utility patent application, corrected publication

B1

Utility patent grant, no pre‑grant publication (post‑Jan 2, 2001 use)

B2

Utility patent grant, with pre‑grant publication

C1

Identifies a reexamination certificate issued after the first reexamination proceeding for a granted US patent (current C‑series replacement for older B1/B2/B3)

C2

Identifies a reexamination certificate issued after a second reexamination proceeding on the same patent (i.e., the patent has been reexamined twice)

C3

Identifies a reexamination certificate issued after a third reexamination proceeding on that patent

E1

Reissue patent (normalized to two‑position form)

S1

Design patent grant (normalized to two‑position form)

P1

Plant application publication, first publication

P2

Plant patent grant, no pre‑grant publication (post‑Jan 2, 2001)

P3

Plant patent grant, with pre‑grant publication (post‑Jan 2, 2001)

P4

Second or subsequent publication of a plant patent application

P9

Corrected publication of a plant patent application

H1

Statutory invention registration (SIR)

Note

SIR program was ended in 2013, so H/H1 appear only on legacy documents.

Unknown

Unknown, missing, or otherwise un-supported kind code

Implementations

impl KindCode

pub fn is_granted(&self) -> bool

Return true if a kind code is a granted patent, false otherwise (e.g., application, publication)

Trait Implementations

impl Clone for KindCode

fn clone(&self) -> KindCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for KindCode

impl Debug for KindCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KindCode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for KindCode

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

Formats the value using the given formatter.

impl Eq for KindCode

impl From<&str> for KindCode

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<String> for KindCode

fn from(s: String) -> Self

Converts to this type from the input type.

impl Hash for KindCode

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 KindCode

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

The name of the generated JSON Schema.

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

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

fn json_schema(generator: &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.

impl PartialEq for KindCode

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for KindCode

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 KindCode