PropertyAlgorithm.h

/*
 *
 * This file is part of Tulip (https://tulip.labri.fr)
 *
 * Authors: David Auber and the Tulip development Team
 * from LaBRI, University of Bordeaux
 *
 * Tulip is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *
 * Tulip is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 */
 
#ifndef PROPERTYALGORITHM_H
#define PROPERTYALGORITHM_H
 
#include <tulip/Algorithm.h>
#include <tulip/Graph.h>
 
namespace tlp {
class PluginContext;
static const std::string PROPERTY_ALGORITHM_CATEGORY = "Property";
 
/**
 * @ingroup Plugins
 * @brief A non-template interface for tlp::TypedPropertyAlgorithm
 * @see tlp::TypedPropertyAlgorithm
 **/
class TLP_SCOPE PropertyAlgorithm : public tlp::Algorithm {
public:
  PropertyAlgorithm(const tlp::PluginContext *context) : Algorithm(context) {}
  std::string category() const override {
    return PROPERTY_ALGORITHM_CATEGORY;
  }
};
 
template <class Property>
class TLP_SCOPE TypedPropertyAlgorithm : public PropertyAlgorithm {
public:
  Property *result;
  TypedPropertyAlgorithm(const tlp::PluginContext *context)
      : PropertyAlgorithm(context), result(nullptr) {
    if (dataSet != nullptr) {
      if (!dataSet->exists("result")) {
        std::string propname("result");
        unsigned number = 0;
 
        while (graph->existProperty(propname)) {
          propname.clear();
          propname += "result" + std::to_string(number);
          ++number;
        }
 
        result = graph->getProperty<Property>(propname);
      } else {
        dataSet->get("result", result);
      }
    }
  }
 
  std::string category() const override {
    return PROPERTY_ALGORITHM_CATEGORY;
  }
};
 
class BooleanProperty;
static const std::string BOOLEAN_ALGORITHM_CATEGORY = "Selection";
 
/**
 * @ingroup Plugins
 * @brief The Boolean algorithm takes a graph as input and output its results as a
 * tlp::BooleanProperty
 */
class TLP_SCOPE BooleanAlgorithm : public TypedPropertyAlgorithm<tlp::BooleanProperty> {
protected:
  BooleanAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return BOOLEAN_ALGORITHM_CATEGORY;
  }
};
 
class ColorProperty;
static const std::string COLOR_ALGORITHM_CATEGORY = "Coloring";
 
/**
 * @ingroup Plugins
 * @brief The color algorithm takes a graph as input and output its results as a tlp::ColorProperty
 */
class TLP_SCOPE ColorAlgorithm : public TypedPropertyAlgorithm<tlp::ColorProperty> {
protected:
  ColorAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return COLOR_ALGORITHM_CATEGORY;
  }
};
 
class DoubleProperty;
static const std::string DOUBLE_ALGORITHM_CATEGORY = "Measure";
 
/**
 * @ingroup Plugins
 * @brief The double algorithm takes a graph as input and output its results as a
 * tlp::DoubleProperty
 */
class TLP_SCOPE DoubleAlgorithm : public TypedPropertyAlgorithm<tlp::DoubleProperty> {
protected:
  ///
  DoubleAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return DOUBLE_ALGORITHM_CATEGORY;
  }
};
 
class IntegerProperty;
static const std::string INTEGER_ALGORITHM_CATEGORY = "Measure";
 
/**
 * @ingroup Plugins
 * @brief The integer algorithm takes a graph as input and output its results as a
 * tlp::IntegerProperty
 */
class TLP_SCOPE IntegerAlgorithm : public TypedPropertyAlgorithm<tlp::IntegerProperty> {
protected:
  IntegerAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return INTEGER_ALGORITHM_CATEGORY;
  }
};
 
class LayoutProperty;
static const std::string LAYOUT_ALGORITHM_CATEGORY = "Layout";
 
/**
 * @ingroup Plugins
 * @brief The layout algorithm takes a graph as input and output its results as a
 * tlp::LayoutProperty
 */
class TLP_SCOPE LayoutAlgorithm : public TypedPropertyAlgorithm<tlp::LayoutProperty> {
protected:
  ///
  LayoutAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return LAYOUT_ALGORITHM_CATEGORY;
  }
};
 
class SizeProperty;
static const std::string SIZE_ALGORITHM_CATEGORY = "Resizing";
 
/**
 * @ingroup Plugins
 * @brief The size algorithm takes a graph as input and output its results as a tlp::SizeProperty
 */
class TLP_SCOPE SizeAlgorithm : public TypedPropertyAlgorithm<tlp::SizeProperty> {
protected:
  SizeAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return SIZE_ALGORITHM_CATEGORY;
  }
};
 
class StringProperty;
static const std::string STRING_ALGORITHM_CATEGORY = "Labeling";
 
/**
 * @ingroup Plugins
 * @brief The string algorithm takes a graph as input and output its results as a
 * tlp::StringProperty
 */
class TLP_SCOPE StringAlgorithm : public TypedPropertyAlgorithm<tlp::StringProperty> {
protected:
  ///
  StringAlgorithm(const tlp::PluginContext *, bool needInOutResult = false);
 
public:
  std::string category() const override {
    return STRING_ALGORITHM_CATEGORY;
  }
};
} // namespace tlp
 
#endif // PROPERTYALGORITHM_H