[snip]
Function should not change the FunctionSpace (that's why FunctionSpace is
const). FunctionSpace shouldn't depend on the data and its size should be
defined when creating the FunctionSpace.
The same applies for FunctionSpace as its member variables are private
and the public accessors are read-only which. Consider a sub-class
ImageFunctionSpace:FunctionSpace, with a constructor like:
ImageFunctionSpace(ImageType *imagePtr)
where imagePtr is supposed to initialise FunctionSpace::_mesh using
the image size, and then _dofmaps itself is initialised using _mesh.
How would you do that considering the restrictions?
The FunctionSpace has pointers to the mesh, etc. You just need to create
your mesh and pass it to the FunctionSpace constructor. What else you then
do with the mesh, etc is up to you.
That can be done _outside_ of a sub-class. A sub-class of
FunctionSpace doesn't have a control over _mesh of its own parent
FunctionSpace. The following example may make this more clear:
template <typename TImage>
class DolfinImageFunctionSpace : public dolfin::FunctionSpace
{
public:
// just some itk typedefs -- ignore
typedef TImage ImageType;
typedef typename ImageType::PixelType PixelType;
typedef typename ImageType::SizeType SizeType;
// .. and some dolfin typedefs -- ignore
typedef typename std::tr1::shared_ptr<const dolfin::Mesh> MeshConstPointerType;
typedef typename std::tr1::shared_ptr<const dolfin::FiniteElement>
ElementConstPointerType;
typedef typename std::tr1::shared_ptr<const dolfin::DofMap>
DofMapConstPointerType;
// the ctor
DolfinImageFunctionSpace(ImageType* imageData,
MeshConstPointerType mesh,
ElementConstPointerType element,
DofMapConstPointerType dofmap) :
dolfin::FunctionSpace(mesh, element, dofmap)
{
SizeType imageSize = imageData->GetBufferedRegion().GetSize();
// here, we whish to call some thing like:
// _mesh = UnitSquare(imageSize[0], imageSize[1]);
// but it's private and the accessor is read-only.
};
}
