Struct gedcomx::Name

#[non_exhaustive]
pub struct Name {
    pub id: Option<Id>,
    pub lang: Option<Lang>,
    pub sources: Vec<SourceReference>,
    pub analysis: Option<ResourceReference>,
    pub notes: Vec<Note>,
    pub confidence: Option<ConfidenceLevel>,
    pub attribution: Option<Attribution>,
    pub name_type: Option<NameType>,
    pub name_forms: Vec<NameForm>,
    pub date: Option<Date>,
}

A name of a person.

A Name is intended to represent a single variant of a person’s name. This means that nicknames, spelling variations, or other names (often distinguishable by a name type) should be modeled with separate instances of Name.

The name forms of a name contain alternate representations of the name. A Name MUST contain at least one name form, presumably a representation of the name that is considered proper and well formed in the person’s native, historical cultural context. Other name forms MAY be included, which can be used to represent this name in contexts where the native name form is not easily recognized and interpreted. Alternate forms are more likely in situations where conclusions are being analyzed across cultural context boundaries that have both language and writing script differences.

For example, a Korean name has a native Korean form, but can also have a Chinese form and a Roman/Latin form—three different name forms, but each representing the same name.

If more than one name form is provided, included name forms are presumed to be given in order of preference, with the most preferred name form in the first position in the list.

Examples

Consider the following: a Russian person with the birth name “Александр” (rendered as “Alexander” in English and in a Latin script) that also went by this name’s common nickname, “Саша” (rendered as “Sasha” in English).

It is tempting to think that this situation should be modeled with one Name instance that has several alternate NameForms. The model is not designed to be used in this way. Instead, this person’s names ought to be modeled such that the birth name and the nickname are modeled as two separate Name instances: one instance for the birth name, and one for the nickname. The type property MAY be provided to distinguish the birth name from the nickname. Each Name instance MAY have two NameForm instances: one with the native form of the name and another with the

Name1.type=http://gedcomx.org/BirthName
Name1.nameForms[0].fullText=Александр
Name1.nameForms[1].fullText=Alexander

Name2.type=http://gedcomx.org/Nickname
Name2.nameForms[0].fullText=Саша
Name2.nameForms[1].fullText=Sasha

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: Option<Id>

An identifier for the conclusion data. The id is to be used as a “fragment identifier” as defined by RFC 3986, Section 3.5.

lang: Option<Lang>

The locale identifier for the conclusion.

sources: Vec<SourceReference>

The list of references to the sources of related to this conclusion. Note that the sources referenced from conclusions are also considered to be sources of the entities that contain them. For example, a source associated with the Name of a Person is also source for the Person.

analysis: Option<ResourceReference>

A reference to the analysis document explaining the analysis that went into this conclusion. If provided, MUST resolve to an instance of Document of type Analysis.

notes: Vec<Note>

A list of notes about this conclusion.

confidence: Option<ConfidenceLevel>

The level of confidence the contributor has about the data.

attribution: Option<Attribution>

The attribution of this conclusion. If not provided, the attribution of the containing data set (e.g. file) of the conclusion is assumed.

name_type: Option<NameType>

The name type.

name_forms: Vec<NameForm>

The name form(s) that best express this name, usually representations considered proper and well formed in the person’s native, historical cultural context.

At least one name form MUST be provided. All included name forms SHOULD be representations of the same name, and NOT variants of the name (i.e., not nicknames or spelling variations).

date: Option<Date>

The date of applicability of the name.

Implementations

impl Name

pub fn new(
    id: Option<Id>,
    lang: Option<Lang>,
    sources: Vec<SourceReference>,
    analysis: Option<ResourceReference>,
    notes: Vec<Note>,
    confidence: Option<ConfidenceLevel>,
    attribution: Option<Attribution>,
    name_type: Option<NameType>,
    name_forms: Vec<NameForm>,
    date: Option<Date>
) -> Self

pub fn part_for_type(&self, name_type: &NamePartType) -> Option<&str>

pub fn builder(name_form: NameForm) -> NameBuilder

Trait Implementations

impl Clone for Name

fn clone(&self) -> Name

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Name

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

Formats the value using the given formatter.

impl Default for Name

fn default() -> Name

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Name

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<&'_ str> for Name

fn from(s: &str) -> Self

Performs the conversion.

impl PartialEq<Name> for Name

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Name

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl YaDeserialize for Name

fn deserialize<R: Read>(reader: &mut Deserializer<R>) -> Result<Self, String>

impl YaSerialize for Name

fn serialize<W: Write>(&self, writer: &mut Serializer<W>) -> Result<(), String>

fn serialize_attributes(
    &self,
    source_attributes: Vec<OwnedAttribute>,
    source_namespace: Namespace
) -> Result<(Vec<OwnedAttribute>, Namespace), String>

impl StructuralPartialEq for Name