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

// Own
#include "sidc_definitions.h"
#include <SymbologyImpl/symbol_dictionary_impl.h>

#ifdef XML_SYMBOL_ICONS
#include <SymbologyXML/symbol.h>
#include <SymbologyXML/symbol_reader.h>
#include <SymbologyXML/symbol_exporter.h>
#endif

#include <QtCore/QFile>
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
#include <QtWidgets/QGraphicsScene>


//
//#include <sstream>

namespace AdvancedSymbology
{


SidcDefinitions::SidcDefinitions(SymbolDictionary *symbolDictionary, const char *loggerName)
  : m_symbolDictionary(symbolDictionary)
  , m_logger(getLogger(loggerName))
{
  if (m_symbolDictionary)
  {
    if (m_symbolDictionary->isLoaded())
    {
      SymbolDictionaryImpl *symDicImpl = static_cast<SymbolDictionaryImpl *>(m_symbolDictionary);
      m_esriDictProcessor = symDicImpl->getEsriDictionaryProcessor();
    }
    else
      ERROR_LOG(m_logger) << LOGFUNCTION << " symbolDictionary not loaded";
  }
  else
    ERROR_LOG(m_logger) << LOGFUNCTION << " no symbolDictionary";
}

QLatin1String SidcDefinitions::toString(ShapeType value)
{
  switch (value)
  {
  case ShapeType::Undefined:
    return QLatin1String("Undefined");
  case ShapeType::Circle:
    return QLatin1String("Circle");
  case ShapeType::Clover:
    return QLatin1String("Clover");
  case ShapeType::Curve:
    return QLatin1String("Curve");
  case ShapeType::Diamond:
    return QLatin1String("Diamond");
  case ShapeType::Rectangle:
    return QLatin1String("Rectangle");
  case ShapeType::Square:
    return QLatin1String("Square");
  }
  return QLatin1String("ERROR-ShapeType");
}


QLatin1String SidcDefinitions::toString(Context value)
{
  switch (value)
  {
  case Context::Reality:
    return QLatin1String("Reality");
  case Context::Exercise:
    return QLatin1String("Exercise");
  case Context::Simulation:
    return QLatin1String("Simulation");
  }
  return QLatin1String("ERROR-Context");
}


QPixmap SidcDefinitions::toPixmap(Context value)
{
  Q_UNUSED(value)
  return QPixmap();
}


QLatin1String SidcDefinitions::toString(Identity value)
{
  switch (value)
  {
  case Identity::Pending:
    return QLatin1String("Pending");
  case Identity::Unknown:
    return QLatin1String("Unknown");

  case Identity::AssumedFriend:
    return QLatin1String("AssumedFriend");
  case Identity::Friend:
    return QLatin1String("Friend");

  case Identity::Neutral:
    return QLatin1String("Neutral");

  case Identity::SuspectJoker:
    return QLatin1String("SuspectJoker");
  case Identity::HostileFaker:
    return QLatin1String("HostileFaker");
  } // switch
  return QLatin1String("ERROR-Identity");
}


QPixmap SidcDefinitions::toPixmap(Identity value)
{
  Q_UNUSED(value);
  return QPixmap();  // render XML symbol frame not activated yet
  
  #ifdef XML_SYMBOL_ICONS

    QGraphicsScene                     scene;
    QString                            frameXml;
    QString                            frameResource;
    SymbologyXML::Symbol               symbol;
    SymbologyXML::SymbolReader         symbolReader;
    QColor                             fillColor;
    SymbologyXML::SymbolTypes::t_affil affil;

    static QMap<Identity,QImage*>      frameImageMap;

    if (frameImageMap[value]) return QPixmap::fromImage(*frameImageMap[value]);

    scene.setSceneRect( QRectF(-2.0, -2.0, 4.0, 4.0) );
  
    switch (value)
    {
      case Identity::Pending : 
      {
        affil = SymbologyXML::SymbolTypes::t_affil::PENDING; 
        fillColor = QColor(QStringLiteral("yellow"));       
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_unknown.xml");
      } break;

      case Identity::Unknown : 
      {
        affil = SymbologyXML::SymbolTypes::t_affil::UNKNOWN; 
        fillColor = QColor(QStringLiteral("yellow"));       
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_unknown.xml");
      } break;

      case Identity::AssumedFriend : 
       {
        affil = SymbologyXML::SymbolTypes::t_affil::ASSUMED_FRIEND; 
        fillColor = QColor(QStringLiteral("light blue"));
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_friend.xml");
      } break;

      case Identity::Friend :
      {
        affil = SymbologyXML::SymbolTypes::t_affil::FRIEND; 
        fillColor = QColor(QStringLiteral("light blue"));
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_friend.xml");
      } break;

      case Identity::Neutral :
      {
        affil = SymbologyXML::SymbolTypes::t_affil::NEUTRAL; 
        fillColor = QColor(QStringLiteral("darkseagreen")); 
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_neutral.xml");
      } break;

      case Identity::SuspectJoker :
      {
        affil = SymbologyXML::SymbolTypes::t_affil::SUSPECT; 
        fillColor = QColor(QStringLiteral("orange"));
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_enemy.xml");
      } break;

      case Identity::HostileFaker :
      {
        affil = SymbologyXML::SymbolTypes::t_affil::ENEMY; 
        fillColor = QColor(QStringLiteral("red"));
        frameResource = QStringLiteral(":/Symbole/Attributes/symbolframes/frame_landunits_enemy.xml");
      } break;
    } //switch

    if (frameResource.isEmpty()) return QPixmap();

    QFile fileXml(frameResource);

    if (!fileXml.exists()) return QPixmap();

    if (!fileXml.open(QIODevice::ReadOnly | QIODevice::Text)) return QPixmap();
    frameXml = QString::fromLocal8Bit( fileXml.readAll() );
    fileXml.close();

    if (frameXml.isEmpty()) return QPixmap();

    if (!symbolReader.read(frameXml,symbol)) return QPixmap();

    symbol.setAffil(affil);
    symbol.setDimen(SymbologyXML::SymbolTypes::t_dimen::LAND_UNITS);
    symbol.setHeadquarter(false);

    QImage   *frameImage = new QImage(40,40,QImage::Format::Format_ARGB32);
    QPainter  painter(frameImage);

    painter.setRenderHints(QPainter::Antialiasing|QPainter::SmoothPixmapTransform);
  
    frameImage->fill(QColor(255,255,255,0));

    SymbologyXML::SymbolTypes::AdditionalSymbolData options;
    options.m_filltype = SymbologyXML::SymbolTypes::FILLTYPE_FILLED;

    SymbologyXML::SymbolExporter::drawFrameSymbol( symbol, options, &scene, QColor(0,0,0,255), fillColor, 0.0, true);
  
    scene.render(&painter);

    frameImageMap[value] = frameImage;

    return QPixmap::fromImage(*frameImage);

  #endif
}

SidcDefinitions::ShapeType SidcDefinitions::StandardIdentity::getShape() const
{
  switch (identity)
  {
    case Identity::Unknown:
    case Identity::Pending:
      return ShapeType::Clover;

    case Identity::Friend:
    case Identity::AssumedFriend:
      return ShapeType::Rectangle;

    case Identity::Neutral:
      return ShapeType::Square;

    case Identity::HostileFaker:
    case Identity::SuspectJoker:
      return ShapeType::Diamond;
    } // switch

    return ShapeType::Undefined;
}

QVector<SidcDefinitions::Context> SidcDefinitions::contexts()
{
  return { Context::Reality, Context::Exercise, Context::Simulation };
}


QVector<SidcDefinitions::Identity> SidcDefinitions::identities()
{
  return {Identity::Pending,
          Identity::Unknown,
          Identity::AssumedFriend,
          Identity::Friend,
          Identity::Neutral,
          Identity::SuspectJoker,
          Identity::HostileFaker};
}


QLatin1String SidcDefinitions::toString(HQTFDummy value)
{
  switch (value)
  {
  case HQTFDummy::Unknown:
    return QLatin1String("Unknown");
  case HQTFDummy::FeintDummy:
    return QLatin1String("FeintDummy");
  case HQTFDummy::Headquarters:
    return QLatin1String("Headquarters");
  case HQTFDummy::FeintDummy_Headquarters:
    return QLatin1String("FeintDummy_Headquarters");
  case HQTFDummy::TaskForce:
    return QLatin1String("TaskForce");
  case HQTFDummy::FeintDummy_TaskForce:
    return QLatin1String("FeintDummy_TaskForce");
  case HQTFDummy::TaskForce_Headquarters:
    return QLatin1String("TaskForce_Headquarters");
  case HQTFDummy::FeintDummy_TaskForce_Headquarters:
    return QLatin1String("FeintDummy_TaskForce_Headquarters");
  } // switch
  return QLatin1String("ERROR-HQTFDummy");
}


QPixmap SidcDefinitions::toPixmap(HQTFDummy value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::HQTFDummy> SidcDefinitions::hQTFDummy()
{
  return {HQTFDummy::Unknown,
          HQTFDummy::FeintDummy,
          HQTFDummy::Headquarters,
          HQTFDummy::FeintDummy_Headquarters,
          HQTFDummy::TaskForce,
          HQTFDummy::FeintDummy_TaskForce,
          HQTFDummy::TaskForce_Headquarters,
          HQTFDummy::FeintDummy_TaskForce_Headquarters
         };
}

void SidcDefinitions::HQTFDummyConverter::toBool(const SidcDefinitions::HQTFDummy &hqTfDummy, bool &headquarters, bool &taskForce, bool &feintDummy)
{
  uint asInt = static_cast<uint>(hqTfDummy);
  headquarters  = asInt & 2;  // mask
  taskForce     = asInt & 4;  // mask
  feintDummy    = asInt & 1;  // mask

}
uint SidcDefinitions::HQTFDummyConverter::toHqTfDummyAsInt(bool headquarters, bool taskForce, bool feintDummy)
{
  uint hdtffd = 0;

  if (headquarters)  hdtffd += 2;
  if (taskForce)     hdtffd += 4;
  if (feintDummy)    ++hdtffd;

  return hdtffd;
}
SidcDefinitions::HQTFDummy SidcDefinitions::HQTFDummyConverter::toHqTfDummy(bool headquarters, bool taskForce, bool feintDummy)
{
  return static_cast<HQTFDummy>(toHqTfDummyAsInt(headquarters,
                                                 taskForce,
                                                 feintDummy));
}


QLatin1String SidcDefinitions::toString(AmplifierGroup value)
{
  switch (value)
  {
  case AmplifierGroup::Unknown:
    return QLatin1String("Unknown");
  case AmplifierGroup::Echelon_BrigadeAndBelow:
    return QLatin1String("Echelon_BrigadeAndBelow");
  case AmplifierGroup::Echelon_DivisionAndAbove:
    return QLatin1String("Echelon_DivisionAndAbove");
  case AmplifierGroup::Mobility_OnLand:
    return QLatin1String("Mobility_OnLand");
  case AmplifierGroup::Mobility_OnSnow:
    return QLatin1String("Mobility_OnSnow");
  case AmplifierGroup::Mobility_OnWater:
    return QLatin1String("Mobility_OnWater");
  case AmplifierGroup::Naval_TowedArry:
    return QLatin1String("Naval_TowedArry");
  } // switch
  return QLatin1String("ERROR-AmplifierGroup");
}


QPixmap SidcDefinitions::toPixmap(AmplifierGroup value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::AmplifierGroup> SidcDefinitions::amplifierGroups()
{
  return { AmplifierGroup::Unknown,

           AmplifierGroup::Echelon_BrigadeAndBelow,
           AmplifierGroup::Echelon_DivisionAndAbove,

           AmplifierGroup::Mobility_OnLand,
           AmplifierGroup::Mobility_OnSnow,
           AmplifierGroup::Mobility_OnWater,

           AmplifierGroup::Naval_TowedArry
         };
}


QLatin1String SidcDefinitions::toString(EchelonBrigadeAndBelow value)
{
  switch (value)
  {
  case EchelonBrigadeAndBelow::Unknown:
    return QLatin1String("Unknown");
  case EchelonBrigadeAndBelow::TeamCrew:
    return QLatin1String("TeamCrew");
  case EchelonBrigadeAndBelow::Squad:
    return QLatin1String("Squad");

  case EchelonBrigadeAndBelow::Section:
    return QLatin1String("Section");
  case EchelonBrigadeAndBelow::PlatoonDetachment:
    return QLatin1String("PlatoonDetachment");
  case EchelonBrigadeAndBelow::BattalionSquadron:
    return QLatin1String("BattalionSquadron");

  case EchelonBrigadeAndBelow::CompanyBatteryTroop:
    return QLatin1String("CompanyBatteryTroop");
  case EchelonBrigadeAndBelow::RegimentGroup:
    return QLatin1String("RegimentGroup");
  case EchelonBrigadeAndBelow::Brigade:
    return QLatin1String("Brigade");
  } // switch
  return QLatin1String("ERROR-EchelonBrigadeAndBelow");
}


QPixmap  SidcDefinitions::toPixmap(EchelonBrigadeAndBelow value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::EchelonBrigadeAndBelow> SidcDefinitions::echelonBrigadeAndBelows()
{
  return { EchelonBrigadeAndBelow::Unknown,
           EchelonBrigadeAndBelow::TeamCrew,
           EchelonBrigadeAndBelow::Squad,
           EchelonBrigadeAndBelow::Section,
           EchelonBrigadeAndBelow::PlatoonDetachment,
           EchelonBrigadeAndBelow::CompanyBatteryTroop,
           EchelonBrigadeAndBelow::BattalionSquadron,
           EchelonBrigadeAndBelow::RegimentGroup,
           EchelonBrigadeAndBelow::Brigade
         };
}


QLatin1String SidcDefinitions::toString(EchelonDivisionAndAbove value)
{
  switch (value)
  {
  case EchelonDivisionAndAbove::Unknown:
    return QLatin1String("Unknown");
  case EchelonDivisionAndAbove::Division:
    return QLatin1String("Division");
  case EchelonDivisionAndAbove::CorpsMEF:
    return QLatin1String("CorpsMEF");
  case EchelonDivisionAndAbove::Army:
    return QLatin1String("Army");
  case EchelonDivisionAndAbove::Army_GroupFront:
    return QLatin1String("Army_GroupFront");
  case EchelonDivisionAndAbove::RegionTheater:
    return QLatin1String("RegionTheater");
  case EchelonDivisionAndAbove::Command:
    return QLatin1String("Command");
  } // switch
  return QLatin1String("ERROR-EchelonDivisionAndAbove");
}

QVector<SidcDefinitions::EchelonDivisionAndAbove> SidcDefinitions::echelonDivisionAndAboves()
{
  return {EchelonDivisionAndAbove::Unknown,
          EchelonDivisionAndAbove::Division,
          EchelonDivisionAndAbove::CorpsMEF,
          EchelonDivisionAndAbove::Army,
          EchelonDivisionAndAbove::Army_GroupFront,
          EchelonDivisionAndAbove::RegionTheater,
          EchelonDivisionAndAbove::Command,
         };
}


QLatin1String SidcDefinitions::toString(MobilityOnLand value)
{
  switch (value)
  {
  case MobilityOnLand::Unknown:
    return QLatin1String("Unknown");
  case MobilityOnLand::WheeledLimitedCrossCountry:
    return QLatin1String("WheeledLimitedCrossCountry");
  case MobilityOnLand::WheeledCrossCountry:
    return QLatin1String("WheeledCrossCountry");
  case MobilityOnLand::Tracked:
    return QLatin1String("Tracked");
  case MobilityOnLand::WheeledAndTrackedCombination:
    return QLatin1String("WheeledAndTrackedCombination");
  case MobilityOnLand::Towed:
    return QLatin1String("Towed");
  case MobilityOnLand::Rail:
    return QLatin1String("Rail");
  case MobilityOnLand::PackAnimal:
    return QLatin1String("PackAnimal");
  } // switch
  return QLatin1String("ERROR-MobilityOnLand");
}


QPixmap  SidcDefinitions::toPixmap(MobilityOnLand value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::MobilityOnLand> SidcDefinitions::mobilityOnLands()
{
  return { MobilityOnLand::Unknown,
           MobilityOnLand::WheeledLimitedCrossCountry,
           MobilityOnLand::WheeledCrossCountry,
           MobilityOnLand::Tracked,
           MobilityOnLand::WheeledAndTrackedCombination,
           MobilityOnLand::Towed,
           MobilityOnLand::Rail,
           MobilityOnLand::PackAnimal
         };
}


QLatin1String SidcDefinitions::toString(MobilityOnSnow value)
{
  switch (value)
  {
  case MobilityOnSnow::Unknown:
    return QLatin1String("Unknown");
  case MobilityOnSnow::OverSnow:
    return QLatin1String("OverSnow");
  case MobilityOnSnow::Sled:
    return QLatin1String("Sled");
  } // switch
  return QLatin1String("ERROR-MobilityOnSnow");
}


QPixmap  SidcDefinitions::toPixmap(MobilityOnSnow value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::MobilityOnSnow> SidcDefinitions::mobilityOnSnows()
{
  return { MobilityOnSnow::Unknown,
           MobilityOnSnow::OverSnow,
           MobilityOnSnow::Sled
         };
}

QLatin1String SidcDefinitions::toString(MobilityOnWater value)
{
  switch (value)
  {
  case MobilityOnWater::Unknown:
    return QLatin1String("Unknown");
  case MobilityOnWater::Barge:
    return QLatin1String("Barge");
  case MobilityOnWater::Amphibious:
    return QLatin1String("Amphibious");
  } // switch
  return QLatin1String("ERROR-MobilityOnWater");
}


QPixmap  SidcDefinitions::toPixmap(MobilityOnWater value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::MobilityOnWater> SidcDefinitions::mobilityOnWaters()
{
  return { MobilityOnWater::Unknown,
           MobilityOnWater::Barge,
           MobilityOnWater::Amphibious
         };
}


QLatin1String SidcDefinitions::toString(NavalTowedArray value)
{
  switch (value)
  {
  case NavalTowedArray::Unknown:
    return QLatin1String("Unknown");
  case NavalTowedArray::ShortTowedArray:
    return QLatin1String("ShortTowedArray");
  case NavalTowedArray::LongTowedArray:
    return QLatin1String("LongTowedArray");
  } // switch
  return QLatin1String("ERROR-NavalTowedArray");
}


QPixmap  SidcDefinitions::toPixmap(NavalTowedArray value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::NavalTowedArray> SidcDefinitions::navalTowedArrays()
{
  return {NavalTowedArray::Unknown,
          NavalTowedArray::ShortTowedArray,
          NavalTowedArray::LongTowedArray
         };
}

QLatin1String SidcDefinitions::toString(SymbolSet value)
{
  switch (value)
  {
  case SymbolSet::Unknown:
    return QLatin1String("Unknown");
  case SymbolSet::Air:
    return QLatin1String("Air");
  case SymbolSet::AirMissle:
    return QLatin1String("AirMissle");
  case SymbolSet::Space:
    return QLatin1String("Space");
  case SymbolSet::SpaceMissle:
    return QLatin1String("SpaceMissle");
  case SymbolSet::LandUnit:
    return QLatin1String("LandUnit");
  case SymbolSet::LandCivilian_UnitOrganisation:
    return QLatin1String("LandCivilian_UnitOrganisation");
  case SymbolSet::LandEquipment:
    return QLatin1String("LandEquipment");
  case SymbolSet::LandInstallation:
    return QLatin1String("LandInstallation");
  case SymbolSet::ControlMeasure:
    return QLatin1String("ControlMeasure");
  case SymbolSet::DismountedIndividual:
    return QLatin1String("DismountedIndividual");
  case SymbolSet::SeaSurface:
    return QLatin1String("SeaSurface");
  case SymbolSet::SeaSubSurface:
    return QLatin1String("SeaSubSurface");
  case SymbolSet::MineWarfare:
    return QLatin1String("MineWarfare");
  case SymbolSet::Activities:
    return QLatin1String("Activities");
  case SymbolSet::Atmospheric:
    return QLatin1String("Atmospheric");
  case SymbolSet::Oceanographic:
    return QLatin1String("Oceanographic");
  case SymbolSet::MeteorologicalSpace:
    return QLatin1String("MeteorologicalSpace");
  case SymbolSet::SignalsIntelligence_Space:
    return QLatin1String("SignalsIntelligence_Space");
  case SymbolSet::SignalsIntelligence_Air:
    return QLatin1String("SignalsIntelligence_Air");
  case SymbolSet::SignalsIntelligence_Land:
    return QLatin1String("SignalsIntelligence_Land");
  case SymbolSet::SignalsIntelligence_Surface:
    return QLatin1String("SignalsIntelligence_Surface");
  case SymbolSet::SignalsIntelligence_Subsurface:
    return QLatin1String("SignalsIntelligence_Subsurface");
  case SymbolSet::Cyberspace:
    return QLatin1String("Cyberspace");
  } // switch
  return QLatin1String("ERROR-SymbolSet");
}


QPixmap SidcDefinitions::toPixmap(SymbolSet value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::SymbolSet> SidcDefinitions::symbolSets()
{
  return {SymbolSet::Unknown,
          SymbolSet::Air,
          SymbolSet::AirMissle,
          SymbolSet::Space,
          SymbolSet::SpaceMissle,
          SymbolSet::LandUnit,
          SymbolSet::LandCivilian_UnitOrganisation,
          SymbolSet::LandEquipment,
          SymbolSet::LandInstallation,
          SymbolSet::ControlMeasure,
          SymbolSet::DismountedIndividual,
          SymbolSet::SeaSurface,
          SymbolSet::SeaSubSurface,
          SymbolSet::MineWarfare,
          SymbolSet::Activities,
          SymbolSet::Atmospheric,
          SymbolSet::Oceanographic,
          SymbolSet::MeteorologicalSpace,
          SymbolSet::SignalsIntelligence_Space,
          SymbolSet::SignalsIntelligence_Air,
          SymbolSet::SignalsIntelligence_Land,
          SymbolSet::SignalsIntelligence_Surface,
          SymbolSet::SignalsIntelligence_Subsurface,
          SymbolSet::Cyberspace
         };
}

QLatin1String SidcDefinitions::toString(Status value)
{
  switch (value)
  {
  case Status::Present:
    return QLatin1String("Present");
  case Status::Planned_Anticipated_Suspect:
    return QLatin1String("Planned_Anticipated_Suspect");
  case Status::Present_FullCapable:
    return QLatin1String("Present_FullCapable");
  case Status::Present_Damaged:
    return QLatin1String("Present_Damaged");
  case Status::Present_Destroyed:
    return QLatin1String("Present_Destroyed");
  case Status::Present_FullToCapacity:
    return QLatin1String("Present_FullToCapacity");
  } // switch
  return QLatin1String("ERROR-Status");
}


QPixmap SidcDefinitions::toPixmap(Status value)
{
  Q_UNUSED(value);
  return QPixmap();
}


QVector<SidcDefinitions::Status> SidcDefinitions::statuss()
{
  return
  {
    Status::Present,
    Status::Planned_Anticipated_Suspect,
    Status::Present_FullCapable,
    Status::Present_Damaged,
    Status::Present_Destroyed,
    Status::Present_FullToCapacity
  };
}


QStringList SidcDefinitions::modifierKeys() const
{
  if (!m_esriDictProcessor)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " no m_esriDictProcessor";
    return QStringList();
  }
  return m_esriDictProcessor->symbolModifierKeys();
}


QVector<ModifierData> SidcDefinitions::modifierList(SidcDefinitions::SymbolSet symbolSet, unsigned int modifierSector) const
{
  if (!m_esriDictProcessor)
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " no m_esriDictProcessor";
    return QVector<ModifierData>();
  }
  return m_esriDictProcessor->symbolModifierList(symbolSet, modifierSector);
}





//----------------------------------------------------------------------------

std::ostream &operator<< (std::ostream   &stream, const AdvancedSymbology::SidcDefinitions::ShapeType &value)
{
  stream << "ShapeType(" << AdvancedSymbology::SidcDefinitions::toString(value)
         << ")";
  return stream;
}

std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::Identity &value)
{
  stream << "Identity(" << AdvancedSymbology::SidcDefinitions::toString(value)
         << ")";
  return stream;
}

std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::SymbolSet &value)
{
  stream << "SymbolSet(" << AdvancedSymbology::SidcDefinitions::toString(value)
         << ")";
  return stream;
}

std::ostream &operator<< (std::ostream &stream, const AdvancedSymbology::SidcDefinitions::Status &value)
{
  stream << "Status(" << AdvancedSymbology::SidcDefinitions::toString(value)
         << ")";
  return stream;
}


} // namespace AdvancedSymbology