480 lines
14 KiB
C++
Executable File
480 lines
14 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Class SidcBuilder
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
// Own
|
|
#include "sidc_builder.h"
|
|
#include "sidc_codec.h"
|
|
|
|
|
|
// 1234567890
|
|
qint32 AdvancedSymbology::SidcBuilder::_smallest = 1000000000;
|
|
qint32 AdvancedSymbology::SidcBuilder::_specialPartA = 1001980000;
|
|
qint32 AdvancedSymbology::SidcBuilder::_invalidPartB = 1000000000;
|
|
qint32 AdvancedSymbology::SidcBuilder::_retiredPartB = 1100000000;
|
|
|
|
|
|
|
|
namespace AdvancedSymbology
|
|
{
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SidcBuilder
|
|
//-----------------------------------------------------------------------------
|
|
SidcBuilder::SidcBuilder(AdvancedSymbology::SymbolDictionary *symbolDictionary)
|
|
: SidcBuilderBase(symbolDictionary, "SidcBuilder")
|
|
{
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
|
|
init();
|
|
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
|
|
}
|
|
|
|
void SidcBuilder::init()
|
|
{
|
|
m_first10_mil2525D = QString::number(_specialPartA);
|
|
m_second10_mil2525D = QString::number(_invalidPartB);
|
|
initAmplifier();
|
|
}
|
|
|
|
void SidcBuilder::initAmplifier()
|
|
{
|
|
m_amplifierGroup = AmplifierGroup::Unknown;
|
|
|
|
m_e_BrigadeAndBelow = EchelonBrigadeAndBelow::Unknown;
|
|
m_e_DivisionAndAbove = EchelonDivisionAndAbove::Unknown;
|
|
|
|
m_e_MobilityOnLand = MobilityOnLand::Unknown;
|
|
m_e_MobilityOnSnow = MobilityOnSnow::Unknown;
|
|
m_e_MobilityOnWater = MobilityOnWater::Unknown;
|
|
|
|
m_e_NavalTowedArray = NavalTowedArray::Unknown;
|
|
}
|
|
|
|
|
|
|
|
|
|
SidcDefinitions::StandardIdentity SidcBuilder::standardIdentity() const
|
|
{
|
|
StandardIdentity si;
|
|
si.context = context();
|
|
si.identity = identity();
|
|
return si;
|
|
}
|
|
|
|
void SidcBuilder::setStandardIdentity(const SidcDefinitions::StandardIdentity &standardIdentity)
|
|
{
|
|
setContext(standardIdentity.context);
|
|
setIdentity(standardIdentity.identity);
|
|
}
|
|
|
|
SidcDefinitions::Context SidcBuilder::context() const
|
|
{
|
|
return static_cast<Context>(QStringRef(&m_first10_mil2525D, 2, 1).toInt());
|
|
}
|
|
void SidcBuilder::setContext(SidcDefinitions::Context context)
|
|
{
|
|
m_first10_mil2525D.replace(2, 1, QString::number((int)context));
|
|
}
|
|
SidcDefinitions::Identity SidcBuilder::identity() const
|
|
{
|
|
return static_cast<Identity>(QStringRef(&m_first10_mil2525D, 3, 1).toInt());
|
|
}
|
|
|
|
void SidcBuilder::setIdentity(SidcDefinitions::Identity identity)
|
|
{
|
|
m_first10_mil2525D.replace(3, 1, QString::number((int)identity));
|
|
}
|
|
|
|
bool SidcBuilder::isIdentityAssumed() const
|
|
{
|
|
const SidcDefinitions::Identity identityValue = identity();
|
|
|
|
switch (identityValue) {
|
|
case SidcDefinitions::Identity::Pending:
|
|
return true;
|
|
case SidcDefinitions::Identity::AssumedFriend:
|
|
return true;
|
|
case SidcDefinitions::Identity::SuspectJoker:
|
|
return true;
|
|
break;
|
|
default:
|
|
// empty
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
SidcDefinitions::SymbolSet SidcBuilder::symbolSet() const
|
|
{
|
|
SymbolSet sset = static_cast<SymbolSet>(QStringRef(&m_first10_mil2525D, 4, 2).toString().toInt());
|
|
return sset;
|
|
}
|
|
void SidcBuilder::setSymbolSet(const SymbolSet &symbolSet)
|
|
{
|
|
m_first10_mil2525D.replace(4, 2, QStringLiteral("%1").arg((int)symbolSet, 2, 10, QLatin1Char('0')));
|
|
}
|
|
|
|
|
|
SidcDefinitions::Status SidcBuilder::status() const
|
|
{
|
|
Status status = static_cast<Status>(QStringRef(&m_first10_mil2525D, 6, 1).toInt());
|
|
return status;
|
|
}
|
|
|
|
void SidcBuilder::setStatus(const Status &status)
|
|
{
|
|
m_first10_mil2525D.replace(6, 1, QString::number((int)status));
|
|
}
|
|
|
|
|
|
QString SidcBuilder::symbolEntityCode() const
|
|
{
|
|
SymbologyType symbologyType = m_symbolDictionary->symbologyType();
|
|
switch (symbologyType)
|
|
{
|
|
case SymbologyType::APP6B : return SidcCodec::decodeRawSidc(concreteSidcToBaseSymbolCode(SidcCodec::encodeComplete(symbologyType,m_app6bRawSidc)));
|
|
case SymbologyType::APP6D : return m_second10_mil2525D.left(6);
|
|
case SymbologyType::MIL2525C : return QString();
|
|
case SymbologyType::MIL2525D : return m_second10_mil2525D.left(6);
|
|
case SymbologyType::None : return QString();
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
|
|
void SidcBuilder::setSymbolEntityCode(const QString &entityCode)
|
|
{
|
|
if (entityCode.size() == 6) m_second10_mil2525D.replace(0, 6, entityCode);
|
|
}
|
|
|
|
|
|
SidcDefinitions::HQTFDummy SidcBuilder::hqTfFd() const
|
|
{
|
|
HQTFDummy hdtffd = static_cast<HQTFDummy>(QStringRef(&m_first10_mil2525D, 7, 1).toInt());
|
|
return hdtffd;
|
|
}
|
|
|
|
uint SidcBuilder::hqTfFd_UInt() const
|
|
{
|
|
return static_cast<int>(hqTfFd());
|
|
}
|
|
|
|
void SidcBuilder::setHqTfFd(const HQTFDummy &hqTfFd)
|
|
{
|
|
m_first10_mil2525D.replace(7, 1, QString::number((int)hqTfFd));
|
|
}
|
|
|
|
bool SidcBuilder::headquarters() const
|
|
{
|
|
bool headquarters;
|
|
bool taskForce;
|
|
bool feintDummy;
|
|
SidcDefinitions::HQTFDummyConverter::toBool(hqTfFd(), headquarters, taskForce, feintDummy);
|
|
return headquarters;
|
|
}
|
|
|
|
bool SidcBuilder::taskForce() const
|
|
{
|
|
bool headquarters;
|
|
bool taskForce;
|
|
bool feintDummy;
|
|
SidcDefinitions::HQTFDummyConverter::toBool(hqTfFd(), headquarters, taskForce, feintDummy);
|
|
return taskForce;
|
|
}
|
|
|
|
bool SidcBuilder::feintDummy() const
|
|
{
|
|
bool headquarters;
|
|
bool taskForce;
|
|
bool feintDummy;
|
|
SidcDefinitions::HQTFDummyConverter::toBool(hqTfFd(), headquarters, taskForce, feintDummy);
|
|
return feintDummy;
|
|
}
|
|
|
|
|
|
SidcDefinitions::AmplifierGroup SidcBuilder::amplifierGroup() const
|
|
{
|
|
AmplifierGroup amplifierGroup = static_cast<AmplifierGroup>(QStringRef(&m_first10_mil2525D, 8, 1).toInt());
|
|
return amplifierGroup;
|
|
}
|
|
void SidcBuilder::setAmplifierGroup(const AmplifierGroup &lifierGroup)
|
|
{
|
|
m_first10_mil2525D.replace(8, 1, QString::number((int)amplifierGroup));
|
|
}
|
|
|
|
unsigned int SidcBuilder::amplifier2ndDigit() const
|
|
{
|
|
return QStringRef(&m_first10_mil2525D, 9, 1).toUInt();
|
|
} // unsigned int SidcBuilder::amplifier2ndDigit() const
|
|
|
|
|
|
void SidcBuilder::setAmplifier2ndDigit(unsigned int amplifierSecondDigit)
|
|
{
|
|
if (amplifierSecondDigit > 9) return; // ToDo error message
|
|
m_first10_mil2525D.replace(9, 1, QString::number(amplifierSecondDigit));
|
|
}
|
|
|
|
unsigned int SidcBuilder::sectorModifier1Digit()
|
|
{
|
|
return QStringRef(&m_second10_mil2525D, 6, 2).toUInt();
|
|
} // unsigned int SidcBuilder::sectorModifier1Digit()
|
|
|
|
|
|
unsigned int SidcBuilder::sectorModifier2Digit()
|
|
{
|
|
return QStringRef(&m_second10_mil2525D, 8, 2).toUInt();
|
|
} // unsigned int SidcBuilder::sectorModifier2Digit()
|
|
|
|
|
|
void SidcBuilder::setSectorModifier1Digit(unsigned int digit)
|
|
{
|
|
if (digit > 99) return; // ToDo error message
|
|
m_second10_mil2525D.replace(6, 2, QStringLiteral("%1").arg(digit, 2, 10, QLatin1Char('0')));
|
|
} // void SidcBuilder::setSectorModifier1Digit( unsigned int )
|
|
|
|
|
|
void SidcBuilder::setSectorModifier2Digit(unsigned int digit)
|
|
{
|
|
if (digit > 99) return; // ToDo error message
|
|
m_second10_mil2525D.replace(8, 2, QStringLiteral("%1").arg(digit, 2, 10, QLatin1Char('0')));
|
|
} // void SidcBuilder::setSectorModifier2Digit( unsigned int digit )
|
|
|
|
|
|
|
|
|
|
|
|
QString SidcBuilder::toRawSidc() const
|
|
{
|
|
if (!m_symbolDictionary)
|
|
return QString();
|
|
switch (m_symbolDictionary->symbologyType())
|
|
{
|
|
case SymbologyType::APP6B : return m_app6bRawSidc;
|
|
case SymbologyType::APP6D : return m_first10_mil2525D + m_second10_mil2525D;
|
|
case SymbologyType::MIL2525C : return QString();
|
|
case SymbologyType::MIL2525D : return m_first10_mil2525D + m_second10_mil2525D;
|
|
case SymbologyType::None : return QString();
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
|
|
QString SidcBuilder::toSidc() const
|
|
{
|
|
if (!m_symbolDictionary)
|
|
return QString();
|
|
const QString &rawSidc = toRawSidc();
|
|
|
|
return (rawSidc.isEmpty()) ? QString() : SidcCodec::encodeComplete(m_symbolDictionary->symbologyType(), rawSidc);
|
|
} // QString SidcBuilder::toSidc() const
|
|
|
|
|
|
bool SidcBuilder::initFromSymbologyType(SymbologyType symbologyType, const QString &sidc)
|
|
{
|
|
QString rawSidc(sidc);
|
|
|
|
if (SidcCodec::isEncoded(sidc))
|
|
{
|
|
SymbologyType sidcSymbolType = SidcCodec::decodeSymbologyType(sidc);
|
|
SidcCodec::SidcType sidcType = SidcCodec::decodeSidcType(sidc);
|
|
|
|
rawSidc = SidcCodec::decodeRawSidc(sidc);
|
|
|
|
if (symbologyType != sidcSymbolType)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " sidc='" << sidc << "'"
|
|
<< ", wrong symbology type";
|
|
return false;
|
|
}
|
|
|
|
if (SidcCodec::SidcType::Complete != sidcType)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " sidcMIL2525D='" << sidc << "'"
|
|
<< ", wrong sidc type";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// check size
|
|
if (rawSidc.size() != 20)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " sidc='" << sidc << "'"
|
|
<< ", size failed";
|
|
return false;
|
|
}
|
|
|
|
// check version
|
|
if (QStringRef(&rawSidc, 0, 2) != QLatin1String("10"))
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " sidc='" << sidc << "'"
|
|
<< ", wrong version";
|
|
return false;
|
|
}
|
|
|
|
init();
|
|
|
|
m_first10_mil2525D = rawSidc.mid( 0, 10);
|
|
m_second10_mil2525D = rawSidc.mid(10, 10);
|
|
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION
|
|
<< " m_first10='" << m_first10_mil2525D << "'"
|
|
<< " m_second10='" << m_second10_mil2525D << "'";
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool SidcBuilder::initFromSymbologyTypeBaseSymbolCode(SymbologyType symbologyType, const QString &baseSymbolCode)
|
|
{
|
|
QString rawBaseSymbolCode(baseSymbolCode);
|
|
|
|
if (SidcCodec::isEncoded(baseSymbolCode))
|
|
{
|
|
if (SidcCodec::decodeSymbologyType(baseSymbolCode) != symbologyType)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " sidc='" << baseSymbolCode << "'"
|
|
<< ", wrong symbology type";
|
|
return false;
|
|
}
|
|
|
|
if (SidcCodec::decodeSidcType(baseSymbolCode) != SidcCodec::SidcType::Base)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " sidc='" << baseSymbolCode << "'"
|
|
<< ", wrong sidc type";
|
|
return false;
|
|
}
|
|
|
|
rawBaseSymbolCode = SidcCodec::decodeRawSidc(baseSymbolCode);
|
|
}
|
|
|
|
// check size
|
|
if (rawBaseSymbolCode.size() != 8)
|
|
{
|
|
ERROR_LOG(m_logger) << LOGFUNCTION
|
|
<< " baseSymbolCode='" << baseSymbolCode << "'"
|
|
<< ", size failed";
|
|
return false;
|
|
}
|
|
|
|
init();
|
|
|
|
// set SymbolSet:
|
|
SymbolSet sSet = static_cast<SymbolSet>(QStringRef(&rawBaseSymbolCode, 0, 2).toInt());
|
|
this->setSymbolSet(sSet);
|
|
|
|
// set Entity:
|
|
const QString &entityChars = rawBaseSymbolCode.mid(2, 6);
|
|
|
|
// merge into second10:
|
|
m_second10_mil2525D.replace(0, 6, entityChars);
|
|
|
|
return true;
|
|
} // bool SidcBuilder::initFromSymbologyTypeBaseSymbolCode(SymbologyType symbologyType, const QString &baseSymbolCode)
|
|
|
|
|
|
bool SidcBuilder::initFromMil2525D(const QString &sidcMil2525D)
|
|
{
|
|
return SidcBuilder::initFromSymbologyType(SymbologyType::MIL2525D,sidcMil2525D);
|
|
}
|
|
|
|
|
|
bool SidcBuilder::initFromMil2525DBaseSymbolCode(const QString &sidcMil2525D_baseSymbolCode)
|
|
{
|
|
return initFromSymbologyTypeBaseSymbolCode(SymbologyType::MIL2525D, sidcMil2525D_baseSymbolCode);
|
|
}
|
|
|
|
|
|
bool SidcBuilder::initFromApp6B(const QString &sidcApp6B)
|
|
{
|
|
m_app6bRawSidc = SidcCodec::decodeRawSidc(sidcApp6B);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool SidcBuilder::initFromApp6BBaseSymbolCode(const QString &sidcApp6B_baseSymbolCode)
|
|
{
|
|
m_app6bRawSidc = SidcCodec::decodeRawSidc(baseSymbolCodeToSidc( sidcApp6B_baseSymbolCode ));
|
|
return false;
|
|
}
|
|
|
|
bool SidcBuilder::initFromApp6D(const QString &sidcAPP6D)
|
|
{
|
|
return SidcBuilder::initFromSymbologyType(SymbologyType::APP6D,sidcAPP6D);
|
|
}
|
|
|
|
|
|
bool SidcBuilder::initFromApp6DBaseSymbolCode(const QString &sidcAPP6D_baseSymbolCode)
|
|
{
|
|
return initFromSymbologyTypeBaseSymbolCode(SymbologyType::APP6D, sidcAPP6D_baseSymbolCode);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
private void _BuildSIDC()
|
|
{
|
|
// Builds a current (2525D) SIDC from the JMSML Library elements currently associated
|
|
// with this symbol.
|
|
|
|
if (_version != null && _context != null &&
|
|
_standardIdentity != null && _symbolSet != null && _status != null &&
|
|
_hqTFDummy != null && _amplifierGroup != null && _amplifier != null)
|
|
{
|
|
_sidc.PartAUInt = (uint)_version.VersionCode.DigitOne * 1000000000 +
|
|
(uint)_version.VersionCode.DigitTwo * 100000000 +
|
|
(uint)_context.ContextCode * 10000000 +
|
|
(uint)_standardIdentity.StandardIdentityCode * 1000000 +
|
|
(uint)_symbolSet.SymbolSetCode.DigitOne * 100000 +
|
|
(uint)_symbolSet.SymbolSetCode.DigitTwo * 10000 +
|
|
(uint)_status.StatusCode * 1000 +
|
|
(uint)_hqTFDummy.HQTFDummyCode * 100 +
|
|
(uint)_amplifierGroup.AmplifierGroupCode * 10 +
|
|
(uint)_amplifier.AmplifierCode;
|
|
}
|
|
|
|
if (_entity != null)
|
|
{
|
|
_sidc.PartBUInt = (uint)_entity.EntityCode.DigitOne * 1000000000 +
|
|
(uint)_entity.EntityCode.DigitTwo * 100000000;
|
|
}
|
|
|
|
if (_entityType != null)
|
|
{
|
|
_sidc.PartBUInt = _sidc.PartBUInt + (uint)_entityType.EntityTypeCode.DigitOne * 10000000 +
|
|
(uint)_entityType.EntityTypeCode.DigitTwo * 1000000;
|
|
}
|
|
|
|
if (_entitySubType != null)
|
|
{
|
|
_sidc.PartBUInt = _sidc.PartBUInt + (uint)_entitySubType.EntitySubTypeCode.DigitOne * 100000 +
|
|
(uint)_entitySubType.EntitySubTypeCode.DigitTwo * 10000;
|
|
}
|
|
|
|
if (_modifierOne != null)
|
|
{
|
|
_sidc.PartBUInt = _sidc.PartBUInt + (uint)_modifierOne.ModifierCode.DigitOne * 1000 +
|
|
(uint)_modifierOne.ModifierCode.DigitTwo * 100;
|
|
}
|
|
|
|
if (_modifierTwo != null)
|
|
{
|
|
_sidc.PartBUInt = _sidc.PartBUInt + (uint)_modifierTwo.ModifierCode.DigitOne * 10 +
|
|
(uint)_modifierTwo.ModifierCode.DigitTwo;
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
} // namespace AdvancedSymbology
|