InstructionAffectation< FunctionExpression, FunctionVariable > Class Template Reference

#include <Instruction.hpp>

Inheritance diagram for InstructionAffectation< FunctionExpression, FunctionVariable >:

[legend]

Collaboration diagram for InstructionAffectation< FunctionExpression, FunctionVariable >:

[legend]

List of all members.

Public Types
enum	Type {   list, ifStatement, doWhileStatement, whileStatement,   forStatement, exitStatement, coarseMesh, declaration,   affectation, increment, input, decrement,   evaluation, blockBegin, blockEnd, output,   Using, exec, cat, plot,   save, none }
Public Member Functions
void	execute ()
	InstructionAffectation (const std::string &variableName, ReferenceCounting< FunctionExpression > e)
	InstructionAffectation (const InstructionAffectation< FunctionExpression, FunctionVariable > &I)
	~InstructionAffectation ()
const Instruction::Type &	type () const
Protected Attributes
const Instruction::Type	__type
Private Attributes
std::string	__variableName
ReferenceCounting < FunctionExpression >	__expression

---

Detailed Description

template<>
class InstructionAffectation< FunctionExpression, FunctionVariable >

Definition at line 753 of file Instruction.hpp.

---

Member Enumeration Documentation

enum Instruction::Type [inherited]

Enumerator:

list
ifStatement
doWhileStatement
whileStatement
forStatement
exitStatement
coarseMesh
declaration
affectation
increment
input
decrement
evaluation
blockBegin
blockEnd
output
Using
exec
cat
plot
save
none

Definition at line 49 of file Instruction.hpp.

            {
    list,
    ifStatement,
    doWhileStatement,
    whileStatement,
    forStatement,
    exitStatement,
    coarseMesh,

    declaration,
    affectation,
    increment,
    input,
    decrement,
    evaluation,

    blockBegin,
    blockEnd,

    output,
    Using,
    exec,
    cat,
    plot,
    save,
    none
  };

---

Constructor & Destructor Documentation

InstructionAffectation< FunctionExpression, FunctionVariable >::InstructionAffectation	(	const std::string &	variableName,
		ReferenceCounting< FunctionExpression >	e
	)			[inline]

Definition at line 763 of file Instruction.hpp.

    : Instruction(Instruction::affectation),
      __variableName(variableName),
      __expression(e)
  {
    ;
  }

InstructionAffectation< FunctionExpression, FunctionVariable >::InstructionAffectation

(

const InstructionAffectation< FunctionExpression, FunctionVariable > &

I

)

[inline]

Definition at line 772 of file Instruction.hpp.

    : Instruction(I),
      __variableName(I.__variableName),
      __expression(I.__expression)
  {
    ;
  }

InstructionAffectation< FunctionExpression, FunctionVariable >::~InstructionAffectation

(

)

[inline]

Definition at line 781 of file Instruction.hpp.

  {
    ;
  }

---

Member Function Documentation

void InstructionAffectation< FunctionExpression, FunctionVariable >::execute

(

)

[virtual]

Implements Instruction.

Definition at line 227 of file Instruction.cpp.

References InstructionAffectation< DataType, VarType >::__expression, InstructionAffectation< DataType, VarType >::__variableName, FEMFunctionBase::baseMesh(), FEMFunctionBuilder::build(), FEMFunctionBase::discretizationType(), FunctionVariable::expression(), ScalarFunctionBase::femfunction, VariableRepository::findVariable(), FEMFunctionBuilder::getBuiltScalarFunction(), StaticBase< Information >::instance(), StaticBase< VariableRepository >::instance(), SpectralFunction::mesh(), Information::setMesh(), ScalarFunctionBase::spectral, ScalarFunctionBase::type(), and Information::unsetMesh().

{
  FunctionVariable* functionVariable
    = VariableRepository::instance().findVariable<FunctionVariable>(__variableName);

  ConstReferenceCounting<FunctionExpression> f = functionVariable->expression();

  const ScalarFunctionBase& scalarFunction = *f->function();

  switch(scalarFunction.type()) {
  case ScalarFunctionBase::femfunction: {
    const FEMFunctionBase& femFunction = dynamic_cast<const FEMFunctionBase&>(scalarFunction);

    Information::instance().setMesh(femFunction.baseMesh());

    __expression->execute();

    FEMFunctionBuilder builder;
    builder.build(femFunction.discretizationType(),
                  femFunction.baseMesh(),
                  *__expression->function());

    (*functionVariable)
      = new FunctionExpressionValue(builder.getBuiltScalarFunction(), false);

    Information::instance().unsetMesh();
    break;
  }
  case ScalarFunctionBase::spectral: {
    const SpectralFunction& spectralFunction
      = dynamic_cast<const SpectralFunction&>(scalarFunction);
    const Mesh* mesh = spectralFunction.mesh();
    Information::instance().setMesh(mesh);

    __expression->execute();

    (*functionVariable)
      = new FunctionExpressionValue(new SpectralFunction(spectralFunction.mesh(),
                                                         *__expression->function()),
                                    false);
    Information::instance().unsetMesh();
    break;
  }
  default: {
    __expression->execute();
    (*functionVariable) = __expression->value();
  }
  }
}

Here is the call graph for this function:

const Instruction::Type& Instruction::type

(

)

const [inline, inherited]

Definition at line 81 of file Instruction.hpp.

References Instruction::__type.

  {
    return __type;
  }

---

Member Data Documentation

std::string InstructionAffectation< FunctionExpression, FunctionVariable >::__variableName [private]

Definition at line 757 of file Instruction.hpp.

ReferenceCounting<FunctionExpression> InstructionAffectation< FunctionExpression, FunctionVariable >::__expression [private]

Definition at line 758 of file Instruction.hpp.

const Instruction::Type Instruction::__type [protected, inherited]

Definition at line 78 of file Instruction.hpp.

Referenced by Instruction::type().

---

The documentation for this class was generated from the following files:

• Instruction.hpp
• Instruction.cpp