cosmos/lib/cosmos/tools/table_manager/table_config.rb
# encoding: ascii-8bit
# Copyright 2022 Ball Aerospace & Technologies Corp.
# All Rights Reserved.
#
# This program is free software; you can modify and/or redistribute it
# under the terms of the GNU Affero General Public License
# as published by the Free Software Foundation; version 3 with
# attribution addendums as found in the LICENSE.txt
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# This program may also be used under the terms of a commercial or
# enterprise edition license of COSMOS if purchased from the
# copyright holder
require 'cosmos/config/config_parser'
require 'cosmos/packets/packet_config'
require 'cosmos/tools/table_manager/table'
require 'cosmos/tools/table_manager/table_parser'
require 'cosmos/tools/table_manager/table_item_parser'
module Cosmos
# Processes the Table Manager configuration files which define tables. Since
# this class inherits from {PacketConfig} it only needs to implement Table
# Manager specific keywords. All tables are accessed through the table
# and tables methods.
class TableConfig < PacketConfig
# @return [String] Table configuration filename
attr_reader :filename
def self.process_file(filename)
instance = self.new()
instance.process_file(filename)
instance
end
# Create the table configuration
def initialize
super
# Override commands with the Table::TARGET name to store tables
@commands[Table::TARGET] = {}
@definitions = {}
@last_config = [] # Stores array of [filename, contents]
end
# @return [Array<Table>] All tables defined in the configuration file
def tables
@commands[Table::TARGET]
end
# @return [String] Table definition for the specific table
def definition(table_name)
@definitions[table_name.upcase]
end
# @return [Array<String>] All the table names
def table_names
tables.keys
end
# @param table_name [String] Table name to return
# @return [Table]
def table(table_name)
tables[table_name.upcase]
end
# Processes a COSMOS table configuration file and uses the keywords to build up
# knowledge of the tables.
#
# @param filename [String] The name of the configuration file
def process_file(filename)
# Partial files are included into another file and thus aren't directly processed
return if File.basename(filename)[0] == '_' # Partials start with underscore
@filename = filename
@last_config = [File.basename(filename), File.read(filename)]
@converted_type = nil
@converted_bit_size = nil
@proc_text = ''
@building_generic_conversion = false
@defaults = []
parser =
ConfigParser.new(
'https://ballaerospace.github.io/cosmos-website/docs/tools/#table-manager-configuration-cosmos--39',
)
parser.parse_file(filename) do |keyword, params|
if @building_generic_conversion
case keyword
# Complete a generic conversion
when 'GENERIC_READ_CONVERSION_END', 'GENERIC_WRITE_CONVERSION_END'
parser.verify_num_parameters(0, 0, keyword)
@current_item.read_conversion =
GenericConversion.new(
@proc_text,
@converted_type,
@converted_bit_size,
) if keyword.include? 'READ'
@current_item.write_conversion =
GenericConversion.new(
@proc_text,
@converted_type,
@converted_bit_size,
) if keyword.include? 'WRITE'
@building_generic_conversion = false
# Add the current config.line to the conversion being built
else
@proc_text << parser.line << "\n"
end # case keyword
else
# not building generic conversion
case keyword
when 'TABLEFILE'
usage = "#{keyword} <File name>"
parser.verify_num_parameters(1, 1, usage)
table_filename = File.join(File.dirname(filename), params[0])
unless File.exist?(table_filename)
raise parser.error(
"Table file #{table_filename} not found",
usage,
)
end
process_file(table_filename)
when 'TABLE'
finish_packet
@current_packet =
TableParser.parse_table(parser, @commands, @warnings)
@definitions[@current_packet.packet_name] = @last_config
@current_cmd_or_tlm = COMMAND
@default_index = 0
# Select an existing table for editing
when 'SELECT_TABLE'
usage = "#{keyword} <TABLE NAME>"
finish_packet
parser.verify_num_parameters(1, 1, usage)
table_name = params[0].upcase
@current_packet = table(table_name)
unless @current_packet
raise parser.error("Table #{table_name} not found", usage)
end
#######################################################################
# All the following keywords must have a current packet defined
#######################################################################
when 'SELECT_PARAMETER', 'PARAMETER', 'ID_PARAMETER',
'ARRAY_PARAMETER', 'APPEND_PARAMETER', 'APPEND_ID_PARAMETER',
'APPEND_ARRAY_PARAMETER', 'ALLOW_SHORT', 'HAZARDOUS',
'PROCESSOR', 'META', 'DISABLE_MESSAGES', 'DISABLED'
unless @current_packet
raise parser.error("No current packet for #{keyword}")
end
process_current_packet(parser, keyword, params)
#######################################################################
# All the following keywords must have a current item defined
#######################################################################
when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION',
'POLY_READ_CONVERSION', 'POLY_WRITE_CONVERSION',
'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION',
'GENERIC_READ_CONVERSION_START',
'GENERIC_WRITE_CONVERSION_START', 'REQUIRED', 'LIMITS',
'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION',
'HIDDEN', 'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE',
'OVERFLOW', 'UNEDITABLE'
unless @current_item
raise parser.error("No current item for #{keyword}")
end
process_current_item(parser, keyword, params)
when 'DEFAULT'
if params.length != @current_packet.sorted_items.length
raise parser.error("DEFAULT #{params.join(' ')} length of #{params.length} doesn't match item length of #{@current_packet.sorted_items.length}")
end
@defaults.concat(params)
else
# blank config.lines will have a nil keyword and should not raise an exception
raise parser.error("Unknown keyword '#{keyword}'") if keyword
end # case keyword
end
end
# Complete the last defined packet
finish_packet
end
# (see PacketConfig#process_current_packet)
def process_current_packet(parser, keyword, params)
super(parser, keyword, params)
rescue => err
if err.message.include?('not found')
raise parser.error(
"#{params[0]} not found in table #{@current_packet.table_name}",
'SELECT_PARAMETER <PARAMETER NAME>',
)
else
raise err
end
end
# Overridden method to handle the unique table item parameters: UNEDITABLE
# and HIDDEN.
# (see PacketConfig#process_current_item)
def process_current_item(parser, keyword, params)
super(parser, keyword, params)
case keyword
when 'UNEDITABLE'
usage = "#{keyword}"
parser.verify_num_parameters(0, 0, usage)
@current_item.editable = false
when 'HIDDEN'
usage = "#{keyword}"
parser.verify_num_parameters(0, 0, usage)
@current_item.hidden = true
end
end
# (see PacketConfig#start_item)
def start_item(parser)
finish_item
@current_item = TableItemParser.parse(parser, @current_packet, @warnings)
end
# If the table is ROW_COLUMN all currently defined items are
# duplicated until the specified number of rows are created.
def finish_packet
if @current_packet
warnings = @current_packet.check_bit_offsets
if warnings.length > 0
raise "Overlapping items not allowed in tables.\n#{warnings}"
end
if @current_packet.type == :ROW_COLUMN
items = @current_packet.sorted_items.clone
(@current_packet.num_rows - 1).times do |row|
items.each do |item|
new_item = item.clone
new_item.name = "#{new_item.name[0...-1]}#{row + 1}"
@current_packet.append(new_item)
end
end
end
unless @defaults.empty?
@current_packet.sorted_items.each_with_index do |item, index|
case item.data_type
when :INT, :UINT
begin
# Integer handles hex strings, e.g. 0xDEADBEEF
item.default = Integer(@defaults[index])
rescue ArgumentError
value = item.states[@defaults[index]]
if value
item.default = value
else
raise "Unknown DEFAULT #{@defaults[index]} for item #{item.name}. Valid states are #{item.states.keys.join(', ')}."
end
end
when :FLOAT
item.default = @defaults[index].to_f
when :STRING, :BLOCK
item.default = @defaults[index]
end
end
end
end
super()
end
end
end