Struct votable::table::Table

pub struct Table<C: TableDataContent> {
    pub id: Option<String>,
    pub name: Option<String>,
    pub ucd: Option<String>,
    pub utype: Option<String>,
    pub ref_: Option<String>,
    pub nrows: Option<u64>,
    pub extra: HashMap<String, Value>,
    pub description: Option<Description>,
    pub elems: Vec<TableElem>,
    pub links: Vec<Link>,
    pub data: Option<Data<C>>,
    pub infos: Vec<Info>,
}

Fields

id: Option<String>

name: Option<String>

ucd: Option<String>

utype: Option<String>

ref_: Option<String>

nrows: Option<u64>

extra: HashMap<String, Value>

Warning: using extra attributes in Table is not compatible with the VOTable schema. use at your own risks.

description: Option<Description>

elems: Vec<TableElem>

links: Vec<Link>

data: Option<Data<C>>

infos: Vec<Info>

Implementations

impl<C: TableDataContent> Table<C>

pub fn new() -> Self

pub fn set_id<I: Into<String>>(self, id: I) -> Self

pub fn set_id_by_ref<I: Into<String>>(&mut self, id: I)

pub fn set_name<I: Into<String>>(self, name: I) -> Self

pub fn set_name_by_ref<I: Into<String>>(&mut self, name: I)

pub fn set_ucd<I: Into<String>>(self, ucd: I) -> Self

pub fn set_ucd_by_ref<I: Into<String>>(&mut self, ucd: I)

pub fn set_utype<I: Into<String>>(self, utype: I) -> Self

pub fn set_utype_by_ref<I: Into<String>>(&mut self, utype: I)

pub fn set_ref<I: Into<String>>(self, ref_: I) -> Self

pub fn set_ref_by_ref<I: Into<String>>(&mut self, ref_: I)

pub fn set_nrows(self, nrows: u64) -> Self

pub fn set_nrows_by_ref(&mut self, nrows: u64)

pub fn insert_extra<S: Into<String>>(self, key: S, value: Value) -> Self

pub fn insert_extra_by_ref<S: Into<String>>(&mut self, key: S, value: Value)

pub fn set_description(self, description: Description) -> Self

pub fn set_description_by_ref(&mut self, description: Description)

pub fn push_field(self, field: Field) -> Self

pub fn push_field_by_ref(&mut self, field: Field)

pub fn push_param(self, param: Param) -> Self

pub fn push_param_by_ref(&mut self, param: Param)

pub fn push_tablegroup(self, tablegroup: TableGroup) -> Self

pub fn push_tablegroup_by_ref(&mut self, tablegroup: TableGroup)

pub fn push_link(self, link: Link) -> Self

pub fn push_link_by_ref(&mut self, link: Link)

pub fn set_data(self, data: Data<C>) -> Self

pub fn set_data_by_ref(&mut self, data: Data<C>)

pub fn push_info(self, info: Info) -> Self

pub fn push_info_by_ref(&mut self, info: Info)

pub fn for_each_attribute<F>(&self, f: F)

where F: FnMut(&str, &str),

Calls a closure on each (key, value) attribute pairs.

pub fn visit<V>(&mut self, visitor: &mut V) -> Result<(), V::E>

where V: VOTableVisitor<C>,

pub fn read_till_data_by_ref<R: BufRead>( &mut self, reader: &mut Reader<R>, reader_buff: &mut Vec<u8> ) -> Result<Option<Data<C>>, VOTableError>

pub fn to_tabledata(&mut self) -> Result<(), VOTableError>

Transforms the BINARY or BINARY2 tag in this TABLE into TABLEDATA. Do nothing if it already contains a TABLEDATA or if it contains a FITS.

pub fn to_binary(&mut self) -> Result<(), VOTableError>

Transforms the TABLEDATA or BINARY2 tag in this TABLE into BINARY. Do nothing if it already contains a BINARY or if it contains a FITS.

pub fn to_binary2(&mut self) -> Result<(), VOTableError>

Transforms the TABLEDATA or BINARY tag in this TABLE into BINARY2. Do nothing if it already contains a BINARY2 or if it contains a FITS.

Trait Implementations

impl<C: Clone + TableDataContent> Clone for Table<C>

fn clone(&self) -> Table<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + TableDataContent> Debug for Table<C>

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

Formats the value using the given formatter.

impl<C: Default + TableDataContent> Default for Table<C>

fn default() -> Table<C>

Returns the “default value” for a type.

impl<'de, C> Deserialize<'de> for Table<C>

where C: Deserialize<'de> + TableDataContent,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: PartialEq + TableDataContent> PartialEq for Table<C>

fn eq(&self, other: &Table<C>) -> bool

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

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

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

impl<C> Serialize for Table<C>

where C: Serialize + TableDataContent,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: TableDataContent> StructuralPartialEq for Table<C>