class ActiveFedora::QualifiedDublinCoreDatastream

Fields can still be overridden if more specificity is desired (see ActiveFedora::File#fields method).
Fedora Dublin Core XML datastreams structure.
This implementation features customized xml generators and deserialization routines to handle the
The implementation of this class defines the terms from the Qualified Dublin Core specification.
This class represents a Qualified Dublin Core Datastream. A special case of ActiveFedora::OmDatastream

def self.xml_template 

def self.xml_template
   Nokogiri::XML::Document.parse("<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'/>")
end

def field(name, tupe=nil, 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 +QualifiedDublinCorDatastreams+:
Currently supported modifiers:

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

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

Calling any of the generated methods marks self as dirty.


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, tupe=nil, opts={})
  fields ||= {}
  @fields[name.to_s.to_sym]={:type=>tupe, :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)
    om_term_opts = {:xmlns=>"http://purl.org/dc/terms/", :namespace_prefix => "dcterms", :path => opts[:path]}
    term = OM::XML::Term.new(name.to_sym, om_term_opts, 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={}
  DCTERMS.each do |el|
    field el, :string, :multiple=>true
  end
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|
    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 )
      end
    end
  end
  return solr_doc
end

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

def update_indexed_attributes(params={}, opts={})
  # 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