How to overload generic method for specific type of template argument

[Dorian Gray]

Hi,

I am porting C++ application to java and I have a problem with Genric method.

I have generic class which should implement functionality depending on template argument.

abstract class TypeWrapper<T> {
  T val;
  TypeWrapper(T t) { val = t; }
  abstract saveToStream(MyStream) s;
}

class Worker {
  <T> void streamIt(MyStream s, T val) {
    TypeWrapper<T> tp = new TypeWrapper<T>(val);
    tp.saveToStream(s);
  }
}

T should wrap plenty of different types of types and they differe in way to stream. Only method which is specific to each type is "saveToStream".
In C++ it is very easy:

// pseudo Java code:
TypeWrapper<int> {
  void saveToStream() {
    //int specific code
  }
}

As a solution I have created set of saveToStream() methods (for every type of parameter) and the same set of subclasses of generic class. It is "ugly" comparing to C++. Is there something more elegant?

BR

[Rob Spoor]

Java also knows generics, but only for objects - not for the primitive types. You can use the wrapper classes however: TypeWrapper<Integer>.

[Dorian Gray]

I did it but it does not solve problem. I still need declaration of method for every argument type (primitive or wrapper around primitive)

This is copy of C++ code:

template <class T> class SearchAttributeT {
		T mVal;
		public:
			SearchAttributeT( const T& val) {
				mVal=val;
			}
			virtual const void* GetAddressOfAttributeValue();
}

template <typename T> void AddAttribute(const T& val) {
	SearchAttributeT< T >* const attrib = new SearchAttributeT< T >( val);
	mSearchAttributes.push_back(attrib);
}

and finaly implementation for every type parameter:

const void* SearchCriterionAttributeT<int>::GetAddressOfAttributeValue() {
	return &mVal;
}

const void* SearchCriterionAttributeT<String>::GetAddressOfAttributeValue() {
	return mVal.c_str();
}
    

In java I have to create classes for each object type I am using (Int, Boolean, String,...) and same number of methods:

void AddAttributeInt(Int val) {
	SearchAttributeInt const attrib = new SearchAttributeInt( val);
	mSearchAttributes.push_back(attrib);
}
    

Curently 8 new classes and 8 method overloads while in C++ only 8 methods are overload.

It would be good if I can create one method only where compiler will realize which concreate class to use

BR

[Maneesh Godbole]

"Dorian Gray",
Please check your private messages for an important administrative matter.