aslDataWrapper.h
Go to the documentation of this file.
/*
* Advanced Simulation Library <http://asl.org.il>
*
* Copyright 2015 Avtech Scientific <http://avtechscientific.com>
*
*
* This file is part of Advanced Simulation Library (ASL).
*
* ASL is free software: you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, version 3 of the License.
*
* ASL 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with ASL. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef ASLDATAWRAPPER_H
#define ASLDATAWRAPPER_H
#include "aslBlocks.h"
#include "../acl/aclMath/aclVectorOfElementsDef.h"
#include <iostream>
#include <fstream>
namespace acl
{
void copy(const vector<Element> & source,
VectorOfElements & destination);
void copy(const VectorOfElementsData & source,
VectorOfElementsData & destination);
}
using namespace std;
namespace asl
{
class AbstractData
{
protected:
Block block;
inline AbstractData();
inline explicit AbstractData(const Block & b);
public:
virtual const acl::VectorOfElements getEContainer() = 0;
virtual const acl::VectorOfElementsData getDContainer() const = 0;
inline const Block & getBlock() const;
inline void setBlock(const Block & b);
};
typedef shared_ptr<AbstractData> SPAbstractData;
template <typename V> class DataWrapper: public AbstractData
{
protected:
V container;
virtual bool checkConsistency() const;
public:
inline DataWrapper();
inline explicit DataWrapper(const Block & b);
inline DataWrapper(DataWrapper & d);
virtual const acl::VectorOfElements getEContainer();
virtual const acl::VectorOfElementsData getDContainer() const;
inline V & getContainer();
inline void setContainer(const V & cont);
};
typedef DataWrapper<acl::VectorOfElements> DataWrapperACL;
typedef DataWrapper<acl::VectorOfElementsData> DataWrapperACLData;
typedef shared_ptr<DataWrapperACL> SPDataWrapperACL;
typedef shared_ptr<DataWrapperACLData> SPDataWrapperACLData;
// ---------------------------- Implementation ---------------------------
AbstractData::AbstractData()
{
}
AbstractData::AbstractData(const Block & b):
block(b)
{
}
template <typename V> DataWrapper<V>::DataWrapper():
AbstractData()
{
}
template <typename V> DataWrapper<V>::DataWrapper(const Block & b):
AbstractData(b)
{
}
template <typename V> DataWrapper<V>::DataWrapper(DataWrapper & d):
AbstractData(d.block),
container(d.container)
{
}
template <typename V> inline V & DataWrapper<V>::getContainer()
{
return container;
}
template <typename V> inline void DataWrapper<V>::setContainer(const V & cont)
{
copy(cont, container);
}
inline const Block & AbstractData::getBlock() const
{
return block;
}
inline void AbstractData::setBlock(const Block & b)
{
block=b;
}
}
#endif
acl::VectorOfElementsData
The class represents several ElementData.
Definition: aclVectorOfElementsDef.h:57
acl::VectorOfElements
The class represents several Element.
Definition: aclVectorOfElementsDef.h:92
asl::AbstractData
Definition: aslDataWrapper.h:53
asl::AbstractData::AbstractData
AbstractData()
asl::AbstractData::AbstractData
AbstractData(const Block &b)
asl::AbstractData::setBlock
void setBlock(const Block &b)
asl::AbstractData::getDContainer
virtual const acl::VectorOfElementsData getDContainer() const =0
asl::AbstractData::getBlock
const Block & getBlock() const
Definition: aslDataWrapper.h:135
asl::AbstractData::block
Block block
Definition: aslDataWrapper.h:55
asl::AbstractData::getBlock
const Block & getBlock() const
asl::AbstractData::getEContainer
virtual const acl::VectorOfElements getEContainer()=0
asl::Block
Definition: aslBlocks.h:57
asl::DataWrapper
Class defines a folding rule into a 1D/2D/3D bulk.
Definition: aslDataWrapper.h:77
asl::DataWrapper::DataWrapper
DataWrapper(DataWrapper &d)
asl::DataWrapper::checkConsistency
virtual bool checkConsistency() const
asl::DataWrapper::getContainer
V & getContainer()
asl::DataWrapper::getEContainer
virtual const acl::VectorOfElements getEContainer()
asl::DataWrapper::DataWrapper
DataWrapper(const Block &b)
asl::DataWrapper::DataWrapper
DataWrapper()
asl::DataWrapper::getDContainer
virtual const acl::VectorOfElementsData getDContainer() const
asl::DataWrapper::getContainer
V & getContainer()
Definition: aslDataWrapper.h:125
asl::DataWrapper::setContainer
void setContainer(const V &cont)
acl
Advanced Computational Language.
Definition: acl.h:41
acl::copy
void copy(MemBlock &source, T *destination)
acl::copy
void copy(const VectorOfElementsData &source, VectorOfElementsData &destination)
asl
Advanced Simulation Library.
Definition: aslDataInc.h:31
asl::SPDataWrapperACLData
std::shared_ptr< DataWrapperACLData > SPDataWrapperACLData
Definition: aslGenerators.h:54
asl::SPAbstractData
shared_ptr< AbstractData > SPAbstractData
Definition: aslDataWrapper.h:65
asl::SPDataWrapperACL
std::shared_ptr< DataWrapperACL > SPDataWrapperACL
Definition: aslGenerators.h:56
asl::DataWrapperACLData
DataWrapper< acl::VectorOfElementsData > DataWrapperACLData
Definition: aslGenerators.h:52
asl::DataWrapperACL
DataWrapper< acl::VectorOfElements > DataWrapperACL
Definition: aslGenerators.h:55
aslBlocks.h