ontomde-core 1.0.2

data/lib/ontomde-core/custom_method_missing.rb

@@ -0,0 +1,53 @@
+# Overrides standard ruby method_missing interceptor.
+# NOTE:
+#   This is a workaround for standard method_missing 
+#   generates very high CPU usage
+#   when a significant model is loaded in memory.
+#:include: ../shared/license.rdoc
+
+
+def method_missing(methId,args=nil)
+		msg=respond_to?(:rdf_uri) ? "#{rdf_uri}" : "nil"
+		log.error { "method #{methId} not available for object of class #{self.class.name}, (uri=#{msg})(to_s=#{self})" }
+
+		if msg=="ukb_null" 
+			log.error { <<-END 
+********** INVALID MODEL DETECTED **********
+********** INVALID MODEL DETECTED **********
+**** An invalid source model was used (an ukb_null was found).
+**** Probable cause is that you are using a RSM modeler, and 
+**** one of your model contains an invalid reference somewhere.
+****
+**** Because RSM does not tell you where this error is located,
+**** you have to use your .nt export file :
+****
+**** 1) open .nt export file with a text editor.
+**** 2) locate <http://kb#null> string.
+**** 3) locate left member refering to this null element.
+**** 4) This element is the key of RSM invalid element.
+**** 5) Locate this element in RSM and fix it (or delete it).
+**** 6) Re-export your model and check for null uris.
+****
+********** INVALID MODEL DETECTED **********
+		END
+			}
+		end
+
+		log.debug {
+			msg=""
+			self.methods.sort{|a,b| a<=>b}.each {|m|
+				msg="#{msg}, #{m}"
+			}
+			"Available methods are: #{msg}" 
+		}
+
+		#self.included_modules.each { |m| 
+		#	#puts "include #{m}"
+		#	}
+		puts "end of custom method_missing" 
+		#TODO: l'appel au stock method_missing genere des temps de traitements infinis. (cpu a 100%, conso memoire enorme)
+		#super
+		puts "exiting"
+		throw NoMethodError.new("method missing '#{methId}' for object '#{self.class.name}'",methId,args)
+		#exit
+end

data/lib/ontomde-core/delayed.rb

@@ -0,0 +1,20 @@
+class Delayed2 
+	def initialize(&b)
+		@b=b
+	end	
+	def to_s
+		return @b.call 
+	end
+end
+
+#Example usage:
+#i=45
+#c=mtk_delay { i + 5 }
+#i=35
+#puts  c.to_s
+def mtk_delay (&block) 
+	return Delayed2.new(&block)
+end
+
+
+

data/lib/ontomde-core/demoInstaller.rb

@@ -0,0 +1,32 @@
+module DemoInstaller
+	def proceed(target,source,banner)
+		options = { }
+		options[:target]="#{target}" 
+		OptionParser.new do |opts|
+			opts.banner =banner +<<END
+
+Command syntax:
+----------
+END
+			opts.on("-t","--target DIRECTORY","","target directory where demo project will be installed","default: --target #{options[:target]}" ) do |v|
+				options[:target] = v
+			end
+	
+			
+			# No argument, shows at tail.  This will print an options summary.
+			# Try it and see!
+			opts.on_tail("-h", "--help", "Show this message") do
+				puts opts
+				exit
+			end
+		end.parse!
+
+		if File.exist?(options[:target])
+			puts "WARNING: File already exists (#{options[:target]})"
+			puts "WARNING: Copy aborted"
+		else
+			cp_r("#{source}", options[:target] ) 
+			puts "INFO: Project created in #{options[:target]}"
+		end
+	end
+end

data/lib/ontomde-core/exceptions.rb

@@ -0,0 +1,28 @@
+# Core exceptions class
+#:include: ../shared/license.rdoc
+
+# Generic use exception.
+class Warning  < RuntimeError
+  def initialize()
+  end
+end
+
+# Exception raised when an URI is not found in current model. 
+class WarningURIundefined  < RuntimeError
+  attr_reader :uri
+  def initialize(uri)
+	  @uri=uri
+  end
+end
+
+# Exception raised when a ressources claims to be of a type not defined in currently loaded metamodels.
+class WarningRubyTypeUndefined  < RuntimeError
+  attr_reader :uri,:res
+  def initialize(uri,res)
+	  @res=res
+	  @uri=uri
+  end
+end
+
+class WarningUnknownFileType  < RuntimeError
+end

data/lib/ontomde-core/fileLoader.rb

@@ -0,0 +1,163 @@
+#:include: ../shared/license.rdoc
+
+class NTriple ; end
+
+class NTripleFile < NTriple
+	attr_reader :line
+	def line=(_line)
+		@line=_line
+		@about_uri=@predicat_uri=@value_uri=@value_litteral=nil
+		@split=@line.split(" ",3)
+	end
+
+	def about_uri
+		@about_uri=urialias(@split[0]) if !@about_uri
+		return @about_uri
+	end
+	def predicat_uri
+		@predicat_uri=urialias(@split[1]) if !@predicat_uri
+		return @predicat_uri
+	end
+	def value_uri
+		@value_uri=urialias(@split[2]) if ! @value_uri
+		return @value_uri
+	end
+	def value_litteral
+		@value_litteral=@split[2][1,@split[2].length-5] if !@value_literral
+		return @value_litteral
+	end
+	
+	def valueIsReference?
+		case @split[2][0]
+			when 60 then return true
+			when 34 then return false
+			else raise Warning.new,"Bad ntriple detected"
+		end
+	end
+
+	COMMENT_SIGNATURE="#"[0]
+	def isComment?
+		return	@line[0]==COMMENT_SIGNATURE
+	end
+	
+
+	def isOntoMDXHeader?
+		return @line.to_s=="#!ontomdx\n"
+	end
+end
+
+module Mrdf_Model 
+	def loadMetaModelFromFile(fileName,ignoreHeader=false)
+		@updateCount=@updateCount+1
+		raise Exception.new("nil fileName passed to loadMetaModelFromFile") if fileName.nil? 
+		m=fileName+".rb"
+		#log.debug "m=#{m}"
+		if( File.exists?(m) && File.mtime(m) > File.mtime(fileName) )
+			log.debug "Using cache in #{m}"
+			require(m)
+			loadModelFromFile(fileName,ignoreHeader)
+		else
+			log.debug "Generating cache in #{m}"
+			loadModelFromFile(fileName,ignoreHeader)
+			self.generateClassesFromMetamodel(m)
+		end
+	end
+
+	def loadModelFromFile (srcFileName,ignoreHeader=false)
+		fileName=translateToNt(srcFileName)
+		@updateCount=@updateCount+1
+		#Crdf_Resource.new(self,"xx").initUpdate
+		[false,true].each { |modeData|
+			begin 
+			File.open(fileName,"r") { |aFile|
+					parseModelStream(aFile,modeData,ignoreHeader)
+					}
+			rescue Exception => e 
+					raise Exception.new(e.message+"ERROR *** current file is: \"#{fileName}\"\nERROR ***\n")
+			end
+		}
+	end
+
+	def parseModelStream(stream,modeData,ignoreHeader=false)
+		aFile=stream
+		i=0
+		nt=NTripleFile.new()
+		aFile.each_line {
+			|nt.line|  
+			begin	
+			i=i+1
+
+			if(!ignoreHeader)
+				ignoreHeader=true
+				next if nt.isOntoMDXHeader?
+				p="\nERROR *** "
+				raise Exception.new("#{p}#{p}ontomdx was given a model file without#{p}a valid ontomdx plugin file header.#{p}If you have used a model file created by a modeler plugin,#{p}upgrade your plugin.#{p}Il you have used a plain RDF or RDFS file,#{p}specify ignoreHeader=true when loading model with loadModel.#{p}\n")
+			end
+
+			next if nt.isComment?
+			parse(nt,modeData)
+			rescue WarningRubyTypeUndefined => z
+				log.error "WARNING ["+(modeData ? "data":"res")+" :nt.line "+i.to_s+", "+z.to_s+", Will create a default type. Possible discrepancies if defined later on. In case of problem, Consider bootstraping]:"+nt.line
+				#log.debug "z.res=#{z.res}"
+				z.res.createRubyClassMinimal(self)
+				i=i-1
+				retry
+
+			rescue WarningURIundefined => z
+				log.error "WARNING ["+(modeData ? "data":"res")+" :line "+i.to_s+", "+z.to_s+",Will create a default entry]:"+nt.line
+				#log.debug "z.uri=#{z.uri}"
+				Crdf_Resource.new(self,z.uri)
+				#parse(nt.line,modeData)
+				i=i-1
+				retry
+		        rescue Warning => w
+				log.error "WARNING ["+(modeData ? "data":"res")+" :line "+i.to_s+", "+w.to_s+"]:"+nt.line
+
+       			end
+			}
+	end
+
+# moved to ontomde-redland-win
+#	WIN_PATH_RAPPER=File.expand_path("#{File.dirname(__FILE__)}/../../dist/redland-1.0.3-Win32/rapper.exe").tr('/','\\\\')
+
+	PLATFORM_IS_UNIX=!(RUBY_PLATFORM.index("inux").nil?)
+	def rapperRun(param)
+		if PLATFORM_IS_UNIX
+			cmd="rapper "+param
+		else
+			cmd='"'+WIN_PATH_RAPPER+'"'+param
+		end
+		return if system(cmd)
+		raise Exception.new("\n***\n***Error running command\n***\n***#{cmd}\n***\n")
+		
+	end
+	def translateToNt(srcFileName)
+		return srcFileName if ! (srcFileName=~/.rdfs*$/ )
+
+		fileName="#{srcFileName}.cache.deleteMe.nt"
+		if( File.exists?(fileName) && File.mtime(fileName) > File.mtime(srcFileName) )
+			log.debug "INFO:Using cache in #{fileName}"
+		else
+			raise "Blanc dans nom de fichier non supportes sous windows" if fileName.include?(" ")
+			if PLATFORM_IS_UNIX
+				param=' -q -o ntriples -i rdfxml  '+srcFileName+' > '+fileName
+			else
+				param=' -q -o ntriples -i rdfxml  '+srcFileName.tr('/','\\\\')+' > '+fileName.tr('/','\\\\')+''
+			end
+			rapperRun(param)
+		end
+		return fileName
+	end
+
+	def translateToXML(srcFileName,fileName)
+		raise "Blanc dans nom de fichier non supportes sous windows" if fileName.include?(" ") || srcFileName.include?(" ")
+			if PLATFORM_IS_UNIX
+			param=' -q -i ntriples -o rdfxml  '+srcFileName+' > '+fileName+''
+		else
+			param=' -q -i ntriples -o rdfxml  '+srcFileName.tr('/','\\\\')+' > '+fileName.tr('/','\\\\')+''
+		end
+		rapperRun(param)
+		return fileName
+	end
+
+end

data/lib/ontomde-core/fileTypes.rb

@@ -0,0 +1,133 @@
+# File types supported for round trip. 
+# Other File types may be added easily.
+
+class FileType
+	include Singleton
+	attr_reader :re_begin, :re_end
+	@@types=Hash.new
+	def initialize(type)
+		#puts "type=#{type}"
+		@@types[type]=self
+	end
+	def writeComment(str,writer)
+		raise Warning.new(), "Internal error. Undefined method" 
+	end
+	def beginMarker(str,id)
+		raise Warning.new(), "Internal error. Undefined method" 
+	end
+	def endMarker(str,id)
+		raise Warning.new(), "Internal error. Undefined method" 
+	end
+	def FileType.getFileType(fileName)
+		ext=File.extname(fileName)
+		type=@@types[ext]
+		return type if ! type.nil?
+		msg="Unknown File Type \"#{ext}\" for \"#{fileName}\""
+		log.debug(msg)
+		raise WarningUnknownFileType.new(),msg
+	end
+	# escape text to be included in markers
+	def escape(txt)
+		return txt
+	end
+	#unescape text to be read from markers
+	def unescape(txt)
+		return txt
+	end
+end
+
+class FileTypeJava < FileType
+	include Singleton
+	def initialize(ext=".java")
+		super(ext)
+		@re_begin=Regexp.new(/^[ \t]*\/\*[ _]*XMDA[ _]BEGIN[ _]+reverse="(.*)"[ _]uri="(.*)"[ _]*\*\//)
+		@re_end=Regexp.new(/^[ \t]*\/\*[ _]*XMDA[ _]END[ _]+uri="(.*)"[ _]*\*\//)
+	end
+	def writeComment(str,writer)
+		writer.write("/* #{str} */")
+	end
+	def thinLineComment
+		#return context[:thinLineComment,true] ? ('_'*60) : '' 
+		#return "_____________________________________________________________________________________________________________________________________________"
+		return ""
+	end
+	def beginMarker(uri,reverse)
+		return %{\n/*XMDA_BEGIN_reverse="#{reverse ? 'yes':'no'}"_#{thinLineComment}uri="#{uri}"_*/\n}
+	end
+	def endMarker(uri)
+		return %{\n/*XMDA_END_#{thinLineComment}uri="#{uri}"_*/\n}
+	end
+end
+FileTypeJava.instance # register
+
+class FileTypeXML < FileType
+	# a character that can not exist in a URI
+	URI_ESCAPE_CHAR_ONE='�'
+	def initialize(ext=".xml")
+		super(ext)
+		@re_begin=/^[ \t]*<\!-- *XMDA BEGIN +reverse="([^"]*)" uri="([^"]*)" *-->/
+		@re_end=/^[ \t]*<\!-- *XMDA END +uri="([^"]*)" *-->/
+	end
+	def writeComment(str,writer)
+		writer.write("<!-- #{str} -->")
+	end
+	def beginMarker(uri,reverse)
+		return %{\n<!-- XMDA BEGIN reverse="#{reverse ? 'yes':'no'}" uri="#{escape(uri)}" -->\n}
+	end
+	def endMarker(uri)
+		return %{\n<!-- XMDA END   uri="#{escape(uri)}" -->\n}
+	end
+	def escape(txt)
+		return txt.tr('-',URI_ESCAPE_CHAR_ONE)
+	end
+	def unescape(txt)
+		return txt.tr(URI_ESCAPE_CHAR_ONE,'-')
+	end
+end
+FileTypeXML.instance # register
+
+
+class FileTypeJavaProperties < FileType
+	def initialize(ext=".properties")
+		super(ext)
+		@re_begin=/^[ \t]*#[_ ]*XMDA_BEGIN_reverse="([^"]*)"_uri="([^"]*)"[ _]*$/
+		@re_end=/^[ \t]*#[ _]*XMDA_END_uri="([^"]*)"[ _]*$/
+	end
+	def writeComment(str,writer)
+		writer.write("#  #{str} ")
+	end
+	def beginMarker(uri,reverse)
+		return %{\n#_XMDA_BEGIN_reverse="#{reverse ? 'yes':'no'}"_uri="#{uri}"\n}
+	end
+	def endMarker(uri)
+		return %{\n#_XMDA_END_uri="#{uri}"\n}
+	end
+end
+FileTypeJavaProperties.instance # register
+
+
+
+
+class FileTypeJSP < FileType
+	include Singleton
+	def initialize(ext=".jsp")
+		super(ext)
+		@re_begin=Regexp.new(/^[ \t]*<%--*[ _]*XMDA[ _]BEGIN[ _]*reverse="(.*)"[ _]uri="(.*)"[ _]*--%>/)
+		@re_end=Regexp.new(/^[ \t]*<%--[ _]*XMDA[ _]END[ _]*uri="(.*)"[ _]*--%>/)
+	end
+	def writeComment(str,writer)
+		writer.write("<%-- #{str} --%>")
+	end
+	def thinLineComment
+		#return context[:thinLineComment,true] ? ('_'*60) : '' 
+		#return "_____________________________________________________________________________________________________________________________________________"
+		return ""
+	end
+	def beginMarker(uri,reverse)
+		return %{\n<%--_XMDA_BEGIN_reverse="#{reverse ? 'yes':'no'}"_#{thinLineComment}uri="#{uri}"_--%>\n}
+	end
+	def endMarker(uri)
+		return %{\n<%--_XMDA_END_#{thinLineComment}uri="#{uri}"_--%>\n}
+	end
+end
+FileTypeJSP.instance # register

data/lib/ontomde-core/helper.rb

@@ -0,0 +1,538 @@
+#:include: ../shared/license.rdoc
+
+require 'fileutils'
+#require 'ontomde-core/exceptions.rb'
+#require 'ontomde-core/fileTypes.rb'
+ 
+class WarningReverseBadOrMissingEnd < Warning
+end
+
+#Internal use.
+class LoadModelLazyWriter
+
+#Internal use.
+	def initialize (fn,ft)
+		@fileName=fn
+		@fileType=ft
+		@model=nil
+		@usedResources=nil
+	end
+	def fileType
+		if @fileType.nil?
+			@fileType=FileType.getFileType(@fileName)
+		end
+		return @fileType
+	end
+
+#Internal use.
+	def protectedMode?
+		return !@model.nil?
+	end	
+		
+	def [](key)
+		if @model.nil?
+			@model=Crdf_Model.new
+			@model.mtk_retrieveProtected(@fileName,fileType)
+		end
+		if @usedResources.nil?
+			@usedResources=Array.new
+		end
+		ret=@model[key]
+		@usedResources << key unless ret.nil?
+		return ret
+	end
+	
+	def unusedData
+		return nil if @model.nil?
+		ret=nil
+		@model.each { |k,c|
+			next if @usedResources.include?(k)
+			# c is either a String or a bootstrap element.
+			next if c.kind_of?(Mrdf_Resource) && c.ext_isBootstrap?
+			ret=Array.new if ret.nil?
+			ret << k
+		}
+		return ret
+	end
+
+end
+module Mmtk_helper
+
+end
+
+module Mrdf_Resource
+	include Mmtk_helper
+end
+
+class Crdf_Model
+include Mmtk_helper
+end
+class Crdf_Resource
+include Mmtk_helper
+end
+
+module Mrdf_Model
+include Mmtk_helper
+end
+module Mmtk_helper
+# Internal use.
+#
+# Used primarily by mtk server
+def mtk_stringWriteSession()
+	fileName=context.get(:mtk_filename)
+	fileName='string-file' if fileName.nil?
+	file=StringOutputStream.new
+
+	ret=nil
+	mtk_context(:mtk_out=>file,:mtk_fileName=>fileName) {
+		@@mtk_out=context[:mtk_out] # perf
+		yield
+		ret=@@mtk_out.to_s
+	}
+	@@mtk_out=context.get(:mtk_out) # perf
+	return ret
+end
+
+#mtk_writeSession temporary file suffix.
+TEMP_FILE_SUFFIX=".xmda_toolkit_temporary"
+
+@@max_file_logged=30
+
+#le fichier fileName a ete genere pour la resource res 
+	attr_reader :fileGenerated
+	#@fileGenerated=Array.new
+	def notifyFileGenerated(fileName,res)
+		#@fileGenerated << [ fileName , res ]
+	end
+
+#Opens a file for writing. 
+#Note: 
+#  Existing file is deleted
+#  Directory are automatically created
+#  Write is atomic. In case of failure existing file is not affected.
+#  The name of the current file is available in context: context[:mtk_fileName]
+#
+# if context[:dryRun] is true, file writes will be skipped. 
+# Note that reverse (file read) **will** be performed however.
+#Example:
+#mtk_writeSession('file1.java') {
+#		write('this goes into file1.java')
+#		mtk_writeSession('file2.java') {
+#			write('this goes into file2.java')
+#			puts context[:mtk_fileName]
+#		}
+#		write('this goes into file1.java')
+#	}
+MTK_WRITE_SESSION_FILE_NAMES=Set.new
+def mtk_writeSession(fileName,fileType=nil)
+	# Open or create session
+	mtk_writeSessionNameClashErrorDetection(fileName.to_s)
+
+	protectedReverse=LoadModelLazyWriter.new(fileName,fileType)
+	FileUtils.mkdir_p(File.dirname(fileName))
+	notifyFileGenerated(File.expand_path(fileName),self)
+
+	doNotOverwrite=mtk_autoNewFileCreationCheck(fileName)
+	if context[:dryRun,false]
+		file=NullFileWriter.instance
+		log.debug { "Simulating Write to #{fileName} (because context[:dryRun]==true)" }
+		mtk_context(:mtk_out=>file,:mtk_fileName=>fileName,:protectedReverse=>protectedReverse) {
+			@@mtk_out=context[:mtk_out] # perf
+			yield
+		}
+		@@mtk_out=context.get(:mtk_out) # perf
+		return 
+	end
+	File.open(fileName+TEMP_FILE_SUFFIX,File::CREAT|File::TRUNC|File::RDWR, 0644) { 
+		|file| 
+		mtk_context(:mtk_out=>file,:mtk_fileName=>fileName,:protectedReverse=>protectedReverse) {
+		log.debug { "Writing #{fileName}" }
+			@@mtk_out=context[:mtk_out] # perf
+			yield 
+		}
+		@@mtk_out=context.get(:mtk_out) # perf
+		}	
+	#Le fichier temporaire a bien �t� g�n�r�.
+	unusedData=protectedReverse.unusedData
+	if(!unusedData.nil?)
+		log.info { "warning: saved code appended to #{fileName}.mtk_save" }
+		msg=""
+		File.open(fileName+".mtk_save",File::CREAT|File::APPEND|File::RDWR, 0644) { |file| 
+			unusedData.each {|k| 
+				msg=msg+%{\n  ** uri="#{k}"}
+				file.write <<END
+//***********************
+//XMDA BEGIN SAVED DATA : uri="#{k}"
+//***********************
+#{protectedReverse[k]}
+//***********************
+//END SAVED DATA
+//***********************
+
+END
+
+		}
+		}
+		if !context[:allowAutomaticCodeDeletion,false]
+			doNotOverwrite=true 
+			log.error { %{
+***************************************************************
+Code generation has been *halted* to prevent code loss in
+     #{fileName}
+
+Code to be deleted is stored in
+     #{fileName}.mtk_save
+
+You must take the appropriate actions before re-running generator.
+* fix your model for unwanted deletion.
+* manually delete unused code for #{msg}
+* rename 
+     #{fileName+TEMP_FILE_SUFFIX} 
+  to
+     #{fileName} 
+#
+***************************************************************
+}}
+			#exit(1)
+		end
+	
+	end
+
+	puts "Writing: #{fileName}" if context[:logFileWrite,false]
+	retryCount=0
+	while true 
+			begin
+				# On some windows machine, 
+				# file is sometimes locked by some management 
+				# daemon (probably some corporate audit daemon)
+				# This cause code generation to fail.
+				# This loop gives the daemon a chance to
+				# unlock the file.
+				# We just wait a few seconds and try again.
+				#raise IOException.new(),"KO" if retryCount<2
+				File.rename(fileName+TEMP_FILE_SUFFIX,fileName)
+				puts "Retry succeeded." if retryCount>0
+				break # exit while
+			rescue   => e
+				retryCount=retryCount+1
+				#log.warn "#{e}"
+				raise e if retryCount > 3 
+				puts "Rename failed. Retrying (#{retryCount})"
+				sleep(2) # 
+			end	
+	end
+	return nil
+end
+
+#checks if fileName already exists
+def mtk_autoNewFileCreationCheck(fileName)
+	doNotOverwrite=!context[:autoNewFileCreation,true] && !File.exists?(fileName)
+	if doNotOverwrite
+		# xmda is not allowed to create new file
+		log.error { %{
+********* NEW FILE DETECTED **********
+** A new file needs to be added to your project:
+** "#{fileName}"
+**
+** Generator has been halted to let 
+** you take proper actions such as:
+**
+**  * Refactor your code if this new file is a renamed file
+**  * Create a blank file and Add this file to version control 
+** 
+** Model Element being processed is:
+** #{mtk_object_message}
+**
+** Model element being processed is related to:
+** #{mtk_related_message}
+********* NEW FILE DETECTED **********
+}}
+	#exit(1)
+	end
+	return doNotOverwrite
+end
+
+#detects if fileName has already been used.
+#Logs an error if a clash is detected.
+def mtk_writeSessionNameClashErrorDetection(fileName)
+	if(MTK_WRITE_SESSION_FILE_NAMES.include?(fileName.to_s)) 
+		log.error{ %{********* NAME CLASH DETECTED ********** #{fileName}
+********* NAME CLASH DETECTED **********
+** This software has detected that a generated file 
+** is being overwritten in the same code generation session.
+** This most likely is caused by a name clash in the source model.
+**
+** Filename being overwritten is 
+** "#{fileName}"
+** Model Element being processed is:
+** #{mtk_object_message}
+**
+** Model element being processed is related to:
+** #{mtk_related_message}
+********* NAME CLASH DETECTED **********
+}}
+	else
+		MTK_WRITE_SESSION_FILE_NAMES<< fileName.to_s
+	end
+	end	
+
+#writes before string, 
+#yield block and then writes after.
+#
+#EXAMPLE.
+# encloseWrite("<title>","</title>") { write "Today news" }
+def encloseWrite(beforeStr,afterStr,&middleBlock)
+		write(beforeStr.to_s)
+		yield
+		write(afterStr.to_s)	
+end
+
+# Write string to the current file opened by mtk_writeSession.
+def write(str)
+	if !@@mtk_out.nil? 
+		@@mtk_out.write(str)
+		return
+	end
+	raise Warning.new(), <<END
+There is no file currently opened.  
+Please use mtk_writeSession prior to using any write method.
+Example:
+#  mtk_writeSession('file1.java') {
+#    write("Package .... ;")
+#       }
+#  }
+END
+end
+
+# Internal use.
+# 
+# Transforms a uri to a uri qualified by the current file name
+def mtk_qualifyBlockURI(_uri)
+	return "#{_uri}__#{context[:mtk_fileName]}"
+end
+
+#def mtk_fileType
+#	fileType=nil
+#	puts "fileType1=#{fileType}"
+#	fileType=context.get(:mtk_fileType)
+#	puts "fileType2=#{fileType}"
+#	fileType=FileType.get(fileName) if fileType.nil?
+#	puts "fileType3=#{fileType}"
+#
+#	#fileType=FileTypeJava.instance
+#	return fileType
+#end
+
+#
+# Internal use.
+#
+# Reverse the file currently being written by mtk_writeSession.
+# This method is automaticaly called
+def mtk_retrieveProtected(fileName,fileType)
+	return false unless File.exists?(fileName)
+
+	mtk_context(:mtk_fileName=>fileName) {
+	File.open(fileName,'r') { |aFile|
+		i=0
+		reading=false
+		block_uri=nil
+		buffer=''
+		reverseMode=nil
+
+		aFile.each_line { |line|
+			i=i+1
+			if !reading
+				#return if !line.include?("PROTECTED REGION XMDA BEGIN") # optimisation ?
+				m=fileType.re_begin.match(line)
+				log.debug {"beg match_ok=#{!m.nil?} line=#{line}"}
+				next if m.nil?
+				#raise Warning.new,"Error Reading Protected region header\n#{fileName}:line #{i}: #{line}" if m.nil?
+				reading=true
+				buffer=''
+				linesep=''
+				block_uri=fileType.unescape(m[2].to_s)
+				log.debug { "ma: #{m[0]} block_uri=#{block_uri}" }
+				raise Warning.new,'Error Reading Protected region header nil uri' if block_uri.nil?
+				case m[1] 
+					when 'yes' then reverseMode=true
+					when 'no'  then reverseMode=false
+				else raise Warning.new,%{Bad reverseMode value in file #{fileName}. reverse="yes" or reverse="no" expected (got "#{m[1]}" line ##{i}).}
+	end
+				raise Warning.new,'Error Reading Protected region header nil uri' if reverseMode.nil? 
+				log.debug { "!!!!!! block_ri=--#{block_uri}--" }
+			else
+				#log.debug "#{reading} line=#{line}"
+				m=fileType.re_end.match(line)
+				#log.debug "end match_ok=#{!m.nil?} line=#{line}"
+				if m.nil?
+					buffer=buffer.nil? ?  line : "#{buffer}#{line}"
+					next
+				end
+				block_uri_end=fileType.unescape(m[1].to_s)
+				if block_uri_end!=block_uri
+					raise WarningReverseBadOrMissingEnd.new, <<ENDERRORMSG
+Bad non matching END tag in  #{fileName} 
+  expected uri="#{block_uri}" 
+  and got  uri="#{block_uri_end}" 
+  line ##{i})
+ENDERRORMSG
+				end
+				reading=false
+				#log.debug "block_uri=#{block_uri} protected ->xxxxxxx\n#{buffer}xxxxxxxxxx"
+				qualified_block_uri=mtk_qualifyBlockURI(block_uri)
+				if reverseMode
+					self[qualified_block_uri]=buffer[0,buffer.size-1]
+				else
+					#log.debug "Reverse ignored #{context[:mtk_fileName]}!"
+				end
+			end
+
+		}
+	}}
+	return true # un fichier a ete retro
+end
+end
+
+#module Mrdf_Resource
+#end
+module Mmtk_helper #_Resource
+REVERSE=true
+NOREVERSE=false
+
+# mtk_protected is used when generated code can be modified by user and preserved by subsequent generation.
+# The code generated in the block passed as parameter will be generated encolosed between identifiable tags.
+# 
+# NOTE:
+#    The block is identified by the current rdf resource URI.
+#    If more than one block is to be generated in one file, zoneId must be used.
+#
+#
+#
+#
+#Example 1: default 
+#  mtk_writeSession('file1.java') {
+#    write("Package .... ;")
+#    a.mtk_protected() {
+#       write("default code to be redefined by user");
+#       }
+#    b.mtk_protected() {
+#       write("default code to be redefined by user");
+#       }
+#  }
+#Example 2: initial mode is reverse 
+#  mtk_writeSession('file1.java') {
+#    write("Package .... ;")
+#    mtk_protected(REVERSE) {
+#       write("default code to be redefined by user");
+#       }
+#  }
+#Example 3: initial mode is noreverse 
+#  mtk_writeSession('file1.java') {
+#    write("Package .... ;")
+#    mtk_protected(NOREVERSE) {
+#      write("default code to be redefined by user");
+#      }
+#  }
+#Example 4: multiple-protected zone for a single object
+#  mtk_writeSession('file1.java') {
+#    write("Package .... ;")
+#    a.mtk_protected(REVERSE,"a") {
+#       write("default code to be redefined by user");
+#       }
+#    a.mtk_protected(REVERSE,"b") {
+#       write("default code to be redefined by user");
+#       }
+#  }
+def mtk_protected(initialReverseMode=false,zoneId='0',&block)
+	#mbu=mtk_block_uri
+	mbu="#{rdf_uri}__#{zoneId}"
+	qualified_uri=rdf_model.mtk_qualifyBlockURI(mbu)
+	
+	fileType=context[:protectedReverse].fileType
+	str=context[:protectedReverse][qualified_uri]
+
+	reverse= (!str.nil?) || initialReverseMode
+
+	write(fileType.beginMarker(mbu,reverse))
+	
+	if str.nil?
+		#log.debug "!!yield block_uri=#{mbu}"
+		yield
+	else
+		write(str)
+	end
+	write(fileType.endMarker(mbu))
+end	
+
+#Stream to String Session
+def mtk_stss(&block)
+	#@rdf_model.mtk_stringWriteSession(&block)
+	mtk_stringWriteSession(&block)
+end
+
+#internal method.
+#
+#Returns file descriptor currently used by mtk_writeSession.
+def mtk_out
+	return context[:mtk_out]
+end
+
+end
+
+#Internal use.
+#
+#Used by mtk_stringWriteSession.
+class StringOutputStream 
+def initialize
+	@str=nil
+end
+
+# Internal use.
+#
+# Simulates file open
+def open ; end
+
+# Internal use.
+#
+# Simulates file open
+def close ; end
+
+# Internal use.
+#
+# Appends str to internal steam buffer
+def write (str)
+	#log.debug "Ajout #{str.to_s} !!"
+	if @str
+		@str="#{@str}#{str.to_s}"
+	else
+		@str=str.to_s
+	end
+end
+
+# Internal use.
+# returns the internal stream buffer
+def to_s
+	return @str
+end
+end
+
+
+
+module Mcore_Product
+end
+
+class Ccore_Product < Crdfs_Class
+	include Mcore_Product
+	def generate
+	end
+	
+end
+
+# a file writer that writes nowhere
+class NullFileWriter
+	include Singleton
+	def write(str)
+		# does nothing ! 
+	end
+end
+