qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Viewer/SituationMap/Symbology/sidc_builder_base.cpp

/**
  * @RDE_HEADER@
  * Class SidcBuilderBase
  * $Id$
  * $HeadURL$
  * $Author$
  */

// Own
#include "sidc_builder_base.h"
#include "sidc_codec.h"

// ESRI


// Qt
#include <QtCore/QDebug>
#include <QtCore/QRegularExpression>


namespace AdvancedSymbology
{


SidcBuilderBase::SidcBuilderBase(SymbolDictionary *symbolDictionary, const char *loggerName)
  : SidcDefinitions(symbolDictionary, loggerName)
{
}


QString SidcBuilderBase::baseSymbolCodeToSidc(const QString &baseSymbolCodeCodec)
{
  if (!SidcCodec::isEncoded(baseSymbolCodeCodec))
  {
    qCritical() << LOGFUNCTION << " baseSymbolCodeCodec input parameter isn't encoded: " << baseSymbolCodeCodec;
    return QString();
  }

  switch (SidcCodec::decodeSidcType(baseSymbolCodeCodec))
  {
    case SidcCodec::SidcType::CivilEts:
    case SidcCodec::SidcType::CivilXml:
      return baseSymbolCodeCodec;
    case SidcCodec::SidcType::Base:
      break;
    default :
    {
      qCritical() << LOGFUNCTION << " baseSymbolCodeCodec is not a base symbol code: " << baseSymbolCodeCodec;
      return QString();
    }
  } // switch

  QString       sidc;
  QString       baseSymbolCode = SidcCodec::decodeRawSidc(baseSymbolCodeCodec);
  SymbologyType symbologyType  = SidcCodec::decodeSymbologyType(baseSymbolCodeCodec);

  if ((SymbologyType::MIL2525D == symbologyType) || (SymbologyType::APP6D == symbologyType))
  {
    //
    // its MIL2525D or APP6D
    //

    if ((baseSymbolCode.size() != 8) && (baseSymbolCode.size() != 10))
    {
      return QString(); // failure !!
    }

    QRegularExpression sidcTemplate(QStringLiteral("^[0-9]{8}(_[0-9])?$"));

    if (!sidcTemplate.match(baseSymbolCode).hasMatch())
    {
      return QString(); // Failure
    }

    // Version
    sidc += QLatin1Char('1');
    sidc += QLatin1Char('0');

    // Standard Identity
    sidc += QLatin1Char('0');
    if (baseSymbolCode.size() == 10) sidc += baseSymbolCode[9];
    else                             sidc += QLatin1Char('1');

    // SymbolSet
    sidc += baseSymbolCode[0];
    sidc += baseSymbolCode[1];

    // Status
    sidc += QLatin1Char('0');

    // HeadQuarter, TaskForce, Dummy
    sidc += QLatin1Char('0');

    // Amplifier/Descriptor
    sidc += QLatin1Char('0');
    sidc += QLatin1Char('0');

    sidc += baseSymbolCode[2];
    sidc += baseSymbolCode[3];
    sidc += baseSymbolCode[4];
    sidc += baseSymbolCode[5];
    sidc += baseSymbolCode[6];
    sidc += baseSymbolCode[7];

    sidc = sidc.leftJustified(20, QLatin1Char('0'));

    return SidcCodec::encodeComplete(symbologyType, sidc);
  }
 
  if (SymbologyType::APP6B == symbologyType)
  {
    sidc = baseSymbolCode;
    sidc[1] = QLatin1Char('U');
    sidc[3] = QLatin1Char('P');

    return SidcCodec::encodeComplete(symbologyType, sidc);
  }

  return QString();
} // QString SidcBuilderBase::baseSymbolCodeToSidc(const QString &baseSymbolCodeCodec)


QString SidcBuilderBase::concreteSidcToBaseSymbolCode(const QString &sidcCodec)
{
  if (!SidcCodec::isEncoded(sidcCodec))
  {
    qCritical() << LOGFUNCTION << " sidcCodec is not a complete sidc: " << sidcCodec;
    return QString();
  }

  switch (SidcCodec::decodeSidcType(sidcCodec))
  {
  case SidcCodec::SidcType::CivilEts:
  case SidcCodec::SidcType::CivilXml:
    return sidcCodec;
    break;
  case SidcCodec::SidcType::Complete:
    break;
  default :
  {
    qCritical() << LOGFUNCTION << " sidcCodec is not a complete sidc: " << sidcCodec;
    return QString();
  }
  } // switch

  const QString   &rawSidc      = SidcCodec::decodeRawSidc(sidcCodec);
  SymbologyType   symbologyType = SidcCodec::decodeSymbologyType(sidcCodec);

  switch (symbologyType)
  {
    case SymbologyType::APP6B    :
    {
      const QString & baseSymbolCode = normalizeAPP6BaseSymbolCode(rawSidc);
     
      return SidcCodec::encodeBaseSymbolCode(symbologyType, baseSymbolCode);
    }
    case SymbologyType::MIL2525C : return QString();
    case SymbologyType::APP6D    : // it's same as MIL2525D
    case SymbologyType::MIL2525D :
    {
      if (rawSidc.count() != 20)
        return QString();

      QString baseSymbolCode(
        QStringRef(&rawSidc, 4, 2).toString() +
        QStringRef(&rawSidc, 10, 6).toString());
      return SidcCodec::encodeBaseSymbolCode(symbologyType, baseSymbolCode);
    } break;

    case SymbologyType::None: return QString();
  }
  return QString();
  
} // QString SidcBuilderBase::concreteSidcToBaseSymbolCode(const QString &sidcCodec)


QString SidcBuilderBase::normalizeAPP6BaseSymbolCode(const QString & baseSymbolCode)
{
  QString baseNorm = baseSymbolCode;

  baseNorm.resize(15, QLatin1Char('*'));

  baseNorm[1]  = QLatin1Char('*');
  baseNorm[3]  = QLatin1Char('*');

  if (QLatin1Char('*') != baseNorm[10]) baseNorm[10] = QLatin1Char('-');
  if (QLatin1Char('*') != baseNorm[11]) baseNorm[11] = QLatin1Char('-');
  if (QLatin1Char('*') != baseNorm[14]) baseNorm[14] = QLatin1Char('-');

  return baseNorm;

} // QString SidcBuilderBase::normalizeAPP6BaseSymbolCode(const QString & baseSymbolCode)



} // namespace AdvancedSymbology