# File rdf/redland/model.rb, line 27
    def Model.create_finalizer(model)
      proc {|id| "Finalizer on #{id}"
        #$log_final.info "closing model"
        Redland::librdf_free_model(model)
      }
    end

# File rdf/redland/model.rb, line 17
    def initialize(store=nil)
      @statements = []
      store = MemoryStore.new() if not store
      @model = Redland.librdf_new_model($world.world,store.store,"")
      raise RedlandError.new("Creating new Model failed") if not @model
      @store = store
      ObjectSpace.define_finalizer(self,Model.create_finalizer(@model))
    end

# File rdf/redland/model.rb, line 71
    def add(subject,predicate,object,context=nil)
      my_statement = Statement.new(subject,predicate,object)
      self.add_statement(my_statement,context)
    end

# File rdf/redland/model.rb, line 60
    def add_statement(statement,context=nil)
      if context
        context = Node.ensure(context)
        raise RedlandError.new("Cannot make a Node from an object of #{context.class}") if not context
        return Redland.librdf_model_context_add_statement(self.model,context,statement.statement)
      else
        return Redland.librdf_model_add_statement(self.model,statement.statement)
      end
    end

# File rdf/redland/model.rb, line 78
    def add_statements(statement_stream,context=nil)
      if context
        context = Node.ensure(context)
        raise RedlandError.new("Cannot make a Node from an object of #{context.class}") if not context
        Redland.librdf_model_context_add_statements(self.model,context,statement_stream.stream)
      else
        return Redland.librdf_model_add_statements(self.model,statement_stream.stream)
      end
    end

# File rdf/redland/model.rb, line 188
    def as_stream(context=nil)
      if context
        context = Node.ensure(context)
        raise RedlandError.new("Cannot make a Node from an object of #{context.class}") if not context
        my_stream = Redland.librdf_model_context_as_stream(self.model,context)
      else
        my_stream = Redland.librdf_model_as_stream(self.model)
      end
      return Stream.new(my_stream,self)
    end

# File rdf/redland/model.rb, line 352
    def contexts()
      my_iterator = Redland.librdf_model_get_contexts(@model)
      raise RedlandError.new("Unable to create iterator for contexts") if !my_iterator
      iterator= NodeIterator.new(my_iterator,self)
      if block_given?
        while not iterator.end?
          yield iterator.current
          iterator.next
        end
      else
        context_array = []
        while not iterator.end?
          context_array << iterator.current
          iterator.next
        end
        return context_array
      end
    end

# File rdf/redland/model.rb, line 36
    def create_resource(str=nil,context=nil)
      resource = Resource.new(str,self,context)
      if context
        resource.set_context(Resource.new(context))
      end
      return resource
    end

# File rdf/redland/model.rb, line 156
    def delete(s,p,o,context=nil)
      if [s,p,o].all? { |e| e }
        statement = Statement.new(s,p,o)
        self.delete_statement(statement,context)
      else
        self.find(s,p,o,context) do |ds, dp, d_o|
          st = Statement.new(ds, dp, d_o)
          Kernel.p st
          self.delete_statement(st, context)
        end
      end
    end

# File rdf/redland/model.rb, line 170
    def delete_context(context)
      context = Node.ensure(context)
      raise RedlandError.new("Cannot make a Node from an object of #{context.class}") if not context
      return Redland.librdf_model_context_remove_statements(self.model,context)
    end

# File rdf/redland/model.rb, line 145
    def delete_statement(statement,context=nil)
      if context
        context = Node.ensure(context)
        RedlandError.new("Cannot make a Node from an object of #{context.class}") if not context
        return Redland.librdf_model_context_remove_statement(self.model,context,statement.statement)
      else
        return Redland.librdf_model_remove_statement(self.model,statement.statement)
      end
    end

# File rdf/redland/model.rb, line 380
    def dump_model(context=nil)
      self.triples(context){|s,p,o| puts "#{s}:#{p}:#{o}"}
    end

# File rdf/redland/model.rb, line 238
    def find(s=nil,p=nil,o=nil,context=nil)
      statement = Statement.new(s,p,o,self)
      if context
        context = Node.ensure(context)
        raise RedlandError.new("Cannot make a Node from an object of #{context.class}") if not context
        my_stream = Redland.librdf_model_find_statements_in_context(self.model,statement.statement,context)
      else
        my_stream = Redland.librdf_model_find_statements(self.model,statement.statement)
      end
      return nil if not my_stream      
      stream = Stream.new(my_stream,self)
      if block_given?
        while not stream.end?
          my_statement = stream.current
          yield my_statement.subject,my_statement.predicate,my_statement.object
          stream.next
        end
      else #block not given
        return get_statement_array(stream)
      end
    end

# File rdf/redland/model.rb, line 46
    def get_resource(arg)
      res = self.find(Resource.new(arg),nil,nil)
      return (res.nil? || res[0].nil?) ? nil : res[0].subject
    end

# File rdf/redland/model.rb, line 182
    def include?(s,p,o)
      statement = Statement.new(s,p,o)
      self.include_statement?(statement)
    end

# File rdf/redland/model.rb, line 177
    def include_statement?(statement)
      return (Redland.librdf_model_contains_statement(self.model,statement.statement) != 0)
    end

# File rdf/redland/model.rb, line 433
    def load(uri, name="", mime_type="", type_uri=nil)
      ruri = uri.uri
      rtype_uri = type_uri.nil? ? nil : type_uri.uri
      return Redland.librdf_model_load(@model, ruri, name, mime_type, rtype_uri)
    end

# File rdf/redland/model.rb, line 266
    def object(source,predicate)
      if source.class == Uri then source = Node.new(source) end
      if predicate.class == Uri then predicate = Node.new(predicate) end
      my_node = Redland.librdf_model_get_target(self.model,source.node,predicate.node)
      return nil if not my_node
      return Literal.from_node(my_node) if is_literal?(my_node)
      return Resource.new(my_node,self,false)
    end

# File rdf/redland/model.rb, line 387
    def parse_and_merge(parser,uri,predlist,context=uri,st=nil)
      context = Uri.new(context) if context == uri
      temp_model = MergedModel.new(self)
      if st
        temp_model.add_statement(st)
      else
        parser.parse_as_stream(uri){|s|temp_model.add_statement(s)}
      end
      temp_model.find_canonical(predlist)
      temp_model.rewrite(context)
      if temp_model.global_rewrites.size > 0
        print "***** GLOBAL REWRITES UNDERWAY ***"
        #self.rewrite(temp_model.global_rewrites)
      end
    end

# File rdf/redland/model.rb, line 317
    def predicates(source,target)
      if source.class == Uri
        source = Node.new(source)
      end
      if target.class == Uri or target.class == String
        target =Node.new(target)
      end
      my_iterator = Redland.librdf_model_get_arcs(self.model,source.node,target.node)
      raise RedlandError.new("unable to create iterator") if !my_iterator
      iterator = NodeIterator.new(my_iterator,self,source,target)
      if block_given?    
        while not iterator.end?
          yield iterator.current
          iterator.next
        end
      else 
        return get_node_array(iterator)
      end
    end

# File rdf/redland/model.rb, line 416
    def query_execute(query)
      results=Redland.librdf_model_query_execute(@model, query.query)
      if not results
        return nil
      else
        return QueryResults.new(results)
      end
    end

# File rdf/redland/model.rb, line 404
    def rewrite(change_hash)
      transactions = []
    end

# File rdf/redland/model.rb, line 373
    def save(filename)
      serializer = Serializer.new()
      serializer.to_file(filename,self)
    end

# File rdf/redland/model.rb, line 53
    def size()
      s = get_size()
      raise RedlandError.new("Attempt to get size when using non-countable storage") if s < 0
      return s
    end

# File rdf/redland/model.rb, line 90
    def smush(pred)
      identifying_hash = {}
      canonical = {}
      mapme = []
      transactions = []
      self.find(nil,pred,nil){|sub,pred,obj|
        if not identifying_hash.has_key?(obj.to_s)
          identifying_hash[obj.to_s] = sub
        elsif identifying_hash[obj.to_s] != sub
          subject_string = sub.to_s
          if not canonical.has_key?(subject_string)
            # print "amodule Rdf dding mapping: ",subject_string,"--->",identifying_hash[obj.to_s]
            canonical[subject_string] = identifying_hash[obj.to_s]
            mapme << Node.new(sub)
          end
        end
      }
      
      self.triples(){ |sub,pred,obj| 
        ss = sub.to_s
        os = obj.to_s
        new_statement = nil
        replace = false

        if canonical.has_key?(ss)
          if not replace
            new_statement = Statement.new(sub,pred,obj)
            replace = 1
          end
          new_statement.subject = canonical[ss]
        end
        if canonical.has_key?(os)
          if not replace
            new_statement = Statement.new(sub,pred,obj)
            replace = 1
            new_statement.object = canonical[os]
          end
        end
        
        if replace
          
          transactions << [Statement.new(sub,pred,obj),new_statement]
        end
      }

      
      transactions.each{ |pair|
        self.delete_statement(pair[0])
        self.add_statement(pair[1])
      }
    end

# File rdf/redland/model.rb, line 260
    def statement_array_or_yield(stream)
      
    end

# File rdf/redland/model.rb, line 216
    def statements(context = nil)
      stream = self.as_stream(context)
      while not stream.end?
        yield stream.current
        stream.next
      end
    end

# File rdf/redland/model.rb, line 301
    def subject(predicate,target)
      if predicate.class == Uri
        predicate = Node.new(predicate)
      end
      if target.class == Uri or target.class == String
        target = Node.new(target)
      end
      my_node = Redland.librdf_model_get_source(self.model,predicate.node,target.node)
      return nil if !my_node
      return Literal.from_node(my_node) if is_literal?(my_node)
      return Resource.new(my_node,self,false)
    end

# File rdf/redland/model.rb, line 278
    def subjects(predicate,target)
      if predicate.class == Uri
        predicate = Node.new(predicate)
      end
      if target.class == Uri or target.class == String
        target = Node.new(target)
      end
      my_iterator = Redland.librdf_model_get_sources(self.model,predicate.node,target.node)
      raise RedlandError.new("Unable to create iterator") if !my_iterator
      iterator = NodeIterator.new(my_iterator,self,predicate,target)
      if block_given?
        while not iterator.end?
          yield iterator.current
          iterator.next
        end
      else
        return get_node_array(iterator)
      end

    end

# File rdf/redland/model.rb, line 426
    def to_string(name="", base_uri=nil, mime_type="", type_uri=nil)
      rbase_uri = base_uri.nil? ? nil : base_uri.uri
      rtype_uri = type_uri.nil? ? nil : type_uri.uri

      return Redland.librdf_model_to_string(@model, rbase_uri, name, mime_type, rtype_uri)
    end

# File rdf/redland/model.rb, line 202
    def triples(context=nil)
      stream = self.as_stream(context)
      return nil if not stream
      if block_given?
        while not stream.end?
          yield stream.current.subject ,stream.current.predicate,stream.current.object
          stream.next
        end
      else
        return get_statement_array(stream)
      end
    end

# File rdf/redland/model.rb, line 225
    def triples_with_context(context=nil)
      stream = self.as_stream(context)
      while not stream.end?
        statement = stream.current
        yield statement.subject, statement.predicate, statement.object, stream.context
        stream.next
      end
    end

# File rdf/redland/model.rb, line 337
    def yield_node_or_array(iterator)
      iterator = NodeIterator.new(my_iterator,self,source,target)
      if block_given?    
        while not iterator.end?
          yield iterator.current
          iterator.next
        end
      else 
        return get_node_array(iterator)
      end
    end