anthill_smpp_ruby 0.5.1

data/lib/smpp_csv_outputter.rb

@@ -0,0 +1,1601 @@
+#
+#   Copyright 2007 Majoron.com (developers@majoron.com)
+#   Original sources are available at www.majoron.com
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+
+module Majoron
+
+  module AntHill
+  	module SMPP
+  		class SMPPCSVOutputter < AntHill::TxtOutputter
+  			include SMPPOutputterBase
+
+
+  			def initialize(ostream, showesm = true, showfmt = true)
+  				super(ostream)
+  				initialize_smpp_outputter_base()
+  				@show_esminfo = showesm
+  				@show_fmtinfo = showfmt
+  			end
+
+
+  			# Output header
+  			def output_header(header)
+  				command_name = get_command_name(header.command_id())
+  				error_name = get_error_name(header.command_status())
+
+  				# Output command lengtht
+  				ostream << Outputter::HEADER << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::COMMAND_LENGTH
+  				ostream << Outputter::SEPARATOR << header.command_length().to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_unsigned32(header.command_length())
+  				byte_buffer1 = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer1.write_dump(ostream)
+  				ostream << "\n"
+
+  				# Output command id
+  				ostream << Outputter::HEADER << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::COMMAND_ID
+  				ostream << Outputter::SEPARATOR << Outputter::HEXSIGN
+  				ostream << sprintf("%X", header.command_id()) << Outputter::EQUAL
+  				ostream << command_name << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_unsigned32(header.command_id())
+  				byte_buffer2 = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer2.write_dump(ostream)
+  				ostream << "\n"
+
+  				# Output command status
+  				ostream << Outputter::HEADER << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::COMMAND_STATUS
+  				ostream << Outputter::SEPARATOR << header.command_status().to_s
+  				ostream << Outputter::EQUAL << error_name << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_unsigned32(header.command_status())
+  				byte_buffer3 = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer3.write_dump(ostream)
+  				ostream << "\n"
+
+  				# Output sequence number
+  				ostream << Outputter::HEADER << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SEQUENCE_NUMBER
+  				ostream << Outputter::SEPARATOR << header.sequence_number().to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_unsigned32(header.sequence_number())
+  				byte_buffer4 = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer4.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			# Output mandatory fields
+  			def output_system_id(system_id)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SYSTEM_ID
+  				ostream << Outputter::SEPARATOR << system_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_system_id(system_id)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_password(password)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::PASSWORD
+  				ostream << Outputter::SEPARATOR << password.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_password(password)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_system_type(system_type)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SYSTEM_TYPE
+  				ostream << Outputter::SEPARATOR << system_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_system_type(system_type)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_interface_version(interface_version)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::INTERFACE_VERSION
+  				ostream << Outputter::SEPARATOR << Outputter::HEXSIGN
+  				ostream << sprintf("%X", interface_version) << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_interface_version(interface_version)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_addr_ton(addr_ton)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ADDR_TON
+  				ostream << Outputter::SEPARATOR << addr_ton.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_addr_ton(addr_ton)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_addr_npi(addr_npi)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ADDR_NPI
+  				ostream << Outputter::SEPARATOR << addr_npi.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_addr_npi(addr_npi)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_address_range(address_range)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ADDRESS_RANGE
+  				ostream << Outputter::SEPARATOR << address_range.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_address_range(address_range)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_service_type(service_type)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SERVICE_TYPE
+  				ostream << Outputter::SEPARATOR << service_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_service_type(service_type)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_addr_ton(addr_ton)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_ADDR_TON
+  				ostream << Outputter::SEPARATOR << addr_ton.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_addr_ton(addr_ton)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_addr_npi(addr_npi)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_ADDR_NPI
+  				ostream << Outputter::SEPARATOR << addr_npi.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_addr_npi(addr_npi)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_addr21(source_addr)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_ADDR
+  				ostream << Outputter::SEPARATOR << source_addr.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_addr21(source_addr)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_addr65(source_addr)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_ADDR
+  				ostream << Outputter::SEPARATOR << source_addr.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_addr65(source_addr)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_addr_ton(dest_addr_ton)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR_TON
+  				ostream << Outputter::SEPARATOR << dest_addr_ton.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_addr_ton(dest_addr_ton)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_addr_npi(dest_addr_npi)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR_NPI
+  				ostream << Outputter::SEPARATOR << dest_addr_npi.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_addr_npi(dest_addr_npi)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_addr21(dest_addr)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << dest_addr.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_addr21(dest_addr)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_addr65(dest_addr)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << dest_addr.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_addr65(dest_addr)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_esm_class(esm_class)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << esm_class.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_esm_class(esm_class)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_protocol_id(protocol_id)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << protocol_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_protocol_id(protocol_id)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_priority_flag(priority_flag)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << priority_flag.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_priority_flag(priority_flag)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_schedule_delivery_time(schedule_delivery_time)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SCHEDULE_DELIVERY_TIME
+  				ostream << Outputter::SEPARATOR << schedule_delivery_time.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_schedule_delivery_time(schedule_delivery_time)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_validity_period(validity_period)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::VALIDITY_PERIOD
+  				ostream << Outputter::SEPARATOR << validity_period.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_validity_period(validity_period)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_registered_delivery(registered_delivery)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::REGISTERED_DELIVERY
+  				ostream << Outputter::SEPARATOR << registered_delivery.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_registered_delivery(registered_delivery)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_replace_if_present_flag(replace_if_present_flag)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << replace_if_present_flag.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_replace_if_present_flag(replace_if_present_flag)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_data_coding(data_coding)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR
+  				ostream << Outputter::SEPARATOR << data_coding.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_data_coding(data_coding)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_sm_default_msg_id(sm_default_msg_id)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SM_DEFAULT_MSG_ID
+  				ostream << Outputter::SEPARATOR << sm_default_msg_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_sm_default_msg_id(sm_default_msg_id)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_sm_length(sm_length)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SM_LENGTH
+  				ostream << Outputter::SEPARATOR << sm_length.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_sm_length(sm_length)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_short_message(short_message)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::SHORT_MESSAGE
+  				ostream << Outputter::SEPARATOR
+  				if !short_message.nil?
+  					buffer = AntHill::ByteBuffer.new(short_message)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_short_message(short_message)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_message_id(message_id)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::MESSAGE_ID
+  				ostream << Outputter::SEPARATOR << message_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_message_id(message_id)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_esme_addr_ton(esme_addr_ton)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ESME_ADDR_TON
+  				ostream << Outputter::SEPARATOR << esme_addr_ton.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_esme_addr_ton(esme_addr_ton)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_esme_addr_npi(esme_addr_npi)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ESME_ADDR_NPI
+  				ostream << Outputter::SEPARATOR << esme_addr_npi.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_esme_addr_npi(esme_addr_npi)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_esme_addr(esme_addr)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ESME_ADDR
+  				ostream << Outputter::SEPARATOR << esme_addr.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_esme_addr(esme_addr)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_number_of_dest(number_of_dest)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::NUMBER_OF_DEST
+  				ostream << Outputter::SEPARATOR << number_of_dest.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_number_of_dest(number_of_dest)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_addresses(dest_addresses)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDRESSES
+  				ostream << Outputter::SEPARATOR
+
+  				0.upto(dest_addresses.size() -1) do |i|
+  					# Output destination address
+  					ostream << Outputter::LCURLYBRACE if i == 0
+  					ostream << Outputter::LBRACKET << FieldsName::DESTFLAG
+  					ostream << Outputter::COLON << Outputter::SPACE
+  					ostream << dest_addresses[i].dest_flag()
+  					case dest_addresses[i].dest_flag()
+  						when DestFlag::SME_ADDRESS
+  							ostream << Outputter::SPACE << FieldsName::TON
+  							ostream << Outputter::COLON << Outputter::SPACE
+  							ostream << dest_addresses[i].address.ton()
+  							ostream << Outputter::SPACE << FieldsName::NPI
+  							ostream << Outputter::COLON << Outputter::SPACE
+  							ostream << dest_addresses[i].address.npi()
+  							ostream << Outputter::SPACE << FieldsName::ADDRESS
+  							ostream << Outputter::COLON << Outputter::SPACE
+  							ostream << dest_addresses[i].address.address()
+  						when DestFlag::DISTR_LIST_NAME
+  							ostream << Outputter::SPACE << FieldsName::DISTR_LIST_NAME
+  							ostream << Outputter::COLON << Outputter::SPACE
+  							ostream << dest_addresses[i].distr_list_name()
+  						else
+  							ostream << Outputter::SPACE << FieldsName::INV_DEST_FLAG
+  							ostream << Outputter::SPACE
+  					end
+  					ostream << Outputter::RBRACKET
+
+  					#Next or last element
+  					if i != dest_addresses.size() - 1
+  						ostream << Outputter::COMMA
+  					else
+  						ostream << Outputter::RCURLYBRACE
+  					end
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_addresses(dest_addresses)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_no_unsuccess(no_unsuccess)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::NO_UNSUCCESS
+  				ostream << Outputter::SEPARATOR << no_unsuccess.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_no_unsuccess(no_unsuccess)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_unsuccess_smes(unsuccess_smes)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::UNSUCCESS_SMES
+  				ostream << Outputter::SEPARATOR
+
+  				0.upto(unsuccess_smes.size() -1) do |i|
+  					# Output destination address
+  					ostream << Outputter::LCURLYBRACE if i == 0
+  					ostream << Outputter::LBRACKET << FieldsName::ERROR_STATUS_CODE
+  					ostream << Outputter::COLON << Outputter::SPACE
+  					ostream << unsuccess_smes[i].error_status_code.to_s
+
+  					ostream << Outputter::SPACE << FieldsName::TON
+  					ostream << Outputter::COLON << Outputter::SPACE
+  					ostream << unsuccess_smes[i].sme_address().ton()
+  					ostream << Outputter::SPACE << FieldsName::NPI
+  					ostream << Outputter::COLON << Outputter::SPACE
+  					ostream << unsuccess_smes[i].sme_address().npi()
+  					ostream << Outputter::SPACE << FieldsName::NPI
+  					ostream << Outputter::COLON << Outputter::SPACE
+  					ostream << unsuccess_smes[i].sme_address().address()
+  					ostream << Outputter::RBRACKET
+
+  					#Next or last element
+  					if i != unsuccess_smes.size() - 1
+  						ostream << Outputter::COMMA
+  					else
+  						ostream << Outputter::RCURLYBRACE
+  					end
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_unsuccess_smes(unsuccess_smes)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_final_date(final_date)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::FINAL_DATE
+  				ostream << Outputter::SEPARATOR << final_date.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_final_date(final_date)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_message_state(message_state)
+  				message_state_name = get_message_state_name(message_state)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ERROR_CODE
+  				ostream << Outputter::SEPARATOR << message_state.to_s
+  				ostream << Outputter::EQUAL << message_state_name
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_message_state(message_state)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_error_code(error_code)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR
+  				ostream << Outputter::SEPARATOR << FieldsName::ERROR_CODE
+  				ostream << Outputter::SEPARATOR << error_code.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_error_code(error_code)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_message_state_tlv(message_state, len)
+  				message_state_name = get_message_state_name(message_state)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::MESSAGE_STATE
+  				ostream << Outputter::SEPARATOR << message_state.to_s
+  				ostream << Outputter::EQUAL << message_state_name
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_message_state_tlv(message_state, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_area_identifier(broadcast_area_identifier, len)
+  				0.upto(broadcast_area_identifier.size() -1) do | i |
+  					# Output field
+  					ostream << Outputter::MANDATORY << Outputter::SEPARATOR << len[i].to_s
+  					ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_AREA_IDENTIFIER
+  					ostream << Outputter::SEPARATOR
+
+
+  					if broadcast_area_identifier[i].value().size()
+  						buffer = AntHill::ByteBuffer.new(broadcast_area_identifier[i].value())
+  						buffer.write_dump(ostream)
+
+  						if @show_fmtinfo
+                area_format_code = 0
+                if RUBY_VERSION >= "1.9.0"
+                  area_format_code = broadcast_area_identifier[i].value()[0].ord
+                else
+                  area_format_code = broadcast_area_identifier[i].value()[0]
+                end
+  							# area_format_code = broadcast_area_identifier[i].value()[0]
+  							area_format_name = get_area_format_name(area_format_code)
+  							ostream << sprintf("%s%d", Outputter::COMMA, area_format_code)
+  							ostream << sprintf("%s%s", Outputter::EQUAL, area_format_name)
+  						end
+  					end
+  					ostream << Outputter::SEPARATOR
+
+
+  					encoder.reset_buffer()
+  					encoder.encode_broadcast_area_identifier_single(broadcast_area_identifier[i], len[i])
+  					byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  					byte_buffer.write_dump(ostream)
+  					ostream << "\n"
+  				end
+  			end
+
+  			def output_broadcast_rep_num(broadcast_rep_num, len)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_REP_NUM
+  				ostream << Outputter::SEPARATOR << broadcast_rep_num.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_rep_num(broadcast_rep_num, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_frequency_interval(broadcast_frequency_interval, len)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_FREQUENCY_INTERVAL
+  				ostream << Outputter::SEPARATOR
+  				if !broadcast_frequency_interval.nil?
+  					buffer = AntHill::ByteBuffer.new(broadcast_frequency_interval)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_frequency_interval(broadcast_frequency_interval, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+
+  			end
+
+  			def output_broadcast_content_type(broadcast_content_type, len)
+  				ostream << Outputter::MANDATORY << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_CONTENT_TYPE
+  				ostream << Outputter::SEPARATOR
+  				if !broadcast_content_type.nil?
+  					buffer = AntHill::ByteBuffer.new(broadcast_content_type)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_content_type(broadcast_content_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_area_success(broadcast_area_success, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_AREA_SUCCESS
+  				ostream << Outputter::SEPARATOR << broadcast_area_success.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_area_success(broadcast_area_success, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+
+
+  			# Methods to output optional fields
+  			def output_sc_interface_version(sc_interface_version, len)
+  				raise Errors::INTERFACE_NOT_IMPLEMENTED
+  			end
+
+  			def output_ms_availability_status(ms_availability_status, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_ADDR_NPI
+  				ostream << Outputter::SEPARATOR << ms_availability_status.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_ms_availability_status(ms_availability_status, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_alert_on_msg_delivery(alert_on_msg_delivery, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::ALERT_ON_MSG_DELIVERY
+  				ostream << Outputter::SEPARATOR << alert_on_msg_delivery.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_alert_on_msg_delivery(alert_on_msg_delivery, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_channel_indicator(broadcast_channel_indicator, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_CHANNEL_INDICATOR
+  				ostream << Outputter::SEPARATOR << broadcast_channel_indicator.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_channel_indicator(broadcast_channel_indicator, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_content_type_info(broadcast_content_type_info, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_MESSAGE_CLASS
+  				ostream << Outputter::SEPARATOR
+  				if !broadcast_content_type_info.nil?
+  					buffer = AntHill::ByteBuffer.new(broadcast_content_type_info)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_content_type_info(broadcast_content_type_info, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_message_class(broadcast_message_class, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_MESSAGE_CLASS
+  				ostream << Outputter::SEPARATOR << broadcast_message_class.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_message_class(broadcast_message_class, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_service_group(broadcast_service_group, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_SERVICE_GROUP
+  				ostream << Outputter::SEPARATOR
+  				if !broadcast_service_group.nil?
+  					buffer = AntHill::ByteBuffer.new(broadcast_service_group)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_service_group(broadcast_service_group, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_callback_num(callback_num, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::CALLBACK_NUM
+  				ostream << Outputter::SEPARATOR
+  				if !callback_num.nil?
+  					buffer = AntHill::ByteBuffer.new(callback_num)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_callback_num(callback_num, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_callback_num_atag(callback_num_atag, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::CALLBACK_NUM_ATAG
+  				ostream << Outputter::SEPARATOR
+  				if !callback_num_atag.nil?
+  					buffer = AntHill::ByteBuffer.new(callback_num_atag)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_callback_num_atag(callback_num_atag, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_callback_num_pres_ind(callback_num_pres_ind, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::CALLBACK_NUM_PRES_IND
+  				ostream << Outputter::SEPARATOR << callback_num_pres_ind.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_callback_num_pres_ind(callback_num_pres_ind, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_addr_subunit(dest_addr_subunit, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_ADDR_SUBUNIT
+  				ostream << Outputter::SEPARATOR << dest_addr_subunit.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_addr_subunit(dest_addr_subunit, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_subaddress(dest_subaddress, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_SUBADDRESS
+  				ostream << Outputter::SEPARATOR
+  				if !dest_subaddress.nil?
+  					buffer = AntHill::ByteBuffer.new(dest_subaddress)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_subaddress(dest_subaddress, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_display_time(display_time, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DISPLAY_TIME
+  				ostream << Outputter::SEPARATOR << display_time.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_display_time(display_time, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_language_indicator(language_indicator, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::LANGUAGE_INDICATOR
+  				ostream << Outputter::SEPARATOR << language_indicator.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_language_indicator(language_indicator, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_message_payload(message_payload, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::MESSAGE_PAYLOAD
+  				ostream << Outputter::SEPARATOR
+  				if !message_payload.nil?
+  					buffer = AntHill::ByteBuffer.new(message_payload)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_message_payload(message_payload, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_ms_validity(ms_validity, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::MS_VALIDITY
+  				ostream << Outputter::SEPARATOR << ms_validity.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_ms_validity(ms_validity, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_payload_type(payload_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::PAYLOAD_TYPE
+  				ostream << Outputter::SEPARATOR << payload_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_payload_type(payload_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_privacy_indicator(privacy_indicator, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::PRIVACY_INDICATOR
+  				ostream << Outputter::SEPARATOR << privacy_indicator.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_privacy_indicator(privacy_indicator, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_sms_signal(sms_signal, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SMS_SIGNAL
+  				ostream << Outputter::SEPARATOR << sms_signal.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_sms_signal(sms_signal, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_addr_subunit(source_addr_subunit, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_ADDR_SUBUNIT
+  				ostream << Outputter::SEPARATOR << source_addr_subunit.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_addr_subunit(source_addr_subunit, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_port(source_port, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_PORT
+  				ostream << Outputter::SEPARATOR << source_port.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_port(source_port, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_subaddress(source_subaddress, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_SUBADDRESS
+  				ostream << Outputter::SEPARATOR
+  				if !source_subaddress.nil?
+  					buffer = AntHill::ByteBuffer.new(source_subaddress)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_subaddress(source_subaddress, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_user_message_reference(user_message_reference, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::USER_MESSAGE_REFERENCE
+  				ostream << Outputter::SEPARATOR << user_message_reference.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_user_message_reference(user_message_reference, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_error_status(broadcast_error_status, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_ERROR_STATUS
+  				ostream << Outputter::SEPARATOR << broadcast_error_status.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_error_status(broadcast_error_status, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_failed_broadcast_area_identifier(failed_broadcast_area_identifier, len)
+  				0.upto(failed_broadcast_area_identifier.size() -1) do | i |
+  					# Output field
+  					ostream << Outputter::MANDATORY << Outputter::SEPARATOR << len[i].to_s
+  					ostream << Outputter::SEPARATOR << FieldsName::FAILED_BROADCAST_AREA_IDENTIFIER
+  					ostream << Outputter::SEPARATOR
+
+
+  					if failed_broadcast_area_identifier[i].value().size()
+  						buffer = AntHill::ByteBuffer.new(failed_broadcast_area_identifier[i].value())
+  						buffer.write_dump(ostream)
+
+  						if @show_fmtinfo
+                area_format_code = 0
+                if RUBY_VERSION >= "1.9.0"
+                  area_format_code = failed_broadcast_area_identifier[i].value()[0].ord
+                else
+                  area_format_code = failed_broadcast_area_identifier[i].value()[0]
+                end
+  							# area_format_code = failed_broadcast_area_identifier[i].value()[0]
+  							area_format_name = get_area_format_name(area_format_code)
+  							ostream << sprintf("%s%d", Outputter::COMMA, area_format_code)
+  							ostream << sprintf("%s%s", Outputter::EQUAL, area_format_name)
+  						end
+  					end
+  					ostream << Outputter::SEPARATOR
+
+
+  					encoder.reset_buffer()
+  					encoder.encode_failed_broadcast_area_identifier_single(failed_broadcast_area_identifier[i], len[i])
+  					byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  					byte_buffer.write_dump(ostream)
+  					ostream << "\n"
+  				end
+  			end
+
+  			def output_broadcast_content_type_opt(broadcast_content_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_CONTENT_TYPE
+  				ostream << Outputter::SEPARATOR
+  				if !broadcast_content_type.nil?
+  					buffer = AntHill::ByteBuffer.new(broadcast_content_type)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_content_type(broadcast_content_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_network_type(source_network_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_NETWORK_TYPE
+  				ostream << Outputter::SEPARATOR << source_network_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_network_type(source_network_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_bearer_type(source_bearer_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_BEARER_TYPE
+  				ostream << Outputter::SEPARATOR << source_bearer_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_bearer_type(source_bearer_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_source_telematics_id(source_telematics_id, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SOURCE_TELEMATICS_ID
+  				ostream << Outputter::SEPARATOR << source_telematics_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_source_telematics_id(source_telematics_id, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_destination_port(destination_port, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DESTINATION_PORT
+  				ostream << Outputter::SEPARATOR << destination_port.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_destination_port(destination_port, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_network_type(dest_network_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_NETWORK_TYPE
+  				ostream << Outputter::SEPARATOR << dest_network_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_network_type(dest_network_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_bearer_type(dest_bearer_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_BEARER_TYPE
+  				ostream << Outputter::SEPARATOR << dest_bearer_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_bearer_type(dest_bearer_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dest_telematics_id(dest_telematics_id, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DEST_TELEMATICS_ID
+  				ostream << Outputter::SEPARATOR << dest_telematics_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dest_telematics_id(dest_telematics_id, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_sar_msg_ref_num(sar_msg_ref_num, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SAR_MSG_REF_NUM
+  				ostream << Outputter::SEPARATOR << sar_msg_ref_num.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_sar_msg_ref_num(sar_msg_ref_num, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_sar_total_segments(sar_total_segments, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SAR_TOTAL_SEGMENTS
+  				ostream << Outputter::SEPARATOR << sar_total_segments.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_sar_total_segments(sar_total_segments, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_sar_segment_seqnum(sar_segment_seqnum, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SAR_SEGMENT_SEQNUM
+  				ostream << Outputter::SEPARATOR << sar_segment_seqnum.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_sar_segment_seqnum(sar_segment_seqnum, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_more_messages_to_send(more_messages_to_send, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::MORE_MESSAGES_TO_SEND
+  				ostream << Outputter::SEPARATOR << more_messages_to_send.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_more_messages_to_send(more_messages_to_send, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_qos_time_to_live(qos_time_to_live, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::QOS_TIME_TO_LIVE
+  				ostream << Outputter::SEPARATOR << qos_time_to_live.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_qos_time_to_live(qos_time_to_live, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_set_dpf(set_dpf, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::SET_DPF
+  				ostream << Outputter::SEPARATOR << set_dpf.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_set_dpf(set_dpf, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_receipted_message_id(receipted_message_id, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::RECEIPTED_MESSAGE_ID
+  				ostream << Outputter::SEPARATOR << receipted_message_id.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_receipted_message_id(receipted_message_id, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_message_state_tlv_opt(message_state, len)
+  				message_state_name = get_message_state_name(message_state)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::MESSAGE_STATE
+  				ostream << Outputter::SEPARATOR << message_state.to_s
+  				ostream << Outputter::EQUAL << message_state_name
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_message_state_tlv(message_state, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_network_error_code(network_error_code, len)
+  				network_name = get_network_error_name(network_error_code.network_code())
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::NETWORK_ERROR_CODE
+  				ostream << Outputter::SEPARATOR << network_error_code.network_code.to_s
+  				ostream << Outputter::EQUAL << network_name.to_s
+  				ostream << Outputter::COMMA << network_error_code.error_code.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_network_error_code(network_error_code, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_ms_msg_wait_facilities(ms_msg_wait_facilities, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::MS_MSG_WAIT_FACILITIES
+  				ostream << Outputter::SEPARATOR << ms_msg_wait_facilities.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_ms_msg_wait_facilities(ms_msg_wait_facilities, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_number_of_messages(number_of_messages, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::NUMBER_OF_MESSAGES
+  				ostream << Outputter::SEPARATOR << number_of_messages.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_number_of_messages(number_of_messages, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_its_reply_type(its_reply_type, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::ITS_REPLY_TYPE
+  				ostream << Outputter::SEPARATOR << its_reply_type.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_its_reply_type(its_reply_type, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_its_session_info(its_session_info, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::ITS_SESSION_INFO
+  				ostream << Outputter::SEPARATOR << its_session_info.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_its_session_info(its_session_info, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_user_response_code(user_response_code, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::USER_RESPONSE_CODE
+  				ostream << Outputter::SEPARATOR << user_response_code.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_user_response_code(user_response_code, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_delivery_failure_reason(delivery_failure_reason, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DELIVERY_FAILURE_REASON
+  				ostream << Outputter::SEPARATOR << delivery_failure_reason.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_delivery_failure_reason(delivery_failure_reason, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_additional_status_info_text(additional_status_info_text, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::ADDITIONAL_STATUS_INFO_TEXT
+  				ostream << Outputter::SEPARATOR
+  				if !additional_status_info_text.nil?
+  					buffer = AntHill::ByteBuffer.new(additional_status_info_text)
+  					buffer.write_dump(ostream)
+  				end
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_additional_status_info_text(additional_status_info_text, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_dpf_result(dpf_result, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::DPF_RESULT
+  				ostream << Outputter::SEPARATOR << dpf_result.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_dpf_result(dpf_result, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  			def output_broadcast_end_time(broadcast_end_time, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::BROADCAST_END_TIME
+  				ostream << Outputter::SEPARATOR << broadcast_end_time.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_broadcast_end_time(broadcast_end_time, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+
+  			def output_ussd_service_op(ussd_service_op, len)
+  				ostream << Outputter::OPTIONAL_ << Outputter::SEPARATOR << len.to_s
+  				ostream << Outputter::SEPARATOR << FieldsName::USSD_SERVICE_OP
+  				ostream << Outputter::SEPARATOR << ussd_service_op.to_s
+  				ostream << Outputter::SEPARATOR
+
+  				# Show hex dump
+  				encoder.reset_buffer()
+  				encoder.encode_ussd_service_op(ussd_service_op, len)
+  				byte_buffer = AntHill::ByteBuffer.new(encoder.get_buffer())
+  				byte_buffer.write_dump(ostream)
+  				ostream << "\n"
+  			end
+
+  		end
+
+  	end
+  end
+end