Re: Ada Popularity: Comparison of Ada/Charles with C++ STL (and Perl)

["Robert Kawulak" <tigrisek@interia.pl>]

Hi,

>>     I don't know about Ada, but in C++ you can, and such "templates
> nesting"
[...]
> Of course, you can pass the type made available via an instantiation of a
> generic package as the actual type of some other instantiation.  The
> container libraray for Ada 2005 (see AI-302) was specially designed to
> allow a container as the element of another container.

Thanks for clarification.

So returning to what Dmitry has written:

Dmitry > For instance, it is impossible to have generic programming
Dmitry > on containers of containers. You cannot have a list of items of
Dmitry > "array" types that are different instantiations. Because see above,
Dmitry > you have no that common abstract predecessor. That "arrays" are not
Dmitry > arrays, we are just fooling ourselves.

    I think I see now what Dmitry was trying to say: you cannot have a list
of "arrays" such that one its element will be of type std::vector<int>, the
other of std::valarray<int> and so on. Do I understand you well, Dmitry?
    If yes, then I admit: it can't be done directly. But it *doesn't* mean
it's impossible! Have a look at this:

/*************************************************/

#include <cstddef>
using std::size_t;

#include <list>
using std::list;

#include <vector>
using std::vector;

#include <map>
using std::map;

// STEP 1:

// Helper template for getting element
// and index type of an array type. ArrayTraits
// is meant to be specialised for any concrete
// array type.

template<typename ArrayT>
struct ArrayTraits {
  typedef ArrayT ArrayType;
}; // struct ArrayTraits<>

// Specialisation for std::vector<>

template<typename ElementT>
struct ArrayTraits< vector<ElementT> > {
  typedef typename vector<ElementT> ArrayType;
  typedef typename ArrayType::value_type ElementType;
  typedef typename ArrayType::size_type IndexType;
}; // struct ArrayTraits< vector<ElementT> >

// Specialisation for std::map<>

template<typename ElementT, typename IndexT>
struct ArrayTraits< map<IndexT, ElementT> > {
  typedef typename map<IndexT, ElementT> ArrayType;
  typedef typename ArrayType::mapped_type ElementType;
  typedef typename ArrayType::key_type IndexType;
}; // struct ArrayTraits< map<IndexT, ElementT> >

// Specialisation for C-style arrays

template<typename ElementT>
struct ArrayTraits<ElementT[]> {
  typedef ElementT ArrayType[];
  typedef ElementT ElementType;
  typedef size_t IndexType;
}; // struct ArrayTraits<ElementT[]>

// STEP 2:

// Abstract base class for the wrapper of any
// array type (here we assume that array type
// is any type having [] operator)

template<typename ElementType, typename IndexType>
struct ArrayWrapperBase {
  virtual ElementType & operator [] (const IndexType & ) = 0;
  // ...Possibly some other array-specific operations...
  virtual ~ArrayWrapperBase() {}
}; // struct ArrayWrapperBase<>

// STEP 3:

// The wrapper class template

template<typename ArrayType>
struct ArrayWrapper:
  public ArrayWrapperBase<
    typename ArrayTraits<ArrayType>::ElementType,
    typename ArrayTraits<ArrayType>::IndexType
  >
{
  typedef typename ArrayTraits<ArrayType>::ElementType ElementType;
  typedef typename ArrayTraits<ArrayType>::IndexType IndexType;
  ArrayType & mArray; // reference to actual array object
  ArrayWrapper(ArrayType & A): mArray(A) {}
  ElementType & operator [] (const IndexType & i) { return mArray[i]; };
}; // struct ArrayWrapper<>

// STEP 4:

// Use!

int main()
{

  vector<int> AVector(10);
  ArrayWrapper< vector<int> > WrappedVector(AVector);

  map<size_t, int> AMap;
  ArrayWrapper< map<size_t, int> > WrappedMap(AMap);

  int AnArray[10];
  ArrayWrapper< int[] > WrappedArray(AnArray);

  typedef list<ArrayWrapperBase<int, size_t> *> ListOfArrays;
  ListOfArrays MyList; // list of arrays of any kind holding ints

  // creme de la creme:
  MyList.push_back(&WrappedVector);
  MyList.push_back(&WrappedMap);
  MyList.push_back(&WrappedArray);

  // the three instructions are equivalent:
  AVector[7] = 27182;
  WrappedVector[7] = 27182;
  (*MyList.front())[7] = 27182;

  // setting 5-th element of every array to 31415:
  for(ListOfArrays::iterator i = MyList.begin(); i != MyList.end(); i++)
    (**i)[4] = 31415;

} // main()


/*************************************************/

    Long and complicated? Indeed. But on the other hand I have never heard
of anybody who needed this. Yet it's possible ;-).

Best regards,
Robert Kawulak