prepare BlockIdentifier to be accessed easier

apply singleton pattern to remaining *Identifier objects

biomeidentifier.cpp

@@ -196,6 +196,11 @@ BiomeIdentifier::~BiomeIdentifier() {
   }
 }
 
+BiomeIdentifier& BiomeIdentifier::Instance() {
+  static BiomeIdentifier singleton;
+  return singleton;
+}
+
 BiomeInfo &BiomeIdentifier::getBiome(int biome) {
   QList<BiomeInfo*> &list = biomes[biome];
   // search backwards for priority sorting to work

biomeidentifier.h

@@ -44,13 +44,21 @@ class BiomeInfo {
 
 class BiomeIdentifier {
  public:
-  BiomeIdentifier();
-  ~BiomeIdentifier();
+  // singleton: access to global usable instance
+  static BiomeIdentifier &Instance();
+
   int addDefinitions(JSONArray *, int pack = -1);
   void enableDefinitions(int id);
   void disableDefinitions(int id);
   BiomeInfo &getBiome(int id);
- private:
+
+private:
+  // singleton: prevent access to constructor and copyconstructor
+  BiomeIdentifier();
+  ~BiomeIdentifier();
+  BiomeIdentifier(const BiomeIdentifier &);
+  BiomeIdentifier &operator=(const BiomeIdentifier &);
+
   QHash<int, QList<BiomeInfo*>> biomes;
   QList<QList<BiomeInfo*> > packs;
 };

blockidentifier.cpp

@@ -80,6 +80,11 @@ bool BlockInfo::biomeFoliage() { return foliage; }
 void BlockInfo::setBiomeGrass(bool value)   { grass = value; }
 void BlockInfo::setBiomeFoliage(bool value) { foliage = value; }
 
+
+// --------- --------- --------- ---------
+// BlockIdentifier
+// --------- --------- --------- ---------
+
 BlockIdentifier::BlockIdentifier() {
   for (int i = 0; i < 16; i++)
     unknownBlock.colors[i] = 0xff00ff;
@@ -94,6 +99,11 @@ BlockIdentifier::~BlockIdentifier() {
   }
 }
 
+BlockIdentifier& BlockIdentifier::Instance() {
+  static BlockIdentifier singleton;
+  return singleton;
+}
+
 BlockInfo &BlockIdentifier::getBlockInfo(uint hid) {
   // first apply the mask
   if (blocks.contains(hid)) {

blockidentifier.h

@@ -68,13 +68,21 @@ class BlockInfo {
 
 class BlockIdentifier {
  public:
-  BlockIdentifier();
-  ~BlockIdentifier();
+  // singleton: access to global usable instance
+  static BlockIdentifier &Instance();
+
   int addDefinitions(JSONArray *, int pack = -1);
   void enableDefinitions(int id);
   void disableDefinitions(int id);
   BlockInfo &getBlockInfo(uint hid);
- private:
+
+private:
+  // singleton: prevent access to constructor and copyconstructor
+  BlockIdentifier();
+  ~BlockIdentifier();
+  BlockIdentifier(const BlockIdentifier &);
+  BlockIdentifier &operator=(const BlockIdentifier &);
+
   void parseDefinition(JSONObject *block, BlockInfo *parent, int pack);
   QMap<uint, BlockInfo*> blocks;
   QList<QList<BlockInfo*> > packs;

chunk.cpp

@@ -6,7 +6,7 @@
 #include "./flatteningconverter.h"
 
 quint16 getBits(const unsigned char *data, int pos, int n) {
-  quint16 result = 0;
+//  quint16 result = 0;
   int arrIndex = pos/8;
   int bitIndex = pos%8;
   quint32 loc =

definitionmanager.cpp

@@ -24,8 +24,12 @@
 DefinitionManager::DefinitionManager(QWidget *parent) :
     QWidget(parent),
     isUpdating(false),
+    dimensionManager(DimensionIdentifier::Instance()),
+    blockManager(BlockIdentifier::Instance()),
+    biomeManager(BiomeIdentifier::Instance()),
     entityManager(EntityIdentifier::Instance()),
-    flatteningConverter(FlatteningConverter::Instance()) {
+    flatteningConverter(FlatteningConverter::Instance())
+{
   setWindowFlags(Qt::Window);
   setWindowTitle(tr("Definitions"));
 
@@ -67,10 +71,6 @@ DefinitionManager::DefinitionManager(QWidget *parent) :
   emit packSelected(false);
   setLayout(layout);
 
-  dimensionManager = new DimensionIdentifier;
-  blockManager = new BlockIdentifier;
-  biomeManager = new BiomeIdentifier;
-
   QSettings settings;
   sorted = settings.value("packs").toList();
 
@@ -97,21 +97,8 @@ DefinitionManager::DefinitionManager(QWidget *parent) :
   refresh();
 }
 
-DefinitionManager::~DefinitionManager() {
-  delete dimensionManager;
-  delete blockManager;
-  delete biomeManager;
-}
+DefinitionManager::~DefinitionManager() {}
 
-BlockIdentifier *DefinitionManager::blockIdentifier() {
-  return blockManager;
-}
-BiomeIdentifier *DefinitionManager::biomeIdentifier() {
-  return biomeManager;
-}
-DimensionIdentifier *DefinitionManager::dimensionIdentifer() {
-  return dimensionManager;
-}
 
 void DefinitionManager::refresh() {
   table->clearContents();
@@ -154,21 +141,21 @@ void DefinitionManager::toggledPack(bool onoff) {
     switch (def.type) {
       case Definition::Block:
         if (onoff)
-          blockManager->enableDefinitions(def.id);
+          blockManager.enableDefinitions(def.id);
         else
-          blockManager->disableDefinitions(def.id);
+          blockManager.disableDefinitions(def.id);
         break;
       case Definition::Biome:
         if (onoff)
-          biomeManager->enableDefinitions(def.id);
+          biomeManager.enableDefinitions(def.id);
         else
-          biomeManager->disableDefinitions(def.id);
+          biomeManager.disableDefinitions(def.id);
         break;
       case Definition::Dimension:
         if (onoff)
-          dimensionManager->enableDefinitions(def.id);
+          dimensionManager.enableDefinitions(def.id);
         else
-          dimensionManager->disableDefinitions(def.id);
+          dimensionManager.disableDefinitions(def.id);
         break;
       case Definition::Entity:
         if (onoff)
@@ -178,14 +165,14 @@ void DefinitionManager::toggledPack(bool onoff) {
         break;
       case Definition::Pack:
         if (onoff) {
-          blockManager->enableDefinitions(def.blockid);
-          biomeManager->enableDefinitions(def.biomeid);
-          dimensionManager->enableDefinitions(def.dimensionid);
+          blockManager.enableDefinitions(def.blockid);
+          biomeManager.enableDefinitions(def.biomeid);
+          dimensionManager.enableDefinitions(def.dimensionid);
           entityManager.enableDefinitions(def.entityid);
         } else {
-          blockManager->disableDefinitions(def.blockid);
-          biomeManager->disableDefinitions(def.biomeid);
-          dimensionManager->disableDefinitions(def.dimensionid);
+          blockManager.disableDefinitions(def.blockid);
+          biomeManager.disableDefinitions(def.biomeid);
+          dimensionManager.disableDefinitions(def.dimensionid);
           entityManager.disableDefinitions(def.entityid);
         }
         break;
@@ -401,15 +388,15 @@ void DefinitionManager::loadDefinition(QString path) {
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Converter;
     } else if (type == "flatblock") {
-      d.id = blockManager->addDefinitions(
+      d.id = blockManager.addDefinitions(
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Block;
     } else if (type == "biome") {
-      d.id = biomeManager->addDefinitions(
+      d.id = biomeManager.addDefinitions(
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Biome;
     } else if (type == "dimension") {
-      d.id = dimensionManager->addDefinitions(
+      d.id = dimensionManager.addDefinitions(
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Dimension;
     } else if (type == "entity") {
@@ -455,13 +442,13 @@ void DefinitionManager::loadDefinition(QString path) {
 //        d.blockid = flatteningConverter->addDefinitions(
 //            dynamic_cast<JSONArray*>(def->at("data")), d.blockid);
       } else if (type == "flatblock") {
-          d.blockid = blockManager->addDefinitions(
+          d.blockid = blockManager.addDefinitions(
               dynamic_cast<JSONArray*>(def->at("data")), d.blockid);
       } else if (type == "biome") {
-        d.biomeid = biomeManager->addDefinitions(
+        d.biomeid = biomeManager.addDefinitions(
             dynamic_cast<JSONArray*>(def->at("data")), d.biomeid);
       } else if (type == "dimension") {
-        d.dimensionid = dimensionManager->addDefinitions(
+        d.dimensionid = dimensionManager.addDefinitions(
             dynamic_cast<JSONArray*>(def->at("data")), d.dimensionid);
       } else if (type == "entity") {
         d.entityid = entityManager.addDefinitions(
@@ -480,21 +467,21 @@ void DefinitionManager::removeDefinition(QString path) {
   if (def.path == path) {
     switch (def.type) {
       case Definition::Block:
-        blockManager->disableDefinitions(def.id);
+        blockManager.disableDefinitions(def.id);
         break;
       case Definition::Biome:
-        biomeManager->disableDefinitions(def.id);
+        biomeManager.disableDefinitions(def.id);
         break;
       case Definition::Dimension:
-        dimensionManager->disableDefinitions(def.id);
+        dimensionManager.disableDefinitions(def.id);
         break;
       case Definition::Entity:
         entityManager.disableDefinitions(def.id);
         break;
       case Definition::Pack:
-        blockManager->disableDefinitions(def.blockid);
-        biomeManager->disableDefinitions(def.biomeid);
-        dimensionManager->disableDefinitions(def.dimensionid);
+        blockManager.disableDefinitions(def.blockid);
+        biomeManager.disableDefinitions(def.biomeid);
+        dimensionManager.disableDefinitions(def.dimensionid);
         entityManager.disableDefinitions(def.entityid);
         break;
     }

definitionmanager.h

@@ -43,9 +43,6 @@ class DefinitionManager : public QWidget {
   QSize minimumSizeHint() const;
   QSize sizeHint() const;
 
-  BlockIdentifier *blockIdentifier();
-  BiomeIdentifier *biomeIdentifier();
-  DimensionIdentifier *dimensionIdentifer();
   void autoUpdate();
 
  signals:
@@ -74,10 +71,10 @@ class DefinitionManager : public QWidget {
   void removeDefinition(QString path);
   void refresh();
   QHash<QString, Definition> definitions;
-  BiomeIdentifier *biomeManager;  // todo: migrate to reference to singleton
-  BlockIdentifier *blockManager;  // todo: migrate to reference to singleton
-  DimensionIdentifier *dimensionManager;  // todo: migrate to reference to singleton
-  EntityIdentifier &entityManager;
+  BiomeIdentifier     &biomeManager;
+  BlockIdentifier     &blockManager;
+  DimensionIdentifier &dimensionManager;
+  EntityIdentifier    &entityManager;
   FlatteningConverter &flatteningConverter;
   QString selected;
   QList<QVariant> sorted;

dimensionidentifier.cpp

@@ -15,6 +15,11 @@ class DimensionDef {
   bool enabled;
 };
 
+
+// --------- --------- --------- ---------
+// DimensionIdentifier
+// --------- --------- --------- ---------
+
 DimensionIdentifier::DimensionIdentifier() {
   group = NULL;
 }
@@ -25,6 +30,12 @@ DimensionIdentifier::~DimensionIdentifier() {
   }
 }
 
+DimensionIdentifier& DimensionIdentifier::Instance() {
+  static DimensionIdentifier singleton;
+  return singleton;
+}
+
+
 void DimensionIdentifier::enableDefinitions(int pack) {
   if (pack < 0) return;
   int len = packs[pack].length();
@@ -85,6 +96,7 @@ void DimensionIdentifier::removeDimensions(QMenu *menu) {
     group = NULL;
   }
 }
+
 void DimensionIdentifier::getDimensions(QDir path, QMenu *menu,
                                         QObject *parent) {
   // first get the currently selected dimension so it doesn't change

dimensionidentifier.h

@@ -27,8 +27,9 @@ class DimensionIdentifier : public QObject {
   Q_OBJECT
 
  public:
-  DimensionIdentifier();
-  ~DimensionIdentifier();
+  // singleton: access to global usable instance
+  static DimensionIdentifier &Instance();
+
   int addDefinitions(JSONArray *, int pack = -1);
   void enableDefinitions(int id);
   void disableDefinitions(int id);
@@ -42,6 +43,12 @@ class DimensionIdentifier : public QObject {
   void viewDimension();
 
  private:
+  // singleton: prevent access to constructor and copyconstructor
+  DimensionIdentifier();
+  ~DimensionIdentifier();
+  DimensionIdentifier(const DimensionIdentifier &);
+  DimensionIdentifier &operator=(const DimensionIdentifier &);
+
   void addDimension(QDir path, QString dir, QString name, int scale,
                     QObject *parent);
   QList<QAction *> items;

entityidentifier.cpp

@@ -12,6 +12,11 @@ EntityInfo::EntityInfo(QString name, QString category, QColor brushColor,
 static EntityInfo entityDummy("Name unknown", "Others",  // Name Category
                               Qt::black, Qt::black);     // Black circle with Black border
 
+
+// --------- --------- --------- ---------
+// EntityIdentifier
+// --------- --------- --------- ---------
+
 EntityIdentifier::EntityIdentifier() {}
 EntityIdentifier::~EntityIdentifier() {}
 

flatteningconverter.cpp

@@ -23,14 +23,14 @@ BlockData * FlatteningConverter::getPalette() {
   return palette;
 }
 
-void FlatteningConverter::enableDefinitions(int pack) {
+void FlatteningConverter::enableDefinitions(int /*pack*/) {
 //  if (pack < 0) return;
 //  int len = packs[pack].length();
 //  for (int i = 0; i < len; i++)
 //    packs[pack][i]->enabled = true;
 }
 
-void FlatteningConverter::disableDefinitions(int pack) {
+void FlatteningConverter::disableDefinitions(int /*pack*/) {
 //  if (pack < 0) return;
 //  int len = packs[pack].length();
 //  for (int i = 0; i < len; i++)