Overview | Modules | Class Hierarchy | Classes | Members

# Plugins

## Classes

- class tlp::Algorithm
    Interface for general algorithm plug-ins. More...
- class tlp::AlgorithmFactory
- class tlp::BooleanAlgorithm
    Interface for selection plug-ins. More...
- class tlp::ColorAlgorithm
    Interface for color plug-ins. More...
- class tlp::DoubleAlgorithm
    Interface for metric plug-ins. More...
- class tlp::ExportModule
    Interface for exportModule plug-ins. More...
- class tlp::ExportModuleFactory
- class tlp::ImportModule
    Interface for importModule plug-ins. More...
- class tlp::ImportModuleFactory
- class tlp::IntegerAlgorithm
    Interface for int plug-ins. More...
- class tlp::LayoutAlgorithm
    Interface for layout plug-ins. More...
- class tlp::AlgorithmContext
    Parameter for calling clustering plugins. More...
- class tlp::PropertyContext
    Parameter for calling Property plugins. More...
- class tlp::PropertyAlgorithm
- class tlp::SizeAlgorithm
    Interface for sizes plug-ins. More...
- class tlp::StringAlgorithm
    Interface for String plug-ins. More...
- class tlp::TemplateFactoryInterface
- class tlp::TemplateFactory< ObjectFactory, ObjectType, Context >
- class tlp::PropertyFactory< T >
- struct tlp::Dependency
- class tlp::WithDependency
- struct tlp::WithParameter

## Defines

- #define PROPERTYPLUGINFACTORY(T, C, N, A, D, I, R, G)
    Macro for factorization of source code pf Properties plugin mechanism.
- #define BOOLEANPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Boolean,C,N,A,D,I,R,G)
- #define BOOLEANPLUGIN(C, N, A, D, I, R) BOOLEANPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define COLORPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Color,C,N,A,D,I,R,G)
- #define COLORPLUGIN(C, N, A, D, I, R) COLORPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define DOUBLEPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Double,C,N,A,D,I,R,G)
- #define DOUBLEPLUGIN(C, N, A, D, I, R) DOUBLEPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define GRAPHPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Graph,C,N,A,D,I,R,G)
- #define GRAPHPLUGIN(C, N, A, D, I, R) GRAPHPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define INTEGERPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Integer,C,N,A,D,I,R,G)
- #define INTEGERPLUGIN(C, N, A, D, I, R) INTEGERPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define LAYOUTPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Layout,C,N,A,D,I,R,G)
- #define LAYOUTPLUGIN(C, N, A, D, I, R) LAYOUTPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define SIZEPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(Size,C,N,A,D,I,R,G)
- #define SIZEPLUGIN(C, N, A, D, I, R) SIZEPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define STRINGPLUGINOFGROUP(C, N, A, D, I, R, G) PROPERTYPLUGINFACTORY(String,C,N,A,D,I,R,G)
- #define STRINGPLUGIN(C, N, A, D, I, R) STRINGPLUGINOF(C,N,A,D,I,R,"")
- #define GRAPHPLUGINFACTORY(T, C, N, A, D, I, R, G)
    Macro for factorization of source code of Graph modification plugin mechanism.
- #define ALGORITHMPLUGINOFGROUP(C, N, A, D, I, R, G) GRAPHPLUGINFACTORY(Algorithm,C,N,A,D,I,R,G)
- #define ALGORITHMPLUGIN(C, N, A, D, I, R) ALGORITHMPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define EXPORTPLUGINOFGROUP(C, N, A, D, I, R, G) GRAPHPLUGINFACTORY(ExportModule,C,N,A,D,I,R,G)
- #define EXPORTPLUGIN(C, N, A, D, I, R) EXPORTPLUGINOFGROUP(C,N,A,D,I,R,"")
- #define IMPORTPLUGINOFGROUP(C, N, A, D, I, R, G) GRAPHPLUGINFACTORY(ImportModule,C,N,A,D,I,R,G)
- #define IMPORTPLUGIN(C, N, A, D, I, R) IMPORTPLUGINOFGROUP(C,N,A,D,I,R,"")

## Functions

- virtual tlp::BooleanAlgorithm::~BooleanAlgorithm ()
- tlp::BooleanAlgorithm::BooleanAlgorithm (const PropertyContext &)

## Variables

- BooleanProperty * tlp::BooleanAlgorithm::booleanResult

## Define Documentation

#define ALGORITHMPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | ALGORITHMPLUGINOFGROUP(C,N,A,D,I,R,"")

#define ALGORITHMPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | GRAPHPLUGINFACTORY(Algorithm,C,N,A,D,I,R,G)

#define BOOLEANPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | BOOLEANPLUGINOFGROUP(C,N,A,D,I,R,"")

#define BOOLEANPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Boolean,C,N,A,D,I,R,G)

#define COLORPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | COLORPLUGINOFGROUP(C,N,A,D,I,R,"")

#define COLORPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Color,C,N,A,D,I,R,G)

#define DOUBLEPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | DOUBLEPLUGINOFGROUP(C,N,A,D,I,R,"")

#define DOUBLEPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Double,C,N,A,D,I,R,G)

#define EXPORTPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | EXPORTPLUGINOFGROUP(C,N,A,D,I,R,"")

#define EXPORTPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | GRAPHPLUGINFACTORY(ExportModule,C,N,A,D,I,R,G)

#define GRAPHPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | GRAPHPLUGINOFGROUP(C,N,A,D,I,R,"")

#define GRAPHPLUGINFACTORY | ( | T,
|  | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) |

Value:

    class C##T##Factory:public tlp::T##Factory              \
    {                                                       \
     public:                                  \
      C##T##Factory(){                              \
        initFactory();                              \
        factory->registerPlugin(this);              \
      }                                       \
      ~C##T##Factory(){}                            \
      std::string getName() const { return std::string(N);}     \
      std::string getGroup() const { return std::string(G);}\
      std::string getAuthor() const {return std::string(A);}\
      std::string getDate() const {return std::string(D);}      \
      std::string getInfo() const {return std::string(I);}      \
      std::string getRelease() const {return std::string(R);}\
      std::string getTulipRelease() const {return std::string(TULIP_RELEASE);}\
      tlp::T * createPluginObject(AlgorithmContext context)     \
       {                                      \
         C *tmp=new C(context);                     \
         return ((tlp::T *) tmp);                   \
       }                                      \
    };                                                      \
    extern "C" {                                            \
      C##T##Factory C##T##FactoryInitializer;               \
    }

Macro for factorization of source code of Graph modification plugin mechanism.

#define GRAPHPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Graph,C,N,A,D,I,R,G)

#define IMPORTPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | IMPORTPLUGINOFGROUP(C,N,A,D,I,R,"")

#define IMPORTPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | GRAPHPLUGINFACTORY(ImportModule,C,N,A,D,I,R,G)

#define INTEGERPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | INTEGERPLUGINOFGROUP(C,N,A,D,I,R,"")

#define INTEGERPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Integer,C,N,A,D,I,R,G)

#define LAYOUTPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | LAYOUTPLUGINOFGROUP(C,N,A,D,I,R,"")

#define LAYOUTPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Layout,C,N,A,D,I,R,G)

#define PROPERTYPLUGINFACTORY | ( | T,
|  | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) |

Value:

    class C##T##Factory:public tlp::PropertyFactory<tlp::T##Algorithm>      \
    {                                                       \
     public:                                  \
      C##T##Factory(){                              \
        tlp::T##Property::initFactory();                  \
        tlp::T##Property::factory->registerPlugin((tlp::PropertyFactory<tlp::T##Algorithm> *) this); \
      }                                       \
      ~C##T##Factory(){}                            \
      std::string getClassName() const { return std::string(#T);} \
      std::string getName() const { return std::string(N);}     \
      std::string getGroup() const { return std::string(G);}\
      std::string getAuthor() const {return std::string(A);}\
      std::string getDate() const {return std::string(D);}      \
      std::string getInfo() const {return std::string(I);}      \
      std::string getRelease() const {return std::string(R);}\
      std::string getTulipRelease() const {return std::string(TULIP_RELEASE);}\
      tlp::T##Algorithm * createPluginObject(const tlp::PropertyContext &context)\
       {                                      \
         C *tmp=new C(context);                     \
         return ((tlp::T##Algorithm *) tmp);        \
       }                                      \
    };                                                      \
    extern "C" {                                            \
      C##T##Factory C##T##FactoryInitializer;               \
    }

Macro for factorization of source code pf Properties plugin mechanism.

#define SIZEPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | SIZEPLUGINOFGROUP(C,N,A,D,I,R,"")

#define SIZEPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(Size,C,N,A,D,I,R,G)

#define STRINGPLUGIN | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R |  | ) | STRINGPLUGINOF(C,N,A,D,I,R,"")

#define STRINGPLUGINOFGROUP | ( | C,
|  | N,
|  | A,
|  | D,
|  | I,
|  | R,
|  | G |  | ) | PROPERTYPLUGINFACTORY(String,C,N,A,D,I,R,G)

## Function Documentation

tlp::BooleanAlgorithm::BooleanAlgorithm | ( | const PropertyContext & |  | ) | `[protected, inherited]`

virtual tlp::BooleanAlgorithm::~BooleanAlgorithm | ( |  | ) | `[inline, virtual, inherited]`

## Variable Documentation

BooleanProperty* tlp::BooleanAlgorithm::booleanResult`[inherited]`

| This Boolean is the one associated to the algorithm, The data should be store in it

Tulip Software by LaBRI Visualization Team 2001 - 2010