Module: LightModels::Serialization

Defined in:
lib/lightmodels/serialization.rb

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.next_serialization_id ⇒ Object

Returns the value of attribute next_serialization_id.



16
17
18
 
# File 'lib/lightmodels/serialization.rb', line 16

def next_serialization_id
  @next_serialization_id
end

.serialization_ids ⇒ Object (readonly)

Returns the value of attribute serialization_ids.



15
16
17
 
# File 'lib/lightmodels/serialization.rb', line 15

def serialization_ids
  @serialization_ids
end

Class Method Details

.eobject_to_model(root, adapters = {}) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/lightmodels/serialization.rb', line 142

def self.eobject_to_model(root,adapters={})
	@serialization_ids = {}
	@next_serialization_id = 1

	model = {}
	external_elements = if root.eResource
		root.eResource.contents.select {|e| e!=root}
	else
		[]
	end

	model['root'] = jsonize_obj(root,adapters)
	model['external_elements'] = []
	external_elements.each do |ee|
		model['external_elements'] << jsonize_obj(ee)
	end
	model
end

.jsonize_attr_value(map, e_object, e_attr) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/lightmodels/serialization.rb', line 37

def self.jsonize_attr_value(map,e_object,e_attr)
	if e_object.respond_to? :eGet
		value = e_object.eGet e_attr
	else
		value = e_object.send e_attr.name.to_sym
	end
	if e_attr.upperBound==1
		map["attr_#{e_attr.name}"] = value
	else
		l = []
		(0..(value.size-1)).each do |i|
			l << value.get(i)
		end
		map["attr_#{e_attr.name}"] = l
	end
end

.jsonize_obj(e_object, adapters = {}) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/lightmodels/serialization.rb', line 87

def self.jsonize_obj(e_object, adapters={})
	if not e_object
		nil
	else 
		map = { 'type' => qname(e_object), 'id' => serialization_id(e_object) }
		if e_object.respond_to? :eClass
			e_class = e_object.eClass			
		else
			e_class = e_object.class.ecore
		end
		e_class.eAllAttributes.each do |a|		
			jsonize_attr_value(map,e_object,a)
		end
		e_class.eAllReferences.each do |r|
			#puts "ref #{r.name} #{r.containment}"
			jsonize_ref_value(map,e_object,r,adapters)
		end
		if adapters.has_key? qname(e_object)
			adapters[qname(e_object)].adapt(e_object,map)
		end
		map
	end
end

.jsonize_ref_single_el(single_value, containment, adapters) ⇒ Object 



54
55
56
57
58
59
60
 
# File 'lib/lightmodels/serialization.rb', line 54

def self.jsonize_ref_single_el(single_value,containment,adapters)
	if containment
		jsonize_obj(single_value,adapters)
	else
		serialization_id(single_value)
	end
end

.jsonize_ref_value(map, e_object, e_ref, adapters) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/lightmodels/serialization.rb', line 62

def self.jsonize_ref_value(map,e_object,e_ref,adapters)
	if e_object.respond_to? :eGet
		value = e_object.eGet e_ref
	else
		value = e_object.send e_ref.name.to_sym
	end

	propname = "relcont_#{e_ref.name}" if e_ref.containment
	propname = "relnoncont_#{e_ref.name}" if not e_ref.containment

	if e_ref.upperBound==1		
		map[propname] = jsonize_ref_single_el(value,e_ref.containment,adapters)
	else
		l = []
		(0..(value.size-1)).each do |i|
			if value.is_a? Array
				l << jsonize_ref_single_el(value.at(i),e_ref.containment,adapters)
			else
				l << jsonize_ref_single_el(value.get(i),e_ref.containment,adapters)
			end
		end
		map[propname] = l
	end
end

.load_file(path, max_nesting = 500) ⇒ Object 



111
112
113
 
# File 'lib/lightmodels/serialization.rb', line 111

def self.load_file(path,max_nesting=500)
	JSON.parse(File.read(path),{max_nesting: max_nesting})
end

.load_models_from_dir(dir, verbose = false, max = -1)) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/lightmodels/serialization.rb', line 115

def self.load_models_from_dir(dir,verbose=false,max=-1)
	per_type_values_map = Hash.new do |pt_hash,pt_key|	
		pt_hash[pt_key] = Hash.new do |pa_hash,pa_key|
			pa_hash[pa_key] = CountingMap.new
		end
	end

	n = 0
	files = Dir[dir+'/**/*.json']
	files = files[0..(max-1)] if max!=-1
	files.each do |f|
		n+=1
		puts "...#{n}) #{f}" if verbose
		model = ::JSON.load_file(f,max_nesting=500)
		EMF.traverse(model) do |n|
			if n
				puts "\tnode: #{n['type']}" if verbose
				EMF.attrs(n).each do |a|
					puts "\t\tattr: #{a}" if verbose
					per_type_values_map[n['type']][a].inc(n[a])
				end
			end
		end
	end
	per_type_values_map
end

.qname(e_object) ⇒ Object 



27
28
29
30
31
32
33
34
35
 
# File 'lib/lightmodels/serialization.rb', line 27

def self.qname(e_object)
	if e_object.respond_to? :eClass 
		e_class = e_object.eClass
		e_package = e_class.ePackage
		"#{e_package.nsURI}##{e_class.name}"
	else
		e_object.class.to_s
	end
end

.rgenobject_to_model(root, adapters = {}) ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/lightmodels/serialization.rb', line 161

def self.rgenobject_to_model(root,adapters={})
	@serialization_ids = {}
	@next_serialization_id = 1

	model = {}
	external_elements = []

	model['root'] = jsonize_obj(root,adapters)
	model['external_elements'] = []
	external_elements.each do |ee|
		model['external_elements'] << jsonize_obj(ee)
	end
	model
end

.save_as_model(root, model_path) ⇒ Object 



176
177
178
179
 
# File 'lib/lightmodels/serialization.rb', line 176

def self.save_as_model(root,model_path)
	model = to_model(root)
	save_model(model,model_path)
end

.save_model(model, model_path, max_nesting = 500) ⇒ Object 



181
182
183
184
185
186
187
188
 
# File 'lib/lightmodels/serialization.rb', line 181

def self.save_model(model,model_path, max_nesting=500)
	dir = File.dirname(model_path)
	FileUtils.mkdir_p(dir) 

	File.open(model_path, 'w') do |file| 		
		file.write(JSON.pretty_generate(model, :max_nesting => max_nesting))
	end
end

.serialization_id(obj) ⇒ Object 



19
20
21
22
23
24
25
 
# File 'lib/lightmodels/serialization.rb', line 19

def self.serialization_id(obj)
	unless LightModels::Serialization.serialization_ids[obj]		
		LightModels::Serialization.serialization_ids[obj] = LightModels::Serialization.next_serialization_id
		LightModels::Serialization.next_serialization_id += 1
	end
	LightModels::Serialization.serialization_ids[obj]
end