Loading...
Searching...
No Matches
LinearAlgebraObject.h
// Copyright (C) 2007-2012 Anders Logg, Garth N. Wells, Ola Skavhaug,
// Martin Alnæs
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// First added: 2012-08-22
// Last changed: 2012-08-24
#ifndef __LINEAR_ALGEBRA_OBJECT_H
#define __LINEAR_ALGEBRA_OBJECT_H
#include <memory>
#include <dolfin/common/MPI.h>
#include <dolfin/common/Variable.h>
namespace dolfin
{
class LinearAlgebraObject : public virtual Variable
{
public:
virtual const LinearAlgebraObject* instance() const
{ return this; }
virtual LinearAlgebraObject* instance()
{ return this; }
virtual std::shared_ptr<const LinearAlgebraObject> shared_instance() const
{ return std::shared_ptr<const LinearAlgebraObject>(); }
virtual std::shared_ptr<LinearAlgebraObject> shared_instance()
{ return std::shared_ptr<LinearAlgebraObject>(); }
virtual MPI_Comm mpi_comm() const = 0;
};
template<typename Y, typename X>
Y& as_type(X& x)
{
try
{
return dynamic_cast<Y&>(*x.instance());
}
catch (std::exception& e)
{
dolfin_error("LinearAlgebraObject.h",
"down-cast linear algebra object to requested type",
"%s", e.what());
}
// Return something to keep the compiler happy, code will not be reached
return dynamic_cast<Y&>(*x.instance());
}
template<typename Y, typename X>
std::shared_ptr<Y> as_type(std::shared_ptr<X> x)
{
// Try to down cast shared pointer
std::shared_ptr<Y> y = std::dynamic_pointer_cast<Y>(x);
// If down cast fails, try to get shared ptr instance to unwrapped object
if (!y)
{
// Try to get instance to unwrapped object and cast
if (x->shared_instance())
y = std::dynamic_pointer_cast<Y>(x->shared_instance());
}
return y;
}
template<typename Y, typename X>
bool has_type(const X& x)
{
return bool(dynamic_cast<const Y*>(x.instance()));
}
}
#endif
dolfin::LinearAlgebraObject
Definition LinearAlgebraObject.h:37
dolfin::LinearAlgebraObject::instance
virtual const LinearAlgebraObject * instance() const
Return concrete instance / unwrap (const version).
Definition LinearAlgebraObject.h:41
dolfin::LinearAlgebraObject::mpi_comm
virtual MPI_Comm mpi_comm() const =0
Return MPI communicator.
dolfin::LinearAlgebraObject::shared_instance
virtual std::shared_ptr< LinearAlgebraObject > shared_instance()
Return concrete shared ptr instance / unwrap (non-const version).
Definition LinearAlgebraObject.h:53
dolfin::LinearAlgebraObject::shared_instance
virtual std::shared_ptr< const LinearAlgebraObject > shared_instance() const
Return concrete shared ptr instance / unwrap (const version).
Definition LinearAlgebraObject.h:49
dolfin::LinearAlgebraObject::instance
virtual LinearAlgebraObject * instance()
Return concrete instance / unwrap (non-const version).
Definition LinearAlgebraObject.h:45
dolfin::Variable::Variable
Variable()
Create unnamed variable.
Definition Variable.cpp:31
dolfin
Definition adapt.h:30
dolfin::dolfin_error
void dolfin_error(std::string location, std::string task, std::string reason,...)
Definition log.cpp:129
dolfin::has_type
bool has_type(const X &x)
Check whether the object matches a specific type.
Definition LinearAlgebraObject.h:102
dolfin::as_type
Y & as_type(X &x)
Definition LinearAlgebraObject.h:64