Class: Sbuilder::SymbolTable

Inherits:
Object
  • Object
show all
Includes:
Utils::MyLogger
Defined in:
lib/sbuilder/symbol_table.rb

Constant Summary collapse

PROGNAME =

Logger

nil

Constants included from Utils::MyLogger

Utils::MyLogger::LOGFILE

Instance Attribute Summary collapse

Construct & configure collapse

Build symbol table collapse

Use symbol table collapse

Methods included from Utils::MyLogger

#getLogger, #logfile

Constructor Details

#initialize(options = {}) ⇒ SymbolTable 



32
33
34
35
36
37
38
 
# File 'lib/sbuilder/symbol_table.rb', line 32

def initialize( options = {} )
  @logger = getLogger( PROGNAME, options )
  @logger.info( "#{__method__} initialized" )

  @types = {}
  @table = {}
end

Instance Attribute Details

#table ⇒ Object (readonly) 



20
21
22
 
# File 'lib/sbuilder/symbol_table.rb', line 20

def table
  @table
end

#types ⇒ Object (readonly) Also known as: metatypes 



11
12
13
 
# File 'lib/sbuilder/symbol_table.rb', line 11

def types
  @types
end

Instance Method Details

#addSymbol(metatype, app, spec) ⇒ Object

Add ‘spec’ symbol of ‘type’ for ‘app’. Issue a warning if ‘type’ is undefined, or if ‘type’, ‘spec’ is redefined.

is associated

Parameters:

  • metatype (String) —

    of previsously defined metatype

  • spec (String) —

    name in specifcation domain

  • app (String) —

    name in application domain where ‘spec’ name



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/sbuilder/symbol_table.rb', line 96

def addSymbol( metatype, app, spec )

  # ------------------------------------------------------------------
  # Unknown metatype

  if types[metatype].nil? then
    typeDesc = "Unknown metatype '#{metatype}' encountered when mapping #{app} -> #{spec}"
    
    msg= <<-EOS
    #{typeDesc}
    
    use #{self.class.name}#defineMetaType(symbol) -method to define metatypes before adding
    symbols using  #{self.class.name}#addSymbol -method.

    EOS
    # warn msg
    @logger.error "#{__method__}: #{msg}"
    raise SymbolTableException.new msg                
  end
  
  # Init  hash to map appName -> specName
  table[metatype] = table[metatype] || {}

  # ------------------------------------------------------------------
  # Check for alias definition for specName

  # turn table outsize in:  specName -> [metatype,appName]
  specName2metatype_appName = table.inject( {} ) {|memo,(m,ah)|
    ah.each { |a,s|
      memo[s] = [m,a]
    }
    memo
  }

  # ------------------------------------------------------------------
  # error on aliased definition
  # if specName2metatype_appName[spec] && specName2metatype_appName[spec] != [metatype,app]
  #   msg = specNameAliasedMessage( metatype, app, *specName2metatype_appName[spec], spec )
  #   @logger.error "#{__method__} #{msg}"
  #   raise SymbolTableException.new msg
  # end

  # ------------------------------------------------------------------
  # Warn on duplicate definition
  if table[metatype][app] && table[metatype][app] != spec
    msg = specNameRerefined( metatype, app, table[metatype][app], spec )
    @logger.error "#{__method__}: #{msg}"
    raise SymbolTableException.new msg        
  end
  

  # ------------------------------------------------------------------
  # Warn on duplicate definition
  if ! table[metatype][app].nil?
    msg = "Duplicate symbol definition #{metatype}:#{spec}" 
    warn msg
    @logger.warn "#{__method__}: #{msg}"
  end

  # ------------------------------------------------------------------
  # Here normal add
  @logger.info "#{__method__} added metatype '#{metatype}', name in spec-domain: '#{spec}',  name in app domain: '#{app}'"
  
  table[metatype][app] = spec
end

#defineMetaType(symbol) ⇒ Object

Add type names to symbol table so that we can issue a warning if unknon symbol types are entered

Parameters:

  • symbol (Hash) —

    name to add

Options Hash (symbol):

  • :name (String) —

    of symbol to define

  • :desc (String) —

    description of symbol to define



53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/sbuilder/symbol_table.rb', line 53

def defineMetaType( symbol )
  @logger.info "#{__method__}: #{symbol}"

  # symbol[:name ]  = symbol[:name ]
  symbol[:prefix] = symbol[:prefix] || generatePrefix()
  
  types[symbol[:name]] = symbol
  
  # Initialize empty hash to store appName->specName mappings
  table[symbol[:name]] = table[symbol[:name]] || {}
end

#getMetaTypeDefinition(metatype) ⇒ String

Returns definition of metatype, nil if not found.

Returns:

  • (String) —

    definition of metatype, nil if not found



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/sbuilder/symbol_table.rb', line 173

def getMetaTypeDefinition( metatype )
  ret = types[metatype]

  if ret.nil?
    msg= <<-EOS
    Metatype definition for metatype '#{metatype}' not found.

    Known metatypes are: #{types.keys.join( ', ')}

    EOS
    # warn msg
    @logger.error "#{__method__}: #{msg}"
    raise SymbolTableException.new msg                

  end
  ret

end

#getMetaTypeDescription(metatype) ⇒ String

Returns definition of metatype.

Returns:

  • (String) —

    definition of metatype



168
169
170
 
# File 'lib/sbuilder/symbol_table.rb', line 168

def getMetaTypeDescription( metatype )
  getMetaTypeDefinition( metatype )[:desc]
end

#lookupSymbol(appName, metatype) ⇒ Object

Return ‘spec’ -name identified by ‘app’/‘type’ combination

is associated

Parameters:

  • app (String) —

    name in application domain where ‘spec’ name

  • type (String) —

    of previsously defined type



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/sbuilder/symbol_table.rb', line 204

def lookupSymbol( appName, metatype  )

  # Find specname (raise exceptio if metatype not found )
  specName =  getMetaTypeHash( metatype, appName )[appName]

  # Valid spec-name found
  if specName.nil? then
    msg=<<-EOS
    Unknown name '#{appName}' in metatype '#{metatype}'

    Valid app-names in meta-type '#{metatype}' are: #{table[metatype].keys.join(', ')}
    EOS
    @logger.error msg
    raise SymbolTableException.new msg
    
  end
  specName
    
end