[−][src]Macro hdk::entry

macro_rules! entry {
    (
        name: $name:expr,
        description: $description:expr,
        sharing: $sharing:expr,
        $(native_type: $native_type:ty,)*

        validation_package: || $package_creator:expr,
        validation: | $entry:ident : $entry_type:ty, $ctx:ident : hdk::ValidationData | $entry_validation:expr
    ) => { ... };
}

The entry macro is a helper for creating ValidatingEntryType definitions for use within the define_zome macro. It has 6 component parts:

  1. name: name is simply the descriptive name of the entry type, such as "post", or "user". It is what must be given as the entry_type_name argument when calling commit_entry and the other data read/write functions.
  2. description: description is something that is primarily for human readers of your code, just describe this entry type
  3. sharing: sharing defines what distribution over the DHT, or not, occurs with entries of this type, possible values are defined in the Sharing enum
  4. native_type: native_type references a given Rust struct, which provides a clear schema for entries of this type.
  5. validation_package: validation_package is a special identifier, which declares which data is required from peers when attempting to validate entries of this type. Possible values are found within ValidationPackageDefinition
  6. validation: validation is a callback function which will be called any time that a source chain action is taken relating to this entry type, such as commit_entry, update_entry, remove_entry. It always expects two arguments, the first of which is the entry attempting to be validated, the second is the validation context, which offers a variety of metadata useful for validation.

Examples

The following is a standalone Rust file that exports a function which can be called to get a ValidatingEntryType of a "post".

use boolinator::*;
use hdk::{
  self,
  entry_definition::ValidatingEntryType,
  holochain_dna::zome::entry_types::Sharing
};
use serde_json;
 
#[derive(Serialize, Deserialize)]
pub struct Post {
    content: String,
    date_created: String,
}
 
pub fn definition() -> ValidatingEntryType {
    entry!(
        name: "post",
        description: "a short social media style sharing of content",
        sharing: Sharing::Public,
        native_type: Post,
 
        validation_package: || {
            hdk::ValidationPackageDefinition::ChainFull
        },
 
        validation: |post: Post, _ctx: hdk::ValidationData| {
            (post.content.len() < 280)
                .ok_or_else(|| String::from("Content too long"))
        }
    )
}