class ActiveFedora::SimpleDatastream

This class represents a simple xml datastream.

def self.xml_template 

def self.xml_template
   Nokogiri::XML::Document.parse("<fields/>")
end

def field(name, datatype=:string, opts={})

whenever you edit the field's values.
you will end up replicating the values in the underlying datastream, resulting in mysterious dubling, quadrupling, etc.
!! Careful: If you declare two fields that correspond to the same xml node without any qualifiers to differentiate them,

There is quite a good example of this class in use in spec/examples/oral_history.rb


:multiple=>true - mark this field as a multivalue field (on by default)
:encoding=>foo, or encodings_scheme - causes an xsi:type attribute to be set to 'foo'
:xml_node => :nodename - The xml node to be used to represent this object (in dcterms namespace)
:element_attrs =>{:foo=>:bar} - hash of xml element attributes
For +SimpleDatastream+:
Currently supported modifiers:

opts is an options hash, which will affect the generation of the xml representation of this datastream.

'datatype' is a datatype, currently :string, :integer and :date are supported.


name
name=(arg)
each field will have the 2 magic methods:
This method generates the various accessor and mutator methods on self for the datastream metadata attributes. 
def field(name, datatype=:string, opts={})
  fields ||= {}
  @fields[name.to_s.to_sym]={:type=>datatype, :values=>[]}.merge(opts)
  # add term to template
  self.class.class_fields << name.to_s
  # add term to terminology
  unless self.class.terminology.has_term?(name.to_sym)
    term = OM::XML::Term.new(name.to_sym, {:type=>datatype}, self.class.terminology)
    self.class.terminology.add_term(term)
    term.generate_xpath_queries!
  end
end

def initialize(digital_object=nil, dsid=nil, options={})

when this method returns. Each term is marked as a multivalue string.
Constructor. this class will call self.field for each DCTERM. In short, all DCTERMS fields will already exist 
def initialize(digital_object=nil, dsid=nil, options={})
  super
  self.fields={}
end

def to_solr(solr_doc = Hash.new, opts = {}) # :nodoc:

:nodoc: 
def to_solr(solr_doc = Hash.new, opts = {}) # :nodoc:
  @fields.each do |field_key, field_info|
    next if field_key == :location ## FIXME HYDRA-825
    things = send(field_key)
    if things
      field_symbol = ActiveFedora::SolrQueryBuilder.solr_name(field_key, type: field_info[:type])
      things.val.each do |val|
        ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val.to_s )
      end
    end
  end
  return solr_doc
end

def update_indexed_attributes(params={}, opts={}) 

def update_indexed_attributes(params={}, opts={})
  raise "can't modify frozen #{self.class}" if frozen?
  # if the params are just keys, not an array, make then into an array.
  new_params = {}
  params.each do |key, val|
    if key.is_a? Array
      new_params[key] = val
    else
      new_params[[key.to_sym]] = val
    end
  end
  super(new_params, opts)
end