#include <vector>
#include <iostream>

//#define USE_TRANS_PART_HELPER // activate to see my non compiling trials

struct PartA;
struct PartB;

// there are serveral variants of the PartTransformer doing different output for Part-Variants

struct PartTransformer
{
	virtual void TransformPartA(const PartA& part) = 0;
	virtual void TransformPartB(const PartB& part) = 0;
};

struct Part {
	virtual void Transform(PartTransformer& transformer) const = 0;
};

struct PartA : Part {
	// specials content of PartA...
	double _value;
	PartA(const double value) :_value(value) {}
	void Transform(PartTransformer& transformer) const override {
		transformer.TransformPartA(*this);
	}
};

#ifndef USE_TRANS_PART_HELPER

struct PartB : Part {
	// specials content of PartB...
	int _value;
	PartB(const int value) :_value(value) {}
	void Transform(PartTransformer& transformer) const override {
		transformer.TransformPartB(*this);
	}
};

#else

// QUESTION !!! // is is possible to have some sort of Tranform-Write helper template // that is specialized with only the to call transformer-method?
// sort of - following does not compile :(
template<typename Method> struct TransPart : Part {
	void Transform(PartTransformer& transformer) const override {
		(transformer.*Method)(*this);
	}
}

struct PartB : TransPart<PartTransformer::TransformPartB>
{
	// specials content of PartB...
	int _value;
	PartB(const int value) :_value(value) {}
	// Transform should be implemented by TransPart template
};

#endif

struct PrintPartTransformer : PartTransformer {
	virtual void TransformPartA(const PartA& part) {
		std::cout << "TransformPartA : double value: " << part._value << std::endl;
	}
	virtual void TransformPartB(const PartB& part) {
		std::cout << "TransformPartB : int value: " << part._value << std::endl;
	}
};

int main() {
	std::vector<Part*> parts;
	// power leaking :) parts.push_back(new PartA(12.33)); parts.push_back(new PartB(1233));
	PrintPartTransformer transformer;
	for (const auto& part : parts) {
		part->Transform(transformer);
	}
}