format 73
"core" // sofa::core
  revision 3
  modified_by 48 "allardj"
  // class settings
  //class diagram settings
  draw_all_relations default hide_attributes default hide_operations default hide_getset_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_relation_visibility default show_infonote default shadow default show_stereotype_properties default
  //use case diagram settings
  package_name_in_tab default show_context default auto_label_position default draw_all_relations default class_drawing_mode default shadow default show_stereotype_properties default
  //sequence diagram settings
  show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
  //collaboration diagram settings
  show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
  //object diagram settings
   write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
  //component diagram settings
  package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default
  draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
  //deployment diagram settings
  package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
  draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
  //state diagram settings
  package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
  show_activities default region_horizontally default drawing_language default show_stereotype_properties default
  //activity diagram settings
  package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
  show_infonote default drawing_language default show_stereotype_properties default
  
  cpp_h_dir "/home/allardj/work/Sofa/framework/sofa/core/"
  cpp_src_dir "/home/allardj/work/Sofa/framework/sofa/core/"
  cpp_namespace "sofa::core"
  classview 128048 "core"
    //class diagram settings
    draw_all_relations default hide_attributes default hide_operations default hide_getset_operations default show_members_full_definition default show_members_visibility default show_members_stereotype default show_members_multiplicity default show_members_initialization default show_attribute_modifiers default member_max_width 0 show_parameter_dir default show_parameter_name default package_name_in_tab default class_drawing_mode default drawing_language default show_context_mode default auto_label_position default show_relation_modifiers default show_relation_visibility default show_infonote default shadow default show_stereotype_properties default
    //collaboration diagram settings
    show_full_operations_definition default show_hierarchical_rank default write_horizontally default drawing_language default package_name_in_tab default show_context default draw_all_relations default shadow default show_stereotype_properties default
    //object diagram settings
     write_horizontally default package_name_in_tab default show_context default auto_label_position default draw_all_relations default shadow default show_stereotype_properties default
    //sequence diagram settings
    show_full_operations_definition default write_horizontally default class_drawing_mode default drawing_language default draw_all_relations default shadow default show_stereotype_properties default
    //state diagram settings
    package_name_in_tab default show_context default auto_label_position default write_trans_label_horizontally default show_trans_definition default draw_all_relations default shadow default
    show_activities default region_horizontally default drawing_language default show_stereotype_properties default
    //class settings
    //activity diagram settings
    package_name_in_tab default show_context default show_opaque_action_definition default auto_label_position default write_flow_label_horizontally default draw_all_relations default shadow default
    show_infonote default drawing_language default show_stereotype_properties default
    class 128048 "BaseMapping"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief An interface to convert a model to an other model
 *
 *  This Interface is used for the Mappings. A Mapping can convert one model to an other.
 *  For example, we can have a mapping from a BehaviorModel to a VisualModel.
 *"
      classrelation 128048 // <generalisation>
	relation 128048 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 128048 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 128176 // <generalisation>
	relation 128176 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 128176 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 128048 "BaseMapping"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : f_mapForces(initData(&f_mapForces, true, \"mapForces\", \"Are forces mapped ?\"))
	, f_mapConstraints(initData(&f_mapConstraints, true, \"mapConstraints\", \"Are constraints mapped ?\"))
	, f_mapMasses(initData(&f_mapMasses, true, \"mapMasses\", \"Are masses mapped ?\"))
	{
		this->addAlias(&f_mapForces, \"isMechanical\");
		this->addAlias(&f_mapMasses, \"isMechanical\");
	};
"
	
	
	
	
	comment "Constructor
Use only for data initialization"
      end

      operation 128176 "~BaseMapping"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      attribute 128048 "f_mapForces"
	public explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 128176 "f_mapConstraints"
	public explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 128304 "f_mapMasses"
	public explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 128304 "apply"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 3
	  param in name "outPos" type class_ref 128432 // MultiVecCoordId
	    defaultvalue "VecCoordId::position()"
	  param in name "inPos" type class_ref 128560 // ConstMultiVecCoordId
	    defaultvalue "ConstVecCoordId::position()"
	  param in name "mparams" type class_ref 128688 // MechanicalParams
	    defaultvalue "MechanicalParams::defaultInstance() "
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/<TO REMOVE>
virtual void updateMapping() = 0;
/ Apply the transformation from the input model to the output model (like apply displacement from BehaviorModel to VisualModel)"
      end

      operation 128432 "applyJ"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 3
	  param in name "outVel" type class_ref 128816 // MultiVecDerivId
	    defaultvalue "VecDerivId::velocity()"
	  param in name "inVel" type class_ref 128944 // ConstMultiVecDerivId
	    defaultvalue "ConstVecDerivId::velocity()"
	  param in name "mparams" type class_ref 128688 // MechanicalParams
	    defaultvalue "MechanicalParams::defaultInstance() "
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 128560 "getFrom"
	abstract cpp_virtual public explicit_return_type "helper::vector<BaseState*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Accessor to the input model of this mapping"
      end

      operation 128688 "getTo"
	abstract cpp_virtual public explicit_return_type "helper::vector<BaseState*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Accessor to the output model of this mapping"
      end

      operation 128816 "applyJT"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 3
	  param in name "inForce" type class_ref 128816 // MultiVecDerivId
	  param in name "outForce" type class_ref 128944 // ConstMultiVecDerivId
	  param in name "mparams" type class_ref 128688 // MechanicalParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment " BaseMechanicalMapping"
      end

      operation 128944 "applyJT"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 3
	  param in name "inConst" type class_ref 129072 // MultiMatrixDerivId
	  param in name "outConst" type class_ref 129200 // ConstMultiMatrixDerivId
	  param in name "mparams" type class_ref 129328 // ConstraintParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 129072 "computeAccFromMapping"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 4
	  param in name "outAcc" type class_ref 128816 // MultiVecDerivId
	  param in name "inVel" type class_ref 128944 // ConstMultiVecDerivId
	  param in name "inAcc" type class_ref 128944 // ConstMultiVecDerivId
	  param in name "mparams" type class_ref 128688 // MechanicalParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, const ${t3} * ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 129200 "areForcesMapped"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return f_mapForces.getValue();
    };
"
	
	
	
	
      end

      operation 129328 "areConstraintsMapped"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return f_mapConstraints.getValue();
    };
"
	
	
	
	
      end

      operation 129456 "areMassesMapped"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return f_mapMasses.getValue();
    };
"
	
	
	
	
      end

      operation 129584 "setForcesMapped"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "b" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        f_mapForces.setValue(b);
    };
"
	
	
	
	
      end

      operation 129712 "setConstraintsMapped"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "b" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		f_mapConstraints.setValue(b);
    };
"
	
	
	
	
      end

      operation 129840 "setMassesMapped"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "b" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		f_mapMasses.setValue(b);
    };
"
	
	
	
	
      end

      operation 129968 "setNonMechanical"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		setForcesMapped(false);
		setConstraintsMapped(false);
		setMassesMapped(false);
    };
"
	
	
	
	
      end

      operation 130096 "isMechanical"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return areForcesMapped() || areConstraintsMapped() || areMassesMapped();
    };
"
	
	
	
	
	comment "/ Return true if this mapping should be used as a mechanical mapping."
      end

      operation 130224 "sameTopology"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return false; };
"
	
	
	
	
	comment "/ Determine if this mapping should only be used as a regular mapping instead of a mechanical mapping.
virtual void setMechanical(bool b)
{
    f_isMechanical.setValue(b);
}
/ Return true if the destination model has the same topology as the source model.
/
/ This is the case for mapping keeping a one-to-one correspondance between
/ input and output DOFs (mostly identity or data-conversion mappings)."
      end

      operation 130352 "getJ"
	cpp_virtual cpp_inline public explicit_return_type "sofa::defaulttype::BaseMatrix"
	nparams 1
	  param in name "" type class_ref 128688 // MechanicalParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		serr << \"Calling deprecated getJ() method in \" << getClassName() << \". Use getJ(const MechanicalParams *) instead.\" << sendl;
		return getJ();
    };
"
	
	
	
	
	comment "/ Get the (sparse) jacobian matrix of this mapping, as used in applyJ/applyJT.
/ This matrix should have as many columns as DOFs in the input mechanical states
/ (one after the other in case of multi-mappings), and as many lines as DOFs in
/ the output mechanical states.
/
/ applyJ(out, in) should be equivalent to $out = J in$.
/ applyJT(out, in) should be equivalent to $out = J^T in$.
/
/ @TODO Note that if the mapping provides this matrix, then a default implementation
/ of all other related methods could be provided, or optionally used to verify the
/ provided implementations for debugging."
      end

      operation 130480 "getJ"
	cpp_virtual cpp_inline public explicit_return_type "sofa::defaulttype::BaseMatrix"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		serr << \"BaseMechanicalMapping::getJ() NOT IMPLEMENTED BY \" << getClassName() << sendl;
        return NULL;
	};
"
	
	
	
	
      end

      operation 130608 "beginAddContactPoint"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        serr<<\" beginAddContactPoint is not implemented for this mapping\"<<sendl;
    };
"
	
	
	
	
	comment "/ Add Contact Point process
/
/ Used for continuousFrictionContact response
/ beginAddContactPoint will reset the mapping
/ addContactPointFromInputMapping will add point in the duplicated mapping without using barycentric mappers"
      end

      operation 130736 "addContactPointFromInputMapping"
	cpp_virtual cpp_inline public explicit_return_type "int"
	nparams 2
	  param in name "" explicit_type "sofa::defaulttype::Vector3"
	  param inout name "" explicit_type "std::vector< std::pair<int, double> >"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        serr<<\" addContactPointFromInputMapping is not implemented for this mapping\"<<sendl;
        return 0;
    };
"
	
	
	
	
      end

      operation 130864 "getMechFrom"
	abstract cpp_virtual public explicit_return_type "helper::vector<behavior::BaseMechanicalState*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/<TO REMOVE>
/Necessary ?
/ Get the source (upper) mechanical state."
      end

      operation 130992 "getMechTo"
	abstract cpp_virtual public explicit_return_type "helper::vector<behavior::BaseMechanicalState*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Get the destination (lower, mapped) mechanical state."
      end

      operation 131120 "disable"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Return false if this mapping should only be used as a regular
/ Disable the mapping to get the original coordinates of the mapped model."
      end

      operation 131248 "testMechanicalState"
	cpp_inline protected explicit_return_type "bool"
	nparams 1
	  param inout name "state" type class_ref 129456 // BaseState
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        bool isMecha = false;
        if(state)
        {
            behavior::BaseMechanicalState* toMechaModel = dynamic_cast<behavior::BaseMechanicalState* > (state);
            isMecha = (toMechaModel) ? true : false;
        }
        return isMecha;
    };
"
	
	
	
	
      end
    end

    class 128176 "typedef1"
      visibility package stereotype "typedef" explicit_base_type "virtual"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 128432 "MultiVecCoordId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_COORD, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 128560 "ConstMultiVecCoordId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_COORD, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "    template<class DataTypes>
    typename const typename DataTypesVecInfo<DataTypes,vtype>::DataVecT* read(const State<DataTypes>* s) const
    {
        return s->read(getId(s));
    }

    template<class DataTypes>
    typename DataTypesVecInfo<DataTypes,vtype>::DataVecT* write(State<DataTypes>* s) const
    {
        BOOST_STATIC_ASSERT(vaccess >= V_WRITE);
        return s->write(getId(s));
    }"
    end

    class 128688 "MechanicalParams"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Class gathering parameters use by mechanical components methods, and transmitted by mechanical visitors"
      classrelation 133552 // <generalisation>
	relation 133552 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 133552 // <generalisation>
	  b parent class_ref 132912 // ExecParams
      end

      operation 151088 "dt"
	const cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_dt; };
"
	
	
	
	
	comment "/ @name Flags and parameters getters
/ @{
/ Time step"
      end

      operation 151216 "implicit"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_implicit; };
"
	
	
	
	
	comment "/ Is the time integration scheme implicit ?"
      end

      operation 151344 "mFactor"
	const cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_mFactor; };
"
	
	
	
	
	comment "/ Mass matrix contributions factor (for implicit schemes)"
      end

      operation 151472 "bFactor"
	const cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_bFactor; };
"
	
	
	
	
	comment "/ Damping matrix contributions factor (for implicit schemes)"
      end

      operation 151600 "kFactor"
	const cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { setKFactorUsed(true); return m_kFactor; };
"
	
	
	
	
	comment "/ Stiffness matrix contributions factor (for implicit schemes)"
      end

      operation 151728 "energy"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_energy; };
"
	
	
	
	
	comment "/ Should the kinematic and potential energies be computed ?"
      end

      operation 151856 "readX"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecCoord>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_x[state].read();    };
"
	
	
	
	
	comment "/ @}
/ @name Access to vectors from a given state container (i.e. State or MechanicalState)
/ @{
/ Read access to current position vector"
      end

      operation 151984 "readV"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecDeriv>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_v[state].read();    };
"
	
	
	
	
	comment "/ Read access to current velocity vector"
      end

      operation 152112 "readF"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecDeriv>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_f[state].read();    };
"
	
	
	
	
	comment "/ Read access to current force vector"
      end

      operation 152240 "readDx"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecDeriv>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_dx[state].read();    };
"
	
	
	
	
	comment "/ Read access to current dx vector (for implicit schemes)"
      end

      operation 152368 "readDf"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecDeriv>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_df[state].read();    };
"
	
	
	
	
	comment "/ Read access to current df vector (for implicit schemes)"
      end

      operation 152496 "setDt"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_dt = v; return *this; };
"
	
	
	
	
	comment "/ @}
/ @name Setup methods
/ Called by the OdeSolver from which the mechanical computations originate.
/ They all return a reference to this MechanicalParam instance, to ease chaining multiple setup calls.
/ @{
/ Set time step"
      end

      operation 152624 "setImplicit"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_implicit = v; return *this; };
"
	
	
	
	
	comment "/ Specify if the time integration scheme is implicit"
      end

      operation 152752 "setMFactor"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_mFactor = v; return *this; };
"
	
	
	
	
	comment "/ Set Mass matrix contributions factor (for implicit schemes)"
      end

      operation 152880 "setBFactor"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_bFactor = v; return *this; };
"
	
	
	
	
	comment "/ Set Damping matrix contributions factor (for implicit schemes)"
      end

      operation 153008 "setKFactor"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_kFactor = v; return *this; };
"
	
	
	
	
	comment "/ Set Stiffness matrix contributions factor (for implicit schemes)"
      end

      operation 153136 "setKFactorUsed"
	const cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "b" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_kFactorUsed = b; };
"
	
	
	
	
	comment "/ Checks wether or nor kFactor is used in ForceFields. Temporary here for compatiblity reasons"
      end

      operation 153264 "getKFactorUsed"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_kFactorUsed; };
"
	
	
	
	
      end

      operation 153392 "setEnergy"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_energy = v; return *this; };
"
	
	
	
	
	comment "/ Specify if the potential and kinematic energies should be computed ?"
      end

      operation 153520 "x"
	const cpp_inline public return_type class_ref 128560 // ConstMultiVecCoordId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_x; };
"
	
	
	
	
      end

      operation 153648 "x"
	cpp_inline public return_type class_ref 128560 // ConstMultiVecCoordId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_x; };
"
	
	
	
	
      end

      operation 153776 "v"
	const cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_v; };
"
	
	
	
	
      end

      operation 153904 "v"
	cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_v; };
"
	
	
	
	
      end

      operation 154032 "f"
	const cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_f; };
"
	
	
	
	
      end

      operation 154160 "f"
	cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_f; };
"
	
	
	
	
      end

      operation 154288 "dx"
	const cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_dx; };
"
	
	
	
	
      end

      operation 154416 "dx"
	cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_dx; };
"
	
	
	
	
      end

      operation 154544 "df"
	const cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_df; };
"
	
	
	
	
      end

      operation 154672 "df"
	cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_df; };
"
	
	
	
	
      end

      operation 154800 "setX"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 133168 // ConstVecCoordId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_x.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of position vector"
      end

      operation 154928 "setX"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 128560 // ConstMultiVecCoordId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_x = v;   return *this; };
"
	
	
	
	
      end

      operation 155056 "setX"
	stereotype "template"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133168 // ConstVecCoordId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_x.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 155184 "setV"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_v.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of velocity vector"
      end

      operation 155312 "setV"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 128944 // ConstMultiVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_v = v;   return *this; };
"
	
	
	
	
      end

      operation 155440 "setV"
	stereotype "template"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_v.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 155568 "setF"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_f.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of force vector"
      end

      operation 155696 "setF"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 128944 // ConstMultiVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_f = v;   return *this; };
"
	
	
	
	
      end

      operation 155824 "setF"
	stereotype "template"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_f.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 155952 "setDx"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_dx.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of dx vector (for implicit schemes)"
      end

      operation 156080 "setDx"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 128944 // ConstMultiVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_dx = v;   return *this; };
"
	
	
	
	
      end

      operation 156208 "setDx"
	stereotype "template"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_dx.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 156336 "setDf"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_df.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of df vector (for implicit schemes)"
      end

      operation 156464 "setDf"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "v" type class_ref 128944 // ConstMultiVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_df = v;   return *this; };
"
	
	
	
	
      end

      operation 156592 "setDf"
	stereotype "template"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_df.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 156720 "MechanicalParams"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "p" type class_ref 132912 // ExecParams
	    defaultvalue "sofa::core::ExecParams() "
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : sofa::core::ExecParams(p)
    , m_dt(0.0)
    , m_implicit(false)
    , m_energy(false)
    , m_x (ConstVecCoordId::position())
    , m_v (ConstVecDerivId::velocity())
    , m_f (ConstVecDerivId::force())
    , m_dx(ConstVecDerivId::dx())
    , m_df(ConstVecDerivId::dforce())
    , m_mFactor(0)
    , m_bFactor(0)
    , m_kFactor(0)
    {
    };
"
	
	
	
	
	comment "/ @}
/ Constructor, initializing all VecIds to default values, implicit and energy flags to false"
      end

      operation 156848 "defaultInstance"
	class_operation cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        static MechanicalParams m_defaultInstance;

        return &m_defaultInstance;
    };
"
	
	
	
	
	comment "/ Get the default MechanicalParams, to be used to provide a default values for method parameters"
      end

      operation 156976 "setExecParams"
	cpp_inline public return_type class_ref 128688 // MechanicalParams
	nparams 1
	  param in name "params" type class_ref 132912 // ExecParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        sofa::core::ExecParams::operator=(*params);
        return this;
    };
"
	
	
	
	
      end

      attribute 134064 "m_dt"
	protected explicit_type "double"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 134192 "m_implicit"
	protected explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 134320 "m_energy"
	protected explicit_type "bool"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 133680 // m_x (<directional composition>)
	relation 133680 *-->
	  a role_name "m_x" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 133680 // m_x (<directional composition>)
	  b parent class_ref 128560 // ConstMultiVecCoordId
      end

      classrelation 133808 // m_v (<directional composition>)
	relation 133808 *-->
	  a role_name "m_v" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 133808 // m_v (<directional composition>)
	  b parent class_ref 128944 // ConstMultiVecDerivId
      end

      classrelation 133936 // m_f (<directional composition>)
	relation 133936 *-->
	  a role_name "m_f" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 133936 // m_f (<directional composition>)
	  b parent class_ref 128944 // ConstMultiVecDerivId
      end

      classrelation 134064 // m_dx (<directional composition>)
	relation 134064 *-->
	  a role_name "m_dx" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134064 // m_dx (<directional composition>)
	  b parent class_ref 128944 // ConstMultiVecDerivId
      end

      classrelation 134192 // m_df (<directional composition>)
	relation 134192 *-->
	  a role_name "m_df" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134192 // m_df (<directional composition>)
	  b parent class_ref 128944 // ConstMultiVecDerivId
      end

      attribute 134448 "m_mFactor"
	protected explicit_type "double"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 134576 "m_bFactor"
	protected explicit_type "double"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 134704 "m_kFactor"
	protected explicit_type "double"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 134832 "m_kFactorUsed"
	protected explicit_type "bool"
	cpp_mutable cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 128816 "MultiVecDerivId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_DERIV, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 128944 "ConstMultiVecDerivId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_DERIV, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 129072 "MultiMatrixDerivId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_MATDERIV, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 129200 "ConstMultiMatrixDerivId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_MATDERIV, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 129328 "ConstraintParams"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Class gathering parameters use by constraint components methods, and transmitted by visitors"
      classrelation 131120 // <generalisation>
	relation 131120 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 131120 // <generalisation>
	  b parent class_ref 132912 // ExecParams
      end

      class 133040 "ConstOrder"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum ${name} {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 132400 "POS"
	  public type class_ref 133040 // ConstOrder
	  init_value " 0"
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 132528 "VEL"
	  public type class_ref 133040 // ConstOrder
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 132656 "ACC"
	  public type class_ref 133040 // ConstOrder
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 146224 "constOrder"
	const cpp_inline public return_type class_ref 133040 // ConstOrder
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_constOrder; };
"
	
	
	
	
	comment "/ @name Flags and parameters getters
/ @{"
      end

      operation 146352 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
    std::string result;
    switch ( m_constOrder )
    {
    case POS : 
      result += \"POSITION\";
    	break;
    case VEL : 
      result += \"VELOCITY\";
      break;
    case ACC :
      result += \"ACCELERATION\";
      break;
    default :
      assert(false);
    }
    return result;
  };
"
	
	
	
	
	comment "/ @}"
      end

      operation 146480 "readX"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecCoord>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_x[state].read();    };
"
	
	
	
	
	comment "/ @name Access to vectors from a given state container (i.e. State or MechanicalState)
/ @{
/ Read access to current position vector"
      end

      operation 146608 "readV"
	stereotype "template"
	const cpp_inline public explicit_return_type "Data<typename S::VecDeriv>"
	nparams 1
	  param in name "state" explicit_type "S"
	cpp_decl "    ${comment}template<class S>
  ${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {   return m_v[state].read();    };
"
	
	
	
	
	comment "/ Read access to current velocity vector"
      end

      operation 146736 "x"
	const cpp_inline public return_type class_ref 128560 // ConstMultiVecCoordId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_x; };
"
	
	
	
	
	comment "/ @}
/ @name Setup methods
/ Called by the OdeSolver from which the mechanical computations originate.
/ They all return a reference to this MechanicalParam instance, to ease chaining multiple setup calls.
/ @{"
      end

      operation 146864 "x"
	cpp_inline public return_type class_ref 128560 // ConstMultiVecCoordId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_x; };
"
	
	
	
	
      end

      operation 146992 "v"
	const cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_v; };
"
	
	
	
	
      end

      operation 147120 "v"
	cpp_inline public return_type class_ref 128944 // ConstMultiVecDerivId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_v; };
"
	
	
	
	
      end

      operation 147248 "setX"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 1
	  param in name "v" type class_ref 133168 // ConstVecCoordId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_x.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of position vector"
      end

      operation 147376 "setX"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 1
	  param in name "v" type class_ref 128560 // ConstMultiVecCoordId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_x = v;   return *this; };
"
	
	
	
	
      end

      operation 147504 "setX"
	stereotype "template"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133168 // ConstVecCoordId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_x.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 147632 "setV"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 1
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_v.assign(v);   return *this; };
"
	
	
	
	
	comment "/ Set the IDs of velocity vector"
      end

      operation 147760 "setV"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 1
	  param in name "v" type class_ref 128944 // ConstMultiVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_v = v;   return *this; };
"
	
	
	
	
      end

      operation 147888 "setV"
	stereotype "template"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 2
	  param in name "g" explicit_type "StateSet"
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { m_v.setId(g, v); return *this; };
"
	
	
	
	
      end

      operation 148016 "ConstraintParams"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "p" type class_ref 132912 // ExecParams
	    defaultvalue "sofa::core::ExecParams() "
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : sofa::core::ExecParams(p)
    , m_x (ConstVecCoordId::position())
    , m_v (ConstVecDerivId::velocity())
    {
    };
"
	
	
	
	
	comment "/ @}
/ Constructor, initializing all VecIds to default values, implicit and energy flags to false"
      end

      operation 148144 "defaultInstance"
	class_operation cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        static ConstraintParams m_defaultInstance;

        return &m_defaultInstance;
    };
"
	
	
	
	
	comment "/ Get the default MechanicalParams, to be used to provide a default values for method parameters"
      end

      operation 148272 "setExecParams"
	cpp_inline public return_type class_ref 129328 // ConstraintParams
	nparams 1
	  param in name "params" type class_ref 132912 // ExecParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        sofa::core::ExecParams::operator=(*params);
        return *this;
    };
"
	
	
	
	
      end

      classrelation 131248 // m_x (<directional composition>)
	relation 131248 *-->
	  a role_name "m_x" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 131248 // m_x (<directional composition>)
	  b parent class_ref 128560 // ConstMultiVecCoordId
      end

      classrelation 131376 // m_v (<directional composition>)
	relation 131376 *-->
	  a role_name "m_v" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 131376 // m_v (<directional composition>)
	  b parent class_ref 128944 // ConstMultiVecDerivId
      end

      classrelation 131504 // m_constOrder (<directional composition>)
	relation 131504 *-->
	  a role_name "m_constOrder" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 131504 // m_constOrder (<directional composition>)
	  b parent class_ref 133040 // ConstOrder
      end
    end

    class 129456 "BaseState"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Component storing position and velocity vectors.
 *
 *  This class define the interface of components used as source and
 *  destination of regular (non mechanical) mapping. It is then specialized as
 *  MechanicalState (storing other mechanical data) or MappedModel (if no
 *  mechanical data is used, such as for VisualModel)."
      classrelation 128304 // <generalisation>
	relation 128304 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 128304 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 128432 // <generalisation>
	relation 128432 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 128432 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 131376 "~BaseState"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
      end

      operation 131504 "getSize"
	abstract const cpp_virtual public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Current size of all stored vectors"
      end

      operation 131632 "resize"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "vsize" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Resize all stored vector"
      end
    end

    class 129584 "BehaviorModel"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Abstract Interface of components defining the behavior of a simulated object.
 *
 *  This Interface is used by \"black-box\" objects (such as some fluid algorithms)
 *  that are present in a SOFA simulation but which do not use the internal
 *  behavior components (MechanicalState, ForceField, etc) defined in the
 *  sofa::core::behavior namespace.
 *
 *  A BehaviorModel simply has to implement the updatePosition method
 *  to compute a new simulation step.
 *"
      classrelation 128560 // <generalisation>
	relation 128560 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 128560 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 128688 // <generalisation>
	relation 128688 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 128688 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 131760 "~BehaviorModel"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 131888 "updatePosition"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "dt" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Computation of a new simulation step."
      end

      operation 132016 "addBBox"
	cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 2
	  param inout name "" explicit_type "double"
	  param inout name "" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
      return false;
    };
"
	
	
	
	
      end
    end

    class 129712 "Processor"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 129840 "ProcessorType"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum ${name} {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 128432 "GRAPH_KAAPI"
	  public type class_ref 129840 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 128560 "CPU"
	  public type class_ref 129840 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 128688 "GPU_CUDA"
	  public type class_ref 129840 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 128816 "DEFAULT"
	  public type class_ref 129840 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 128944 "VISITOR_SYNC"
	  public type class_ref 129840 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 132144 "get_current"
	class_operation preserve_cpp_body_indent public return_type class_ref 129712 // Processor
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 132272 "get_proc_type"
	cpp_inline public return_type class_ref 129840 // ProcessorType
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {return _proc_type;};
"
	
	
	
	
      end

      operation 132400 "set_proc_type"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "_p" type class_ref 129840 // ProcessorType
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {_proc_type=_p;};
"
	
	
	
	
      end

      operation 132528 "get_pid"
	cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
      return 0;
    };
"
	
	
	
	
      end

      operation 132656 "set_pid"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "uint"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
      end

      operation 132784 "Processor"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} :_proc_type(DEFAULT){};
"
	
	
	
	
      end

      classrelation 128816 // _proc_type (<directional composition>)
	relation 128816 *-->
	  a role_name "_proc_type" private
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 128816 // _proc_type (<directional composition>)
	  b parent class_ref 129840 // ProcessorType
      end
    end

    class 129968 "CallContext"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 130096 "ProcessorType"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum ${name} {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 129072 "GRAPH_KAAPI"
	  public type class_ref 130096 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 129200 "CPU"
	  public type class_ref 130096 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 129328 "GPU_CUDA"
	  public type class_ref 130096 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 129456 "DEFAULT"
	  public type class_ref 130096 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 129584 "VISITOR_SYNC"
	  public type class_ref 130096 // ProcessorType
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 132912 "CallContext"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} {

    };
"
	
	
	
	
	comment "/ Constructor"
      end

      classrelation 128944 // executionType (<directional composition>)
	relation 128944 *-->
	  a role_name "executionType" init_value "= CallContext::DEFAULT" class_relation public
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 128944 // executionType (<directional composition>)
	  b parent class_ref 130096 // ProcessorType
      end

      operation 133040 "getProcessorType"
	class_operation cpp_inline public return_type class_ref 130096 // ProcessorType
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return	(ProcessorType)Processor::get_current()->get_proc_type();
    };
"
	
	
	
	
      end

      operation 133168 "getExecutionType"
	class_operation cpp_inline public return_type class_ref 130096 // ProcessorType
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return	(ProcessorType)executionType;
    };
"
	
	
	
	
      end

      operation 133296 "getProcessorId"
	class_operation cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return	Processor::get_current()->get_pid();
    };
"
	
	
	
	
      end

      operation 133424 "setProcessorType"
	class_operation cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "_type" type class_ref 130096 // ProcessorType
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        Processor::get_current()->set_proc_type((Processor::ProcessorType)_type);
    };
"
	
	
	
	
      end

      operation 133552 "setExecutionType"
	class_operation cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "_type" type class_ref 130096 // ProcessorType
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        executionType=_type;
    };
"
	
	
	
	
      end

      operation 133680 "setProcessorId"
	class_operation cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "id" explicit_type "uint"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        Processor::get_current()->set_pid(id);
    };
"
	
	
	
	
      end
    end

    class 130224 "ObjectFactory"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Main class used to register and dynamically create objects
 *
 *  It uses the Factory design pattern, where each class is registered in a map,
 *  and dynamically retrieved given the type name.
 *
 *  It also stores metainformation on each classes, such as description,
 *  authors, license, and available template types.
 *
 *  \\see RegisterObject for how new classes should be registered.
 *"
      class 130352 "Creator"
	abstract visibility package 
	cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	operation 164400 "~Creator"
	  cpp_virtual cpp_inline public explicit_return_type ""
	  nparams 0
	  cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	  
	  
	  
	  
	end

	operation 164528 "canCreate"
	  abstract cpp_virtual public explicit_return_type "bool"
	  nparams 2
	    param inout name "context" type class_ref 141104 // BaseContext
	    param inout name "arg" type class_ref 141232 // BaseObjectDescription
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	  
	  
	  
	  
	  comment "/ Pre-construction check.
/
/ \\return true if the object can be created successfully."
	end

	operation 164656 "createInstance"
	  abstract cpp_virtual public return_type class_ref 128304 // BaseObject
	  nparams 2
	    param inout name "context" type class_ref 141104 // BaseContext
	    param inout name "arg" type class_ref 141232 // BaseObjectDescription
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	  
	  
	  
	  
	  comment "/ Construction method called by the factory.
/
/ \\pre canCreate(context, arg) == true."
	end

	operation 164784 "type"
	  abstract cpp_virtual public explicit_return_type "std::type_info"
	  nparams 0
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	  
	  
	  
	  
	  comment "/ type_info structure associated with the type of intanciated objects."
	end

	operation 164912 "getClass"
	  abstract cpp_virtual public return_type class_ref 141360 // BaseClass
	  nparams 0
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	  
	  
	  
	  
	  comment "/ BaseClass structure associated with the type of intanciated objects."
	end

	operation 165040 "getTarget"
	  abstract cpp_virtual public explicit_return_type "char"
	  nparams 0
	  cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	  
	  
	  
	  
	  comment "/ The name of the library or executable containing the binary code for this component"
	end
      end

      class 132784 "ClassEntry"
	visibility package 
	cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 135984 "className"
	  public explicit_type "std::string"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 136112 "baseClasses"
	  public explicit_type "std::string"
	  stereotype "std::set"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 136240 "aliases"
	  public explicit_type "std::string"
	  stereotype "std::set"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 136368 "description"
	  public explicit_type "std::string"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 136496 "authors"
	  public explicit_type "std::string"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 136624 "license"
	  public explicit_type "std::string"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 136752 "defaultTemplate"
	  public explicit_type "std::string"
	  cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	classrelation 136496 // creatorList (<directional composition>)
	  relation 136496 *-->
	    a role_name "creatorList" public
	      cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	      classrelation_ref 136496 // creatorList (<directional composition>)
	    b parent class_ref 140720 // CreatorList
	end

	classrelation 136624 // creatorMap (<directional composition>)
	  relation 136624 *-->
	    a role_name "creatorMap" public
	      cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	      classrelation_ref 136624 // creatorMap (<directional composition>)
	    b parent class_ref 140592 // CreatorMap
	end

	operation 165168 "~ClassEntry"
	  cpp_inline public explicit_return_type ""
	  nparams 0
	  cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {
            for(CreatorMap::iterator it = creatorMap.begin(), itEnd = creatorMap.end();
                it != itEnd; ++it)
            {
                delete it->second;
                it->second = 0;
            }
        };
"
	  
	  
	  
	  
	  comment "void print();"
	end
      end

      extra_member 128048 "Creator"
	
	stereotype "class"
	cpp "    class Creator;
" ""
	java ""
	php ""
	python ""
	idl ""
      end

      extra_member 128176 "ClassEntry"
	
	stereotype "class"
	cpp "    class ClassEntry;
" ""
	java ""
	php ""
	python ""
	idl ""
      end

      class 140592 "CreatorMap"
	visibility package stereotype "typedef" base_type class_ref 130352 // Creator
	cpp_decl "${comment}typedef std::map<std::string,${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 136112 // <dependency>
	  relation 136112 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 136112 // <dependency>
	    b parent class_ref 130352 // Creator
	end
      end

      class 140720 "CreatorList"
	visibility package stereotype "typedef" explicit_base_type "std::list< std::pair<std::string, Creator*> >"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 140848 "ClassEntryMap"
	visibility package stereotype "typedef" base_type class_ref 132784 // ClassEntry
	cpp_decl "${comment}typedef std::map<std::string,${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 136240 // <dependency>
	  relation 136240 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 136240 // <dependency>
	    b parent class_ref 132784 // ClassEntry
	end
      end

      class 140976 "ClassEntryList"
	visibility package stereotype "typedef" base_type class_ref 132784 // ClassEntry
	cpp_decl "${comment}typedef std::vector<${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 136368 // <dependency>
	  relation 136368 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 136368 // <dependency>
	    b parent class_ref 132784 // ClassEntry
	end
      end

      classrelation 136752 // registry (<directional composition>)
	relation 136752 *-->
	  a role_name "registry" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 136752 // registry (<directional composition>)
	  b parent class_ref 140848 // ClassEntryMap
      end

      classrelation 136880 // classEntries (<directional composition>)
	relation 136880 *-->
	  a role_name "classEntries" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 136880 // classEntries (<directional composition>)
	  b parent class_ref 140976 // ClassEntryList
      end

      operation 165296 "~ObjectFactory"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 165424 "getEntry"
	preserve_cpp_body_indent public return_type class_ref 132784 // ClassEntry
	nparams 1
	  param in name "classname" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Get an entry given a class name (or alias)"
      end

      operation 165552 "hasCreator"
	preserve_cpp_body_indent public explicit_return_type "bool"
	nparams 1
	  param in name "classname" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Test if a creator exists for a given classname"
      end

      operation 165680 "getAllEntries"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "result" explicit_type "std::vector<ClassEntry*>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Fill the given vector with all the registered classes"
      end

      operation 165808 "addAlias"
	preserve_cpp_body_indent public explicit_return_type "bool"
	nparams 4
	  param in name "name" explicit_type "std::string"
	  param in name "result" explicit_type "std::string"
	  param in name "force" explicit_type "bool"
	    defaultvalue "false"
	  param inout name "previous" type class_ref 132784 // ClassEntry
	    defaultvalue "NULL"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} * * ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}, ${t2} ${p2}, ${t3} * * ${p3}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Add an alias name for an already registered class
/
/ \\param name     name of the new alias
/ \\param result   class pointed to by the new alias
/ \\param force    set to true if this method should override any entry already registered for this name
/ \\param previous (output) previous ClassEntry registered for this name"
      end

      operation 165936 "resetAlias"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 2
	  param in name "name" explicit_type "std::string"
	  param inout name "previous" type class_ref 132784 // ClassEntry
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} * ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Reset an alias to a previous state
/
/ \\param name     name of the new alias
/ \\param previous previous ClassEntry that need to be registered back for this name"
      end

      operation 166064 "createObject"
	preserve_cpp_body_indent public return_type class_ref 128304 // BaseObject
	nparams 2
	  param inout name "context" type class_ref 141104 // BaseContext
	  param inout name "arg" type class_ref 141232 // BaseObjectDescription
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${t0} * ${p0}, ${t1} * ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Create an object given a context and a description."
      end

      operation 166192 "getInstance"
	class_operation preserve_cpp_body_indent public return_type class_ref 130224 // ObjectFactory
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Get the ObjectFactory singleton instance"
      end

      operation 166320 "CreateObject"
	class_operation cpp_inline public return_type class_ref 128304 // BaseObject
	nparams 2
	  param inout name "context" type class_ref 141104 // BaseContext
	  param inout name "arg" type class_ref 141232 // BaseObjectDescription
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        return getInstance()->createObject(context, arg);
    };
"
	
	
	
	
	comment "/ \\copydoc createObject"
      end

      operation 166448 "AddAlias"
	class_operation cpp_inline public explicit_return_type "bool"
	nparams 4
	  param in name "name" explicit_type "std::string"
	  param in name "result" explicit_type "std::string"
	  param in name "force" explicit_type "bool"
	    defaultvalue "false"
	  param inout name "previous" type class_ref 132784 // ClassEntry
	    defaultvalue "NULL"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} * * ${p3}${v3}${)}${const}${volatile}${throw}${abstract} {
        return getInstance()->addAlias(name, result, force, previous);
    };
"
	
	
	
	
	comment "/ \\copydoc addAlias"
      end

      operation 166576 "ResetAlias"
	class_operation cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "name" explicit_type "std::string"
	  param inout name "previous" type class_ref 132784 // ClassEntry
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        getInstance()->resetAlias(name, previous);
    };
"
	
	
	
	
	comment "/ \\copydoc resetAlias"
      end

      operation 166704 "HasCreator"
	class_operation cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "classname" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return getInstance()->hasCreator(classname);
    };
"
	
	
	
	
	comment "/ \\copydoc hasCreator"
      end

      operation 166832 "dump"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "out" explicit_type "std::ostream"
	    defaultvalue "std::cout"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Dump the content of the factory to a text stream."
      end

      operation 166960 "dumpXML"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "out" explicit_type "std::ostream"
	    defaultvalue "std::cout"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Dump the content of the factory to a XML stream."
      end

      operation 167088 "dumpHTML"
	preserve_cpp_body_indent public explicit_return_type "void"
	nparams 1
	  param inout name "out" explicit_type "std::ostream"
	    defaultvalue "std::cout"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Dump the content of the factory to a HTML stream."
      end
    end

    class 130480 "Creator"
      visibility package stereotype "typedef" base_type class_ref 130352 // Creator
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 129072 // <dependency>
	relation 129072 -_->
	  a default
	    cpp default "#include in source"
	    classrelation_ref 129072 // <dependency>
	  b parent class_ref 130352 // Creator
      end
    end

    class 130608 "CategoryLibrary"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief An Generic Category of the Sofa Library
 *
 *  It contains all the components available for Sofa corresponding to a given category (force field, mass, mapping...)
 *  This Interface is used for the Modeler mainly. 
 *"
      class 130864 "VecComponent"
	visibility package stereotype "typedef" base_type class_ref 130736 // ComponentLibrary
	cpp_decl "${comment}typedef std::vector<${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 129200 // <dependency>
	  relation 129200 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 129200 // <dependency>
	    b parent class_ref 130736 // ComponentLibrary
	end
      end

      class 130992 "VecComponentIterator"
	visibility package stereotype "typedef" explicit_base_type "VecComponent::const_iterator"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 133808 "CategoryLibrary"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 1
	  param in name "categoryName" explicit_type "std::string"
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw};
"
	cpp_def "//-------------------------------------------------------------------------------------------------------

${inline}${class}::${name}${(}const ${t0} & ${p0}${)}: name(categoryName)
      ${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 133936 "~CategoryLibrary"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
      end

      operation 134064 "addComponent"
	preserve_cpp_body_indent cpp_virtual public return_type class_ref 130736 // ComponentLibrary
	nparams 3
	  param in name "componentName" explicit_type "std::string"
	  param inout name "entry" type class_ref 131120 // ClassEntry
	  param in name "exampleFiles" explicit_type "std::vector< std::string >"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}const ${t0} & ${p0}, ${t1} * ${p1}, const ${t2} & ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 134192 "endConstruction"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 134320 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return name;};
"
	
	
	
	
      end

      operation 134448 "getComponents"
	const cpp_inline public return_type class_ref 130864 // VecComponent
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {return components;};
"
	
	
	
	
      end

      operation 134576 "getComponent"
	preserve_cpp_body_indent const public return_type class_ref 130736 // ComponentLibrary
	nparams 1
	  param in name "categoryName" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}const ${type} * ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 134704 "getNumComponents"
	const cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {return components.size();};
"
	
	
	
	
      end

      operation 134832 "createComponent"
	cpp_virtual cpp_inline protected return_type class_ref 130736 // ComponentLibrary
	nparams 3
	  param in name "componentName" explicit_type "std::string"
	  param inout name "entry" type class_ref 131120 // ClassEntry
	  param in name "exampleFiles" explicit_type "std::vector< std::string >"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} & ${p0}${v0}, ${t1} * ${p1}${v1}, const ${t2} & ${p2}${v2}${)}${const}${volatile}${throw}${abstract} {return new ComponentLibrary(componentName, name, entry, exampleFiles);};
"
	
	
	
	
      end

      attribute 129712 "name"
	protected explicit_type "std::string"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 129328 // components (<directional composition>)
	relation 129328 *-->
	  a role_name "components" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 129328 // components (<directional composition>)
	  b parent class_ref 130864 // VecComponent
      end
    end

    class 130736 "ComponentLibrary"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief An Generic Component of the Sofa Library
 *
 *  It contains all the information related to a Sofa component: its name, the templates available, a description of it, its creator, ...
 *  This Interface is used for the Modeler mainly. 
 *"
      operation 144944 "ComponentLibrary"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 4
	  param in name "componentN" explicit_type "std::string"
	  param in name "categoryN" explicit_type "std::string"
	  param inout name "e" type class_ref 131120 // ClassEntry
	  param in name "exampleFiles" explicit_type "std::vector< std::string >"
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, ${t2} * ${p2}${v2}, const ${t3} & ${p3}${v3}${)}${volatile}${throw};
"
	cpp_def "//-------------------------------------------------------------------------------------------------------

${inline}${class}::${name}${(}const ${t0} & ${p0}, const ${t1} & ${p1}, ${t2} * ${p2}, const ${t3} & ${p3}${)}:  name(componentN), categoryName(categoryN),entry(e)
      ${throw}{
  ${body}}
"
	
	
	
	
      end

      operation 145072 "~ComponentLibrary"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
      end

      operation 145200 "addTemplate"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "nameT" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 145328 "endConstruction"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 145456 "setDisplayed"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
      end

      operation 145584 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return name;};
"
	
	
	
	
      end

      operation 145712 "getDescription"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return description;};
"
	
	
	
	
      end

      operation 145840 "getCategory"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return categoryName;};
"
	
	
	
	
      end

      operation 145968 "getTemplates"
	const cpp_inline public explicit_return_type "std::vector< std::string >"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} { return templateName;};
"
	
	
	
	
      end

      operation 146096 "getEntry"
	const cpp_inline public return_type class_ref 131120 // ClassEntry
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return entry;};
"
	
	
	
	
      end

      attribute 131888 "name"
	protected explicit_type "std::string"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 132016 "templateName"
	protected explicit_type " std::string "
	stereotype "std::vector"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 132144 "description"
	protected explicit_type "std::string"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 132272 "categoryName"
	protected explicit_type "std::string"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 130992 // entry (<unidirectional association>)
	relation 130992 --->
	  a role_name "entry" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 130992 // entry (<unidirectional association>)
	  b parent class_ref 131120 // ClassEntry
      end
    end

    class 131120 "ClassEntry"
      visibility package stereotype "typedef" base_type class_ref 132784 // ClassEntry
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 130864 // <dependency>
	relation 130864 -_->
	  a default
	    cpp default "#include in source"
	    classrelation_ref 130864 // <dependency>
	  b parent class_ref 132784 // ClassEntry
      end
    end

    class 131248 "BaseCollisionElementIterator"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Base class for reference to an collision element defined by its <i>index</i>
 *"
      class 131376 "VIterator"
	visibility package stereotype "typedef" explicit_base_type "std::vector<int>::const_iterator"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 134960 "BaseCollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "index" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}${)}${volatile}${throw} : index(index), it(emptyVector.begin()), itend(emptyVector.end())
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ In most cases it will be used by the CollisionModel to
/ create interators to its elements (such as in the begin() and end()
/ methods)."
      end

      operation 135088 "BaseCollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 3
	  param in name "index" explicit_type "int"
	  param in name "it" type class_ref 131376 // VIterator
	  param in name "itend" type class_ref 131376 // VIterator
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${volatile}${throw} : index(index), it(it), itend(itend)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ This constructor should be used in case a vector of indices is used."
      end

      operation 135216 "BaseCollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param in name "it" type class_ref 131376 // VIterator
	  param in name "itend" type class_ref 131376 // VIterator
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${volatile}${throw} : index(-1), it(it), itend(itend)
    {
	if (it != itend) index = *it;
    };
"
	
	
	
	
	comment "/ Constructor.
/ This constructor should be used in case a vector of indices is used."
      end

      operation 135344 "next"
	cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	if (it == itend)
	    ++index;
	else
	{
	    ++it;
	    if (it != itend) index = *it;
	}
    };
"
	
	
	
	
	comment "/ @name Iterator Interface
/ @{
/ Increment this iterator to reference the next element."
      end

      operation 135472 "operator ++"
	cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
	next();
    };
"
	
	
	
	
	comment "/ Increment this iterator to reference the next element."
      end

      operation 135600 "operator ++"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
	next();
    };
"
	
	
	
	
	comment "/ Increment this iterator to reference the next element."
      end

      operation 135728 "getIndex"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return index;
    };
"
	
	
	
	
	comment "/ Return the index of the referenced element inside the CollisionModel.
/
/ This methods should rarely be used.
/ Users should call it.draw() instead of model->draw(it.getIndex())."
      end

      operation 135856 "getVIterator"
	const cpp_inline public return_type class_ref 131376 // VIterator
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return it;
    };
"
	
	
	
	
	comment "/ Return the current iterator in the vector of indices, in case such a vector is currently used"
      end

      operation 135984 "getVIteratorEnd"
	const cpp_inline public return_type class_ref 131376 // VIterator
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return itend;
    };
"
	
	
	
	
	comment "/ Return the end iterator in the vector of indices, in case such a vector is currently used"
      end

      attribute 129840 "index"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
	comment "/< index of the referenced element inside the CollisionModel."
      end

      classrelation 129456 // it (<directional composition>)
	relation 129456 *-->
	  a role_name "it" protected
	    comment "/< current position in a vector of indices, in case this iterator traverse a non-contiguous set of indices"
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 129456 // it (<directional composition>)
	  b parent class_ref 131376 // VIterator
      end

      classrelation 129584 // itend (<directional composition>)
	relation 129584 *-->
	  a role_name "itend" protected
	    comment "/< end position in a vector of indices, in case this iterator traverse a non-contiguous set of indices"
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 129584 // itend (<directional composition>)
	  b parent class_ref 131376 // VIterator
      end

      attribute 129968 "emptyVector"
	class_attribute protected explicit_type "int"
	stereotype "std::vector"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
	comment "/< empty vector to be able to initialize the iterator to an empty pair"
      end
    end

    class 131504 "TCollisionElementIterator"
      visibility package 
      nformals 1
      formal name "TModel" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Reference to an collision element defined by its <i>index</i> inside
 *  a given collision <i>model</i>.
 *
 *  A CollisionElementIterator is only a temporary iterator and must not
 *  contain any data. It only contains inline non-virtual methods calling the
 *  appropriate methods in the parent model object.
 *  This class is a template in order to store reference to a specific type of
 *  element (such as a Cube in a CubeModel).
 *"
      classrelation 129712 // <generalisation>
	relation 129712 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 129712 // <generalisation>
	  b parent class_ref 131248 // BaseCollisionElementIterator
      end

      class 131632 "Model"
	visibility package stereotype "typedef" explicit_base_type "TModel"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 131760 "VIterator"
	visibility package stereotype "typedef" explicit_base_type "std::vector<int>::const_iterator"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 136112 "TCollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param inout name "model" type class_ref 131632 // Model
	    defaultvalue "NULL"
	  param in name "index" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${volatile}${throw} : BaseCollisionElementIterator(index), model(model)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ In most cases it will be used by the CollisionModel to
/ create interators to its elements (such as in the begin() and end()
/ methods)."
      end

      operation 136240 "TCollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 4
	  param inout name "model" type class_ref 131632 // Model
	  param in name "index" explicit_type "int"
	  param in name "it" type class_ref 131760 // VIterator
	  param in name "itend" type class_ref 131760 // VIterator
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${volatile}${throw} : BaseCollisionElementIterator(index, it, itend), model(model)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ This constructor should be used in case a vector of indices is used."
      end

      operation 136368 "TCollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 3
	  param inout name "model" type class_ref 131632 // Model
	  param in name "it" type class_ref 131760 // VIterator
	  param in name "itend" type class_ref 131760 // VIterator
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${volatile}${throw} : BaseCollisionElementIterator(it, itend), model(model)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ This constructor should be used in case a vector of indices is used."
      end

      operation 136496 "operator =="
	stereotype "template"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "i" explicit_type "TCollisionElementIterator<Model2>"
	cpp_decl "    ${comment}template<class Model2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return this->model == i.getCollisionModel() && this->index == i.getIndex();
    };
"
	
	
	
	
	comment "/ @name Iterator Interface
/ @{
/ Compare two iterators.
/ Note that even it the iterators are of different types, they can point to the same element."
      end

      operation 136624 "operator !="
	stereotype "template"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "i" explicit_type "TCollisionElementIterator<Model2>"
	cpp_decl "    ${comment}template<class Model2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return this->model != i.getCollisionModel() || this->index != i.getIndex();
    };
"
	
	
	
	
	comment "/ Compare two iterators.
/ Note that even it the iterators are of different types, they can point to the same element."
      end

      operation 136752 "valid"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return model!=NULL;
    };
"
	
	
	
	
	comment "/ Test if this iterator is initialized with a valid CollisionModel.
/ Note that it does not test if the referenced element inside the CollisionModel is valid."
      end

      operation 136880 "getCollisionModel"
	const cpp_inline public return_type class_ref 131632 // Model
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return model;
    };
"
	
	
	
	
	comment "/ Return the CollisionModel containing the referenced element."
      end

      operation 137008 "getInternalChildren"
	preserve_cpp_body_indent const public explicit_return_type "std::pair<CollisionElementIterator,CollisionElementIterator>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ @}
/ @name Wrapper methods to access data and methods inside the CollisionModel.
/ @{
/ Return the list (as a pair of iterators) of <i>internal children</i> of this element.
/
/ @see CollisionModel::getInternalChildren"
      end

      operation 137136 "getExternalChildren"
	preserve_cpp_body_indent const public explicit_return_type "std::pair<CollisionElementIterator,CollisionElementIterator>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Return the list (as a pair of iterators) of <i>external children</i> of this element.
/
/ @see CollisionModel::getExternalChildren"
      end

      operation 137264 "isLeaf"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return model->isLeaf(index);
    };
"
	
	
	
	
	comment "/ Test if this element is a leaf.
/
/ @return true if the element(index) is leaf. i.e. If it is a primitive itself."
      end

      operation 137392 "canCollideWith"
	cpp_inline public explicit_return_type "bool"
	nparams 1
	  param inout name "elem" explicit_type "TCollisionElementIterator<Model>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return model->canCollideWithElement(index, elem.model, elem.index);
    };
"
	
	
	
	
	comment "/ Test if this element can collide with another element.
/
/ @see CollisionModel::canCollideWithElement"
      end

      operation 137520 "getProximity"
	cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return model->getProximity(); };
"
	
	
	
	
	comment "/ Distance to the actual (visual) surface"
      end

      operation 137648 "getContactStiffness"
	cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return model->getContactStiffness(index); };
"
	
	
	
	
	comment "/ Contact stiffness"
      end

      operation 137776 "getContactFriction"
	cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return model->getContactFriction(index); };
"
	
	
	
	
	comment "/ Contact friction (damping) coefficient"
      end

      operation 137904 "draw"
	cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        model->draw(index);
    };
"
	
	
	
	
	comment "/ Render this element.
/
/ @see CollisionModel::draw"
      end

      classrelation 129840 // model (<unidirectional association>)
	relation 129840 --->
	  a role_name "model" protected
	    comment "/< CollisionModel containing the referenced element."
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 129840 // model (<unidirectional association>)
	  b parent class_ref 131632 // Model
      end
    end

    class 131888 "CollisionElementIterator"
      visibility package 
      nactuals 1
      actual class class_ref 131504 // TCollisionElementIterator
        rank 0 value class_ref 132016 // CollisionModel
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Reference to an abstract collision element.
 *
 *  You can think of a CollisionElementIterator as a glorified pointer to a
 *  collision element. It is only there to create a reference to it, not to
 *  actual contain its data. Classes derived from TCollisionElementIterator
 *  does not store any data, but just provide methods allowing to access the
 *  additionnal data stored inside the derived CollisionModel. For instance,
 *  the Cube class adds the minVect() / maxVect() methods to retrieve the
 *  corners of the cube, however this data is not stored inside Cube, instead
 *  it is stored inside the CubeData class within CubeModel.
 *"
      classrelation 129968 // <generalisation>
	relation 129968 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 129968 // <generalisation>
	  b parent class_ref 131504 // TCollisionElementIterator
      end

      operation 138032 "CollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param inout name "model" type class_ref 132016 // CollisionModel
	    defaultvalue "NULL"
	  param in name "index" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}${)}${volatile}${throw} : TCollisionElementIterator<CollisionModel>(model, index)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ In most cases it will be used by the CollisionModel to
/ create interators to its elements (such as in the begin() and end()
/ methods)."
      end

      operation 138160 "CollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 3
	  param inout name "model" type class_ref 132016 // CollisionModel
	  param in name "it" explicit_type "VIterator"
	  param in name "itend" explicit_type "VIterator"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${volatile}${throw} : TCollisionElementIterator<CollisionModel>(model, it, itend)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ This constructor should be used in case a vector of indices is used."
      end

      operation 138288 "CollisionElementIterator"
	cpp_inline public explicit_return_type ""
	nparams 4
	  param inout name "model" type class_ref 132016 // CollisionModel
	  param in name "index" explicit_type "int"
	  param in name "it" explicit_type "VIterator"
	  param in name "itend" explicit_type "VIterator"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${volatile}${throw} : TCollisionElementIterator<CollisionModel>(model, index, it, itend)
    {
    };
"
	
	
	
	
	comment "/ Constructor.
/ This constructor should be used in case a vector of indices is used."
      end

      operation 138416 "CollisionElementIterator"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "i" explicit_type "TCollisionElementIterator<DerivedModel>"
	cpp_decl "    ${comment}template<class DerivedModel>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : TCollisionElementIterator<CollisionModel>(i.getCollisionModel(), i.getIndex(), i.getVIterator(), i.getVIteratorEnd())
    {
    };
"
	
	
	
	
	comment "/ Automatic conversion from a reference to an element in a derived model."
      end

      operation 138544 "operator ="
	stereotype "template"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "i" explicit_type "TCollisionElementIterator<DerivedModel>"
	cpp_decl "    ${comment}template<class DerivedModel>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        this->model = i.getCollisionModel();
        this->index = i.getIndex();
	this->it = i.getVIterator();
	this->itend = i.getVIteratorEnd();
    };
"
	
	
	
	
	comment "/ Automatic conversion from a reference to an element in a derived model."
      end
    end

    class 132016 "CollisionModel"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Abstract CollisionModel interface.
 *
 *  A CollisionModel contains a list of same-type elements. It can be part of a
 *  list of CollisionModels, each describing a level in a bounding-volume
 *  hierarchy.
 *
 *  Each CollisionModel stores a pointer to the next model in the hierarchy
 *  (i.e. finer / lower / child level) as well as the previous model (i.e.
 *  coarser / upper / parent level). The first CollisionModel in this list is
 *  the root of the hierarchy and contains only one element. The last
 *  CollisionModel contains the leaves of the hierarchy which are the real
 *  elements of the object.
 *
 *  Each element inside CollisionModels except for the last one can have a list
 *  of children. There are 2 types of child elements:
 *  \\li internal children: child elements of the same type as their parent (often
 *    corresponding to non-final elements)
 *  \\li external children: child elements of a different type (often corresponding
 *    to the final elements) 
 *"
      classrelation 130096 // <generalisation>
	relation 130096 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 130096 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 130224 // <generalisation>
	relation 130224 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 130224 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      class 132144 "Iterator"
	visibility package stereotype "typedef" base_type class_ref 131888 // CollisionElementIterator
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 130352 // <dependency>
	  relation 130352 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 130352 // <dependency>
	    b parent class_ref 131888 // CollisionElementIterator
	end
      end

      class 132400 "Topology"
	visibility package stereotype "typedef" base_type class_ref 132272 // BaseMeshTopology
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 130480 // <dependency>
	  relation 130480 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 130480 // <dependency>
	    b parent class_ref 132272 // BaseMeshTopology
	end
      end

      class 132528 "Real"
	visibility package stereotype "typedef" explicit_base_type "sofa::defaulttype::Vector3::value_type"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 138672 "CollisionModel"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : bActive(initData(&bActive, true, \"active\", \"flag indicating if this collision model is active and should be included in default collision detections\"))
    , bMoving(initData(&bMoving, true, \"moving\", \"flag indicating if this object is changing position between iterations\"))
    , bSimulated(initData(&bSimulated, true, \"simulated\", \"flag indicating if this object is controlled by a simulation\"))
    , bSelfCollision(initData(&bSelfCollision, false, \"selfCollision\", \"flag indication if the object can self collide\"))
    , proximity(initData(&proximity, 0.0, \"proximity\", \"Distance to the actual (visual) surface\"))
    , contactStiffness(initData(&contactStiffness, 10.0, \"contactStiffness\", \"Default contact stiffness\"))
    , contactFriction(initData(&contactFriction, 0.01, \"contactFriction\", \"Default contact friction (damping) coefficient\"))
    , contactResponse(initData(&contactResponse, \"contactResponse\", \"if set, indicate to the ContactManager that this model should use the given class of contacts.\\nNote that this is only indicative, and in particular if both collision models specify a different class it is up to the manager to choose.\"))
    , group(initData(&group, 0, \"group\", \"If not zero, ID of a group containing this model. No collision can occur between collision models of the same group (allowing the same object to have multiple collision models)\"))
    , color(initData(&color, defaulttype::Vec4f(1,0,0,1), \"color\", \"color used to display the collision model if requested\"))
    , size(0), previous(NULL), next(NULL), numberOfContacts(0)
    {
    };
"
	
	
	
	
	comment "/ Constructor"
      end

      operation 138800 "bwdInit"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
      getColor4f(); //init the color to default value
    };
"
	
	
	
	
      end

      operation 138928 "~CollisionModel"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {
        delete previous;
    };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 139056 "empty"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return size==0;
    };
"
	
	
	
	
	comment "/ Return true if there are no elements"
      end

      operation 139184 "getSize"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return size;
    };
"
	
	
	
	
	comment "/ Get the number of elements."
      end

      operation 139312 "setSelfCollision"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "_bSelfCollision" explicit_type "bool"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        bSelfCollision = _bSelfCollision ;
    };
"
	
	
	
	
	comment "/ set a value to bSelfCollision"
      end

      operation 139440 "getNumberOfContacts"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
		return numberOfContacts;
	};
"
	
	
	
	
	comment "/ Get the number of contacts attached to the collision model"
      end

      operation 139568 "setNumberOfContacts"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "i" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
		numberOfContacts = i;
	};
"
	
	
	
	
	comment "/ Set the number of contacts attached to the collision model"
      end

      operation 139696 "resize"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "s" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        size = s;
    };
"
	
	
	
	
	comment "/ Set the number of elements."
      end

      operation 139824 "begin"
	cpp_inline public return_type class_ref 132144 // Iterator
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return Iterator(this,0);
    };
"
	
	
	
	
	comment "/ Return an iterator to the first element."
      end

      operation 139952 "end"
	cpp_inline public return_type class_ref 132144 // Iterator
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return Iterator(this,size);
    };
"
	
	
	
	
	comment "/ Return an iterator pointing after the last element."
      end

      operation 140080 "getNext"
	cpp_inline public return_type class_ref 132016 // CollisionModel
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return next;
    };
"
	
	
	
	
	comment "/ Return the next (finer / lower / child level) CollisionModel in the hierarchy."
      end

      operation 140208 "getPrevious"
	cpp_inline public return_type class_ref 132016 // CollisionModel
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return previous;
    };
"
	
	
	
	
	comment "/ Return the previous (coarser / upper / parent level) CollisionModel in the hierarchy."
      end

      operation 140336 "setNext"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param inout name "val" type class_ref 132016 // CollisionModel
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        next = val;
    };
"
	
	
	
	
	comment "/ Set the next (finer / lower / child level) CollisionModel in the hierarchy."
      end

      operation 140464 "setPrevious"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param inout name "val" type class_ref 132016 // CollisionModel
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        previous = val;
    };
"
	
	
	
	
	comment "/ Set the previous (coarser / upper / parent level) CollisionModel in the hierarchy."
      end

      operation 140592 "isActive"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return bActive.getValue() && getContext()->isActive(); };
"
	
	
	
	
	comment "/ \\brief Return true if this CollisionModel should be used for collisions.
/
/ Default to true."
      end

      operation 140720 "setActive"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "val" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { bActive.setValue(val); };
"
	
	
	
	
	comment "/ \\brief Set true if this CollisionModel should be used for collisions."
      end

      operation 140848 "isMoving"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return bMoving.getValue(); };
"
	
	
	
	
	comment "/ \\brief Return true if this CollisionModel is changing position between
/ iterations.
/
/ Default to true."
      end

      operation 140976 "setMoving"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "val" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { bMoving.setValue(val); };
"
	
	
	
	
	comment "/ \\brief Set true if this CollisionModel is changing position between
/ iterations."
      end

      operation 141104 "isSimulated"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return bSimulated.getValue(); };
"
	
	
	
	
	comment "/ \\brief Return true if this CollisionModel is attached to a simulation.
/ It is false for immobile or procedurally animated objects that don't
/ use contact forces
/
/ Default to true."
      end

      operation 141232 "setSimulated"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "val" explicit_type "bool"
	    defaultvalue "true"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { bSimulated.setValue(val); };
"
	
	
	
	
	comment "/ \\brief Set true if this CollisionModel is attached to a simulation."
      end

      operation 141360 "computeBoundingTree"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "maxDepth" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Create or update the bounding volume hierarchy."
      end

      operation 141488 "computeContinuousBoundingTree"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "" explicit_type "double"
	  param in name "maxDepth" explicit_type "int"
	    defaultvalue "0"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} { computeBoundingTree(maxDepth); };
"
	
	
	
	
	comment "/ \\brief Create or update the bounding volume hierarchy, accounting for motions
/ within the given timestep.
/
/ Default to computeBoundingTree()."
      end

      operation 141616 "getInternalChildren"
	const cpp_virtual cpp_inline public explicit_return_type "std::pair<CollisionElementIterator,CollisionElementIterator>"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return std::make_pair(CollisionElementIterator(),CollisionElementIterator());
    };
"
	
	
	
	
	comment "/ \\brief Return the list (as a pair of iterators) of <i>internal children</i> of
/ an element.
/
/ Internal children are child elements of the same type as their parent
/ (often corresponding to non-final elements). This distinction is used
/ to optimize the intersection tests inside the hierarchy, as internal
/ children can be processed without dynamically retrieving a new
/ intersection method.
/
/ Default to empty (i.e. two identical iterators)"
      end

      operation 141744 "getExternalChildren"
	const cpp_virtual cpp_inline public explicit_return_type "std::pair<CollisionElementIterator,CollisionElementIterator>"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return std::make_pair(CollisionElementIterator(),CollisionElementIterator());
    };
"
	
	
	
	
	comment "/ \\brief Return the list (as a pair of iterators) of <i>external children</i> of
/ an element.
/
/ External children are child elements of a different type than their
/ parent (often corresponding to the final elements).
/
/ Default to empty (i.e. two identical iterators)"
      end

      operation 141872 "isLeaf"
	const cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return true;  //e.g. Triangle will return true 
    };
"
	
	
	
	
	comment "/ \\brief Checks if the element(index) is a leaf and a primitive of the collision model.
/
/ Default to true since triangle model, line model, etc. does not have this method implemented and they
/ are themselves (normally) leaves and primitives"
      end

      operation 142000 "canCollideWith"
	cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 1
	  param inout name "model" type class_ref 132016 // CollisionModel
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
	if (model != this && this->group.getValue() != 0 && this->group.getValue() == model->group.getValue())
	    return false;
        else if (model->getContext() != this->getContext())
            return true;
        else return bSelfCollision.getValue();
    };
"
	
	
	
	
	comment "/ \\brief Test if this model can collide with another model.
/
/ Note that this test is only related to <b>what</b> are the two models
/ (i.e. which type, attached to which object) and not <b>where</b> they
/ are in space. It is used to prune unnecessary or invalid collisions
/ (i.e. vertices of an object should be tested with triangles of another
/ but not the same object).
/
/ Default to false if the collision models are attached to the same
/ context (i.e. the same node in the scenegraph)."
      end

      operation 142128 "canCollideWithElement"
	cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 3
	  param in name "" explicit_type "int"
	  param inout name "" type class_ref 132016 // CollisionModel
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract} { return true; };
"
	
	
	
	
	comment "virtual bool canCollideWith(CollisionModel* model) { return model != this; }
/ \\brief Test if two elements can collide with each other.
/
/ This method should be implemented by models supporting
/ self-collisions to prune tests between adjacent elements.
/
/ Default to true. Note that this method assumes that canCollideWith(model2)
/ was already used to test if the collision models can collide."
      end

      operation 142256 "draw"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "/ Render an collision element."
      end

      operation 142384 "draw"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "/ Render the whole collision model."
      end

      class 132656 "ColourCode"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum ${name} {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 130096 "ENCODE_COLLISIONELEMENT"
	  public type class_ref 132656 // ColourCode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 130224 "ENCODE_RELATIVEPOSITION"
	  public type class_ref 132656 // ColourCode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 142512 "drawColourPicking"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" type class_ref 132656 // ColourCode
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "/ Picking related. Render the collision model with an appropriate RGB colour code 
/ so as to recognize it with the PickHandler of the GUI.
/ ENCODE_COLLISIONELEMENT Pass :
/   r channel : indexCollisionModel / totalCollisionModelInScene.
/   g channel : index of CollisionElement.
/ ENCODE_RELATIVEPOSITION Pass :
/ r,g,b channels encode the barycentric weights for a triangle model"
      end

      operation 142640 "getPositionFromWeights"
	cpp_virtual cpp_inline public explicit_return_type "sofa::defaulttype::Vector3"
	nparams 4
	  param in name "" explicit_type "int"
	  param in name "" type class_ref 132528 // Real
	  param in name "" type class_ref 132528 // Real
	  param in name "" type class_ref 132528 // Real
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}${)}${const}${volatile}${throw}${abstract} { 
      sofa::defaulttype::Vector3  result;
      return result;
    };
"
	
	
	
	
	comment "/ Picking related. 
/ For TriangleModels a,b,c encode the barycentric weights with respect to the vertex p1 p2 and p3 of
/ the TriangleElement with the given index "
      end

      operation 142768 "getFirst"
	cpp_inline public return_type class_ref 132016 // CollisionModel
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        CollisionModel *cm = this;
        CollisionModel *cm2;
        while ((cm2 = cm->getPrevious())!=NULL)
            cm = cm2;
        return cm;
    };
"
	
	
	
	
	comment "/ Return the first (i.e. root) CollisionModel in the hierarchy."
      end

      operation 142896 "getLast"
	cpp_inline public return_type class_ref 132016 // CollisionModel
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        CollisionModel *cm = this;
        CollisionModel *cm2;
        while ((cm2 = cm->getNext())!=NULL)
                cm = cm2;
        return cm;
    };
"
	
	
	
	
	comment "/ Return the last (i.e. leaf) CollisionModel in the hierarchy."
      end

      operation 143024 "createPrevious"
	stereotype "template"
	cpp_inline public explicit_return_type "DerivedModel"
	nparams 0
	cpp_decl "    ${comment}template<class DerivedModel>
  ${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        DerivedModel* pmodel = dynamic_cast<DerivedModel*>(previous);
        if (pmodel == NULL)
        {
            delete previous;
            pmodel = new DerivedModel();
            pmodel->setContext(getContext());
            pmodel->setMoving(isMoving());
            pmodel->setSimulated(isSimulated());
            pmodel->proximity.setValue(proximity.getValue());
            pmodel->group.setValue(group.getValue());
            previous = pmodel;
            pmodel->setNext(this);
        }
        return pmodel;
    };
"
	
	
	
	
	comment "/ Helper method to get or create the previous model in the hierarchy."
      end

      operation 143152 "getProximity"
	cpp_inline public explicit_return_type "double"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return proximity.getValue(); };
"
	
	
	
	
	comment "/ @name Experimental methods
/ @{
/ Get distance to the actual (visual) surface"
      end

      operation 143280 "getContactStiffness"
	cpp_inline public explicit_return_type "double"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { return contactStiffness.getValue(); };
"
	
	
	
	
	comment "/ Get contact stiffness"
      end

      operation 143408 "setContactStiffness"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "stiffness" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { contactStiffness.setValue(stiffness); };
"
	
	
	
	
	comment "/ Set contact stiffness"
      end

      operation 143536 "getContactFriction"
	cpp_inline public explicit_return_type "double"
	nparams 1
	  param in name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { return contactFriction.getValue(); };
"
	
	
	
	
	comment "/ Get contact friction (damping) coefficient"
      end

      operation 143664 "setContactFriction"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "friction" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { contactFriction.setValue(friction); };
"
	
	
	
	
	comment "/ Set contact friction (damping) coefficient"
      end

      operation 143792 "getContactResponse"
	cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return contactResponse.getValue(); };
"
	
	
	
	
	comment "/ Contact response algorithm"
      end

      operation 143920 "getGroup"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return group.getValue(); };
"
	
	
	
	
	comment "/ If not zero, ID of a group containing this model. No collision can occur between collision
/ models of the same group (allowing the same object to have multiple collision models)"
      end

      operation 144048 "setGroup"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "groupId" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { group.setValue(groupId); };
"
	
	
	
	
	comment "/ Set ID of group of this model. No collision can occur between collision
/ models of the same group (allowing the same object to have multiple collision models)"
      end

      operation 144176 "getTopology"
	cpp_virtual cpp_inline public return_type class_ref 132400 // Topology
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return getContext()->getMeshTopology(); };
"
	
	
	
	
	comment "/ @}
/ Topology associated to the collision model"
      end

      operation 144304 "getMeshTopology"
	cpp_virtual cpp_inline public return_type class_ref 132272 // BaseMeshTopology
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} { return getContext()->getMeshTopology(); };
"
	
	
	
	
	comment "/ BaseMeshTopology associated to the collision model"
      end

      operation 144432 "getColor4f"
	preserve_cpp_body_indent public explicit_return_type "float"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "///< empty vector to be able to initialize the iterator to an empty pair
/// Get a color that can be used to display this CollisionModel

${inline}const ${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Get a color that can be used to display this CollisionModel"
      end

      operation 144560 "setColor4f"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "c" explicit_type "float"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {color.setValue(defaulttype::Vec4f(c[0],c[1],c[2],c[3]));};
"
	
	
	
	
	comment "/ Set a color that can be used to display this CollisionModel"
      end

      operation 144688 "setProximity"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "a" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { proximity.setValue(a)        ;};
"
	
	
	
	
	comment "/ Set of differents parameters"
      end

      operation 144816 "setContactResponse"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "a" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { contactResponse.setValue(a)  ;};
"
	
	
	
	
      end

      attribute 130352 "bActive"
	protected explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 130480 "bMoving"
	protected explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 130608 "bSimulated"
	protected explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 130736 "bSelfCollision"
	protected explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 130864 "proximity"
	protected explicit_type "double"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 130992 "contactStiffness"
	protected explicit_type "double"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 131120 "contactFriction"
	protected explicit_type "double"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 131248 "contactResponse"
	protected explicit_type "std::string"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 131376 "group"
	protected explicit_type "int"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 131504 "color"
	protected explicit_type "defaulttype::Vec4f"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 131632 "size"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 130608 // previous (<unidirectional association>)
	relation 130608 --->
	  a role_name "previous" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 130608 // previous (<unidirectional association>)
	  b parent class_ref 132016 // CollisionModel
      end

      classrelation 130736 // next (<unidirectional association>)
	relation 130736 --->
	  a role_name "next" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} * ${name}${value};
"
	    classrelation_ref 130736 // next (<unidirectional association>)
	  b parent class_ref 132016 // CollisionModel
      end

      attribute 131760 "numberOfContacts"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 132912 "ExecParams"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Class gathering parameters use by most components methods, and transmitted by all visitors"
      class 133808 "ExecMode"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum ${name} {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 132784 "EXEC_NONE"
	  public type class_ref 133808 // ExecMode
	  init_value " 0"
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 132912 "EXEC_DEFAULT"
	  public type class_ref 133808 // ExecMode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 133040 "EXEC_DEBUG"
	  public type class_ref 133808 // ExecMode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 133168 "EXEC_GPU"
	  public type class_ref 133808 // ExecMode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 133296 "EXEC_GRAPH"
	  public type class_ref 133808 // ExecMode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 133424 "EXEC_KAAPI"
	  public type class_ref 133808 // ExecMode
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 148912 "execMode"
	const cpp_inline public return_type class_ref 133808 // ExecMode
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_execMode; };
"
	
	
	
	
	comment "/ Mode of execution requested"
      end

      operation 149040 "threadID"
	const cpp_inline public explicit_return_type "int"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return m_threadID; };
"
	
	
	
	
	comment "/ Index of current thread (0 corresponding to the only thread in sequential mode, or first thread in parallel mode)"
      end

      operation 149168 "ExecParams"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : m_execMode(EXEC_DEFAULT)
    , m_threadID(0)
    {
    };
"
	
	
	
	
      end

      operation 149296 "defaultInstance"
	class_operation cpp_inline public return_type class_ref 132912 // ExecParams
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        static ExecParams m_defaultInstance;

        return &m_defaultInstance;
    };
"
	
	
	
	
	comment "/ Get the default ExecParams, to be used to provide a default values for method parameters"
      end

      operation 149424 "setExecMode"
	cpp_inline public return_type class_ref 132912 // ExecParams
	nparams 1
	  param in name "v" type class_ref 133808 // ExecMode
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_execMode = v; return *this; };
"
	
	
	
	
	comment "/ Request a specific mode of execution"
      end

      operation 149552 "setThreadID"
	cpp_inline public return_type class_ref 132912 // ExecParams
	nparams 1
	  param in name "v" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { m_threadID = v; return *this; };
"
	
	
	
	
	comment "/ Specify the index of the current thread"
      end

      classrelation 132272 // m_execMode (<directional composition>)
	relation 132272 *-->
	  a role_name "m_execMode" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 132272 // m_execMode (<directional composition>)
	  b parent class_ref 133808 // ExecMode
      end

      attribute 133552 "m_threadID"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 133168 "ConstVecCoordId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_COORD, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 133296 "ConstVecDerivId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_DERIV, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 133424 "DataEngine"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief from a set of Data inputs computes a set of Data outputs
 *"
      classrelation 131632 // <generalisation>
	relation 131632 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 131632 // <generalisation>
	  b parent class_ref 133552 // DDGNode
      end

      classrelation 131760 // <generalisation>
	relation 131760 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 131760 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 131888 // <generalisation>
	relation 131888 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 131888 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 148400 "DataEngine"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
	comment "/ Constructor"
      end

      operation 148528 "~DataEngine"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
	comment "/ Destructor. Do nothing"
      end
    end

    class 133680 "DevBaseMonitor"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief A basic interface to define a Monitor capable to compute metrics.
 *
 *
 *"
      classrelation 132016 // <generalisation>
	relation 132016 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 132016 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 132144 // <generalisation>
	relation 132144 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 132144 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 148656 "~DevBaseMonitor"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 148784 "eval"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Compute metrics"
      end
    end

    class 133936 "Mapping"
      abstract visibility package 
      nformals 2
      formal name "In" type "class" explicit_default_value ""
        explicit_extends ""
      formal name "Out" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
*  \\brief Specialized interface to convert a model of type TIn to an other model of type TOut
*
*  This Interface is used for the Mappings. A Mapping can convert one model to an other.
*  For example, we can have a mapping from a BehaviorModel to a VisualModel.
*"
      classrelation 132400 // <generalisation>
	relation 132400 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 132400 // <generalisation>
	  b parent class_ref 128048 // BaseMapping
      end

      class 134064 "In"
	visibility package stereotype "typedef" explicit_base_type "TIn"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 134192 "Out"
	visibility package stereotype "typedef" explicit_base_type "TOut"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 134320 "InVecCoord"
	visibility package stereotype "typedef" explicit_base_type "In::VecCoord"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 134448 "InVecDeriv"
	visibility package stereotype "typedef" explicit_base_type "In::VecDeriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 134576 "InMatrixDeriv"
	visibility package stereotype "typedef" explicit_base_type "In::MatrixDeriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 134704 "InDataVecCoord"
	visibility package stereotype "typedef" base_type class_ref 134320 // InVecCoord
	cpp_decl "${comment}typedef Data<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 132528 // <dependency>
	  relation 132528 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 132528 // <dependency>
	    b parent class_ref 134320 // InVecCoord
	end
      end

      class 134832 "InDataVecDeriv"
	visibility package stereotype "typedef" base_type class_ref 134448 // InVecDeriv
	cpp_decl "${comment}typedef Data<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 132656 // <dependency>
	  relation 132656 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 132656 // <dependency>
	    b parent class_ref 134448 // InVecDeriv
	end
      end

      class 134960 "InDataMatrixDeriv"
	visibility package stereotype "typedef" base_type class_ref 134576 // InMatrixDeriv
	cpp_decl "${comment}typedef Data<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 132784 // <dependency>
	  relation 132784 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 132784 // <dependency>
	    b parent class_ref 134576 // InMatrixDeriv
	end
      end

      class 135088 "OutVecCoord"
	visibility package stereotype "typedef" explicit_base_type "Out::VecCoord"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 135216 "OutVecDeriv"
	visibility package stereotype "typedef" explicit_base_type "Out::VecDeriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 135344 "OutMatrixDeriv"
	visibility package stereotype "typedef" explicit_base_type "Out::MatrixDeriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 135472 "OutDataVecCoord"
	visibility package stereotype "typedef" base_type class_ref 135088 // OutVecCoord
	cpp_decl "${comment}typedef Data<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 132912 // <dependency>
	  relation 132912 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 132912 // <dependency>
	    b parent class_ref 135088 // OutVecCoord
	end
      end

      class 135600 "OutDataVecDeriv"
	visibility package stereotype "typedef" base_type class_ref 135216 // OutVecDeriv
	cpp_decl "${comment}typedef Data<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 133040 // <dependency>
	  relation 133040 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 133040 // <dependency>
	    b parent class_ref 135216 // OutVecDeriv
	end
      end

      class 135728 "OutDataMatrixDeriv"
	visibility package stereotype "typedef" base_type class_ref 135344 // OutMatrixDeriv
	cpp_decl "${comment}typedef Data<${type}> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 133168 // <dependency>
	  relation 133168 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 133168 // <dependency>
	    b parent class_ref 135344 // OutMatrixDeriv
	end
      end

      attribute 133680 "fromModel"
	protected explicit_type " In "
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 133808 "toModel"
	protected explicit_type " Out "
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 133296 // m_inputObject (<directional composition>)
	relation 133296 *-->
	  a role_name "m_inputObject" public
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 133296 // m_inputObject (<directional composition>)
	  b parent class_ref 135984 // DataObjectRef
      end

      classrelation 133424 // m_outputObject (<directional composition>)
	relation 133424 *-->
	  a role_name "m_outputObject" public
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 133424 // m_outputObject (<directional composition>)
	  b parent class_ref 135984 // DataObjectRef
      end

      attribute 133936 "f_checkJacobian"
	public explicit_type "bool"
	stereotype "Data"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 149680 "Mapping"
	public explicit_return_type ""
	nparams 2
	  param inout name "from" explicit_type "State< In >"
	    defaultvalue "NULL"
	  param inout name "to" explicit_type "State< Out >"
	    defaultvalue "NULL"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${t0} * ${p0}, ${t1} * ${p1}${)}${throw}{
  ${body}}
"
	
	
	
	
	comment "/ Constructor, taking input and output models as parameters.
/
/ Note that if you do not specify these models here, you must called
/ setModels with non-NULL value before the intialization (i.e. before
/ init() is called)."
      end

      operation 149808 "~Mapping"
	cpp_virtual public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${throw}{
  ${body}}
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 149936 "setModels"
	cpp_virtual public explicit_return_type "void"
	nparams 2
	  param inout name "from" explicit_type "State< In >"
	  param inout name "to" explicit_type "State< Out >"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}, ${t1} * ${p1}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Specify the input and output models."
      end

      operation 150064 "setPathInputObject"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "o" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {m_inputObject.setValue(o);};
"
	
	
	
	
	comment "/ Set the path to the objects mapped in the scene graph"
      end

      operation 150192 "setPathOutPutObject"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "o" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {m_outputObject.setValue(o);};
"
	
	
	
	
      end

      operation 150320 "getFromModel"
	public explicit_return_type "State< In >"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Return the pointer to the input model."
      end

      operation 150448 "getToModel"
	public explicit_return_type "State< Out >"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} * ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Return the pointer to the output model."
      end

      operation 150576 "getFrom"
	public explicit_return_type "helper::vector<BaseState*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Return the pointer to the input model."
      end

      operation 150704 "getTo"
	public explicit_return_type "helper::vector<BaseState*>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Return the pointer to the output model."
      end

      operation 150832 "apply"
	cpp_virtual public explicit_return_type "void"
	nparams 3
	  param in name "outPos" type class_ref 128432 // MultiVecCoordId
	  param in name "inPos" type class_ref 128560 // ConstMultiVecCoordId
	  param in name "mparams" type class_ref 128688 // MechanicalParams
	    defaultvalue "MechanicalParams::defaultInstance() "
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, const ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}, const ${t2} * ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Apply ///
/ Apply the mapping on position vectors.
/
/ If the Mapping can be represented as a matrix J, this method computes
/ $ out = J in $"
      end

      operation 150960 "apply"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 3
	  param inout name "out" type class_ref 135472 // OutDataVecCoord
	  param in name "in" type class_ref 134704 // InDataVecCoord
	  param in name "" type class_ref 128688 // MechanicalParams
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}, const ${t2} * ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ This method must be reimplemented by all mappings."
      end
    end

    class 135856 "State"
      abstract visibility package 
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Component storing position and velocity vectors.
 *
 *  This class define the interface of components used as source and
 *  destination of regular (non mechanical) mapping. It is then specialized as
 *  MechanicalState (storing other mechanical data) or MappedModel (if no
 *  mechanical data is used, such as for VisualModel).
 *
 *  The given DataTypes class should define the following internal types:
 *  \\li \\code Real \\endcode : scalar values (float or double).
 *  \\li \\code Coord \\endcode : position values.
 *  \\li \\code Deriv \\endcode : derivative values (velocity).
 *  \\li \\code VecReal \\endcode : container of scalar values with the same API as sofa::helper::vector.
 *  \\li \\code VecCoord \\endcode : container of Coord values with the same API as sofa::helper::vector.
 *  \\li \\code VecDeriv \\endcode : container of Deriv values with the same API as sofa::helper::vector
 *  \\li \\code MatrixDeriv \\endcode : vector of Jacobians
 *
 *  \\todo sofa::core::behavior::State is related to sofa::core::Mapping, and not to sofa::core::behavior::MechanicalMapping. It should be moved to sofa::core ?
 *"
      classrelation 138416 // <generalisation>
	relation 138416 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 138416 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 138544 // <generalisation>
	relation 138544 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 138544 // <generalisation>
	  b parent class_ref 129456 // BaseState
      end

      class 142896 "DataTypes"
	visibility package stereotype "typedef" explicit_base_type "TDataTypes"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143024 "Real"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::Real"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143152 "Coord"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::Coord"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143280 "Deriv"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::Deriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143408 "VecReal"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::VecReal"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143536 "VecCoord"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::VecCoord"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143664 "VecDeriv"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::VecDeriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 143792 "MatrixDeriv"
	visibility package stereotype "typedef" explicit_base_type "DataTypes::MatrixDeriv"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 171696 "~State"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
      end

      operation 171824 "write"
	abstract cpp_virtual public explicit_return_type "Data< VecCoord >"
	nparams 1
	  param in name "v" type class_ref 143920 // VecCoordId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ @name New vectors access API based on VecId
/ @{"
      end

      operation 171952 "read"
	abstract const cpp_virtual public explicit_return_type "Data< VecCoord >"
	nparams 1
	  param in name "v" type class_ref 133168 // ConstVecCoordId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 172080 "write"
	abstract cpp_virtual public explicit_return_type "Data< VecDeriv >"
	nparams 1
	  param in name "v" type class_ref 144048 // VecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 172208 "read"
	abstract const cpp_virtual public explicit_return_type "Data< VecDeriv >"
	nparams 1
	  param in name "v" type class_ref 133296 // ConstVecDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 172336 "write"
	abstract cpp_virtual public explicit_return_type "Data< MatrixDeriv >"
	nparams 1
	  param in name "v" type class_ref 144176 // MatrixDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 172464 "read"
	abstract const cpp_virtual public explicit_return_type "Data< MatrixDeriv >"
	nparams 1
	  param in name "v" type class_ref 144304 // ConstMatrixDerivId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end

      operation 172592 "getX"
	const cpp_virtual cpp_inline public return_type class_ref 143536 // VecCoord
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        const Data<VecCoord>* v = read(ConstVecCoordId::position());
        return (v == NULL) ? NULL : &(v->getValue());
    };
"
	
	
	
	
	comment "/ @}
/ @name Old specific vectors access API (now limited to read-only accesses)
/ @{
/ Return the current position vector.
/ @deprecated use read(ConstVecCoordId::position()) instead."
      end

      operation 172720 "getV"
	const cpp_virtual cpp_inline public return_type class_ref 143664 // VecDeriv
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        const Data<VecDeriv>* v = read(ConstVecDerivId::velocity());
        return (v == NULL) ? NULL : &(v->getValue());
    };
"
	
	
	
	
	comment "/ Return the current velocity vector.
/ @deprecated use read(ConstVecDerivId::velocity()) instead."
      end

      operation 172848 "getX0"
	const cpp_virtual cpp_inline public return_type class_ref 143536 // VecCoord
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        const Data<VecCoord>* v = read(ConstVecCoordId::restPosition());
        return (v == NULL) ? NULL : &(v->getValue());
    };
"
	
	
	
	
	comment "/ Return the current rest position vector
/ (return NULL if the state does not store rest position).
/ @deprecated use read(ConstVecCoordId::restPosition()) instead."
      end

      operation 172976 "getN"
	const cpp_virtual cpp_inline public return_type class_ref 143664 // VecDeriv
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        const Data<VecDeriv>* v = read(ConstVecDerivId::normal());
        return (v == NULL) ? NULL : &(v->getValue());
    };
"
	
	
	
	
	comment "/ Return the current normal vector
/ (return NULL if the state does not store normal).
/ @deprecated use read(ConstVecDerivId::velocity()) instead."
      end

      operation 173104 "getTemplateName"
	const cpp_virtual cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return templateName(this);
    };
"
	
	
	
	
	comment "/ @}"
      end

      operation 173232 "templateName"
	class_operation cpp_inline public explicit_return_type "std::string"
	nparams 1
	  param in name "" explicit_type "State<DataTypes>"
	    defaultvalue "NULL"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return TDataTypes::Name();
    };
"
	
	
	
	
      end
    end

    class 136112 "StateVecAccessor<DataTypes,V_COORD,V_READ>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 136240 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_COORD, V_READ>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 136368 "MyDataVec"
	visibility package stereotype "typedef" explicit_base_type "Data<typename DataTypes::VecCoord>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 157104 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param in name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 136240 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
      end

      operation 157232 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      operation 157360 "read"
	const cpp_inline public return_type class_ref 136368 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state-> read(id);  };
"
	
	
	
	
      end

      attribute 134960 "state"
	const_attribute protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 134320 // id (<directional composition>)
	relation 134320 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134320 // id (<directional composition>)
	  b parent class_ref 136240 // MyVecId
      end
    end

    class 136496 "StateVecAccessor<DataTypes,V_COORD,V_WRITE>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 136624 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_COORD, V_WRITE>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 136752 "MyDataVec"
	visibility package stereotype "typedef" explicit_base_type "Data<typename DataTypes::VecCoord>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 157488 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param inout name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 136624 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
      end

      operation 157616 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      operation 157744 "read"
	const cpp_inline public return_type class_ref 136752 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state-> read(id);  };
"
	
	
	
	
      end

      operation 157872 "write"
	const cpp_inline public return_type class_ref 136752 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state->write(id);  };
"
	
	
	
	
      end

      attribute 135088 "state"
	protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 134448 // id (<directional composition>)
	relation 134448 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134448 // id (<directional composition>)
	  b parent class_ref 136624 // MyVecId
      end
    end

    class 136880 "StateVecAccessor<DataTypes,V_DERIV,V_READ>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 137008 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_DERIV, V_READ>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 137136 "MyDataVec"
	visibility package stereotype "typedef" explicit_base_type "Data<typename DataTypes::VecDeriv>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 158000 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param in name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 137008 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
      end

      operation 158128 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      operation 158256 "read"
	const cpp_inline public return_type class_ref 137136 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state-> read(id);  };
"
	
	
	
	
      end

      attribute 135216 "state"
	const_attribute protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 134576 // id (<directional composition>)
	relation 134576 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134576 // id (<directional composition>)
	  b parent class_ref 137008 // MyVecId
      end
    end

    class 137264 "StateVecAccessor<DataTypes,V_DERIV,V_WRITE>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 137392 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_DERIV, V_WRITE>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 137520 "MyDataVec"
	visibility package stereotype "typedef" explicit_base_type "Data<typename DataTypes::VecDeriv>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 158384 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param inout name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 137392 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
      end

      operation 158512 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      operation 158640 "read"
	const cpp_inline public return_type class_ref 137520 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state-> read(id);  };
"
	
	
	
	
      end

      operation 158768 "write"
	const cpp_inline public return_type class_ref 137520 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state->write(id);  };
"
	
	
	
	
      end

      attribute 135344 "state"
	protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 134704 // id (<directional composition>)
	relation 134704 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134704 // id (<directional composition>)
	  b parent class_ref 137392 // MyVecId
      end
    end

    class 137648 "StateVecAccessor<DataTypes,V_MATDERIV,V_READ>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 137776 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_MATDERIV, V_READ>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 137904 "MyDataVec"
	visibility package stereotype "typedef" explicit_base_type "Data<typename DataTypes::MatrixDeriv>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 158896 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param in name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 137776 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
      end

      operation 159024 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      operation 159152 "read"
	const cpp_inline public return_type class_ref 137904 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state-> read(id);  };
"
	
	
	
	
      end

      attribute 135472 "state"
	const_attribute protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 134832 // id (<directional composition>)
	relation 134832 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134832 // id (<directional composition>)
	  b parent class_ref 137776 // MyVecId
      end
    end

    class 138032 "StateVecAccessor<DataTypes,V_MATDERIV,V_WRITE>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 138160 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_MATDERIV, V_WRITE>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 138288 "MyDataVec"
	visibility package stereotype "typedef" explicit_base_type "Data<typename DataTypes::MatrixDeriv>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 159280 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param inout name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 138160 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
      end

      operation 159408 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      operation 159536 "read"
	const cpp_inline public return_type class_ref 138288 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state-> read(id);  };
"
	
	
	
	
      end

      operation 159664 "write"
	const cpp_inline public return_type class_ref 138288 // MyDataVec
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {  return state->write(id);  };
"
	
	
	
	
      end

      attribute 135600 "state"
	protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 134960 // id (<directional composition>)
	relation 134960 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 134960 // id (<directional composition>)
	  b parent class_ref 138160 // MyVecId
      end
    end

    class 138416 "StateVecAccessor<DataTypes,V_ALL,V_READ>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 138544 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_ALL, V_READ>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 159792 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param in name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 138544 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
	comment "typedef BaseData MyDataVec;"
      end

      operation 159920 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      attribute 135728 "state"
	const_attribute protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 135088 // id (<directional composition>)
	relation 135088 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 135088 // id (<directional composition>)
	  b parent class_ref 138544 // MyVecId
      end
    end

    class 138672 "StateVecAccessor<DataTypes,V_ALL,V_WRITE>"
      visibility package stereotype "struct"
      nformals 1
      formal name "DataTypes" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 138800 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_ALL, V_WRITE>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 160048 "StateVecAccessor"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param inout name "state" explicit_type "State<DataTypes>"
	  param in name "id" type class_ref 138800 // MyVecId
	cpp_decl "    ${comment}${inline}${name}${(}${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${volatile}${throw} : state(state), id(id) {};
"
	
	
	
	
	comment "typedef BaseData MyDataVec;"
      end

      operation 160176 "operator MyVecId"
	const cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract} {  return id;  };
"
	
	
	
	
      end

      attribute 135856 "state"
	protected explicit_type "DataTypes"
	stereotype "State"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> * ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      classrelation 135216 // id (<directional composition>)
	relation 135216 *-->
	  a role_name "id" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 135216 // id (<directional composition>)
	  b parent class_ref 138800 // MyVecId
      end
    end

    class 138928 "TMultiVecId"
      visibility package 
      nformals 2
      formal name "vtype" type "VecType" explicit_default_value ""
        explicit_extends ""
      formal name "vaccess" type "VecAccess" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 139056 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<vtype, vaccess>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      classrelation 135344 // defaultId (<directional composition>)
	relation 135344 *-->
	  a role_name "defaultId" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 135344 // defaultId (<directional composition>)
	  b parent class_ref 139056 // MyVecId
      end

      class 139184 "IdMap"
	visibility package stereotype "typedef" base_type class_ref 129456 // BaseState
	cpp_decl "${comment}typedef std::map<const ${type}*,MyVecId> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 135472 // <dependency>
	  relation 135472 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 135472 // <dependency>
	    b parent class_ref 129456 // BaseState
	end
      end

      class 139312 "IdMap_iterator"
	visibility package stereotype "typedef" explicit_base_type "IdMap::iterator"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 139440 "IdMap_const_iterator"
	visibility package stereotype "typedef" explicit_base_type "IdMap::const_iterator"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      classrelation 135600 // idMap (<directional composition>)
	relation 135600 *-->
	  a role_name "idMap" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 135600 // idMap (<directional composition>)
	  b parent class_ref 139184 // IdMap
      end

      operation 160304 "TMultiVecId"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} {
    };
"
	
	
	
	
      end

      operation 160432 "TMultiVecId"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype, vaccess2>"
	cpp_decl "    ${comment}template< VecAccess vaccess2>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : defaultId(v)
    {
        BOOST_STATIC_ASSERT(vaccess2 >= vaccess);
    };
"
	
	
	
	
	comment "/ Copy from another VecId, possibly with another type of access, with the
/ constraint that the access must be compatible (i.e. cannot create
/ a write-access VecId from a read-only VecId."
      end

      operation 160560 "TMultiVecId"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "mv" explicit_type "TMultiVecId<vtype2,vaccess2>"
	cpp_decl "    ${comment}template<  VecType vtype2template<  VecAccess vaccess2>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : defaultId( mv.getDefaultId() )
    {
        BOOST_STATIC_ASSERT( vaccess2 >= vaccess ); 
        BOOST_STATIC_ASSERT( vtype == V_ALL || vtype2 == vtype );

        std::copy(mv.getIdMap().begin(), mv.getIdMap().end(), std::inserter(idMap, idMap.begin()) );
    };
"
	
	
	
	
	comment "// Only TMultiVecId< V_ALL , vaccess> can declare copy constructors with all 
// other kinds of TMultiVecIds, namely MultiVecCoordId, MultiVecDerivId... 
// In other cases, the copy constructor takes a TMultiVecId of the same type
// ie copy construct a MultiVecCoordId from a const MultiVecCoordId& or a 
// ConstMultiVecCoordId&."
      end

      operation 160688 "setDefaultId"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "id" type class_ref 139056 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        defaultId = id;
    };
"
	
	
	
	
      end

      operation 160816 "setId"
	stereotype "template"
	cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "states" explicit_type "StateSet"
	  param in name "id" type class_ref 139056 // MyVecId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        for (typename StateSet::const_iterator it = states.begin(), itend = states.end(); it != itend; ++it)
            idMap[*it] = id;
    };
"
	
	
	
	
      end

      operation 160944 "setId"
	cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "s" type class_ref 129456 // BaseState
	  param in name "id" type class_ref 139056 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        idMap[s] = id;
    };
"
	
	
	
	
      end

      operation 161072 "assign"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "id" type class_ref 139056 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        defaultId = id;
        idMap.clear();
    };
"
	
	
	
	
      end

      operation 161200 "getId"
	const cpp_inline public return_type class_ref 139056 // MyVecId
	nparams 1
	  param in name "s" type class_ref 129456 // BaseState
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        IdMap_const_iterator it = idMap.find(s);
        if (it != idMap.end()) return it->second;
        else                   return defaultId;
    };
"
	
	
	
	
      end

      operation 161328 "getIdMap"
	const cpp_inline public explicit_return_type "std::map<const BaseState*, MyVecId>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
      return idMap;
    };
"
	
	
	
	
      end

      operation 161456 "getDefaultId"
	const cpp_inline public return_type class_ref 139056 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return defaultId;
    };
"
	
	
	
	
      end

      operation 161584 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if (idMap.empty())
            return defaultId.getName();
        else
        {
            std::ostringstream out;
            out << '{';
            out << defaultId.getName() << \"[*\";
            MyVecId prev = defaultId;
            for (IdMap_const_iterator it = idMap.begin(), itend = idMap.end(); it != itend; ++it)
            {
                if (it->second != prev) // new id
                {
                    out << \"],\";
                    if (it->second.getType() == defaultId.getType())
                        out << it->second.getIndex();
                    else
                        out << it->second.getName();
                    out << '[';
                    prev = it->second;
                }
                else out << ',';
                if (it->first == NULL) out << \"NULL\";
                else
                    out << it->first->getName();
            }
            out << \"]}\";
            return out.str();
        }
    };
"
	
	
	
	
      end

      operation 161712 "operator <<"
	friend cpp_inline public explicit_return_type "std::ostream"
	nparams 2
	  param inout name "out" explicit_type "std::ostream"
	  param in name "v" explicit_type "TMultiVecId<vtype, vaccess>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        out << v.getName();
        return out;
    };
"
	
	
	
	
      end

      operation 161840 "null"
	class_operation cpp_inline public explicit_return_type "TMultiVecId<vtype, vaccess>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return TMultiVecId(MyVecId::null()); };
"
	
	
	
	
      end

      operation 161968 "isNull"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if (!this->defaultId.isNull()) return false;
        for (IdMap_const_iterator it = idMap.begin(), itend = idMap.end(); it != itend; ++it)
            if (!it->second.isNull()) return false;
        return true;
    };
"
	
	
	
	
      end

      operation 162096 "operator []"
	stereotype "template"
	const cpp_inline public explicit_return_type "StateVecAccessor<DataTypes,vtype,vaccess>"
	nparams 1
	  param inout name "s" explicit_type "State<DataTypes>"
	cpp_decl "    ${comment}template<class DataTypes>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return StateVecAccessor<DataTypes,vtype,vaccess>(s,getId(s));
    };
"
	
	
	
	
	comment " fId.write(mstate);
 fId[mstate].write();   <- THE CURRENT API
 mstate->write(fId.getId(mstate));"
      end

      operation 162224 "operator []"
	stereotype "template"
	const cpp_inline public explicit_return_type "StateVecAccessor<DataTypes,vtype,V_READ>"
	nparams 1
	  param in name "s" explicit_type "State<DataTypes>"
	cpp_decl "    ${comment}template<class DataTypes>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return StateVecAccessor<DataTypes,vtype,V_READ>(s,getId(s));
    };
"
	
	
	
	
      end
    end

    class 139568 "TVecId"
      visibility package 
      nformals 2
      formal name "vtype" type "VecType" explicit_default_value ""
        explicit_extends ""
      formal name "vaccess" type "VecAccess" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Identify a vector of a given type stored in State
/ This class is templated in order to create different variations (generic versus specific type, read-only vs write access)"
      classrelation 139056 // <generalisation>
	relation 139056 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 139056 // <generalisation>
	  b parent class_ref 146480 // typedef5
      end

      attribute 138416 "index"
	public explicit_type "uint"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 175920 "TVecId"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : index(0) { };
"
	
	
	
	
      end

      operation 176048 "TVecId"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "i" explicit_type "uint"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}${)}${volatile}${throw} : index(i) { };
"
	
	
	
	
      end

      operation 176176 "TVecId"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype, vaccess2>"
	cpp_decl "    ${comment}template< VecAccess vaccess2>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : index(v.getIndex())
    {
        BOOST_STATIC_ASSERT(vaccess2 >= vaccess);
    };
"
	
	
	
	
	comment "/ Copy from another VecId, possibly with another type of access, with the
/ constraint that the access must be compatible (i.e. cannot create
/ a write-access VecId from a read-only VecId."
      end

      operation 176304 "TVecId"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype, V_WRITE>"
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : index(v.getIndex()) { };
"
	
	
	
	
      end

      operation 176432 "TVecId"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "v" explicit_type "TVecId<V_ALL, vaccess>"
	cpp_decl "    ${comment}${inline}explicit ${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : index(v.getIndex())
    {
#ifndef NDEBUG
        assert(v.getType() == vtype);
#endif
    };
"
	
	
	
	
      end

      operation 176560 "getType"
	const cpp_inline public return_type class_ref 144432 // VecType
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return vtype; };
"
	
	
	
	
      end

      operation 176688 "getIndex"
	const cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return index; };
"
	
	
	
	
      end

      operation 176816 "operator =="
	stereotype "template"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype2, vaccess2>"
	cpp_decl "    ${comment}template< VecType vtype2template<  VecAccess vaccess2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return getType() == v.getType() && getIndex() == v.getIndex();
    };
"
	
	
	
	
      end

      operation 176944 "operator !="
	stereotype "template"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype2, vaccess2>"
	cpp_decl "    ${comment}template< VecType vtype2template<  VecAccess vaccess2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return getType() != v.getType() || getIndex() != v.getIndex();
    };
"
	
	
	
	
      end

      operation 177072 "null"
	class_operation cpp_inline public return_type class_ref 139568 // TVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return TVecId(0);};
"
	
	
	
	
      end

      operation 177200 "isNull"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return this->index == 0; };
"
	
	
	
	
      end

      operation 177328 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return TStandardVec<vtype, vaccess>::getName(*this);
    };
"
	
	
	
	
      end

      operation 177456 "operator <<"
	friend cpp_inline public explicit_return_type "std::ostream"
	nparams 2
	  param inout name "out" explicit_type "std::ostream"
	  param in name "v" type class_ref 139568 // TVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        out << v.getName();
        return out;
    };
"
	
	
	
	
      end
    end

    class 139696 "TMultiVecId<V_ALL,vaccess>"
      visibility package 
      nformals 1
      formal name "VecAccess vaccess" type "" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "    template<class DataTypes>
    typename const typename DataTypesVecInfo<DataTypes,vtype>::DataVecT* read(const State<DataTypes>* s) const
    {
        return s->read(getId(s));
    }

    template<class DataTypes>
    typename DataTypesVecInfo<DataTypes,vtype>::DataVecT* write(State<DataTypes>* s) const
    {
        BOOST_STATIC_ASSERT(vaccess >= V_WRITE);
        return s->write(getId(s));
    }"
      class 139824 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_ALL, vaccess>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      classrelation 135728 // defaultId (<directional composition>)
	relation 135728 *-->
	  a role_name "defaultId" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 135728 // defaultId (<directional composition>)
	  b parent class_ref 139824 // MyVecId
      end

      class 139952 "IdMap"
	visibility package stereotype "typedef" base_type class_ref 129456 // BaseState
	cpp_decl "${comment}typedef std::map<const ${type}*,MyVecId> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 135856 // <dependency>
	  relation 135856 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 135856 // <dependency>
	    b parent class_ref 129456 // BaseState
	end
      end

      class 140080 "IdMap_iterator"
	visibility package stereotype "typedef" explicit_base_type "IdMap::iterator"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      class 140208 "IdMap_const_iterator"
	visibility package stereotype "typedef" explicit_base_type "IdMap::const_iterator"
	cpp_decl "${comment}typedef  typename ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      classrelation 135984 // idMap (<directional composition>)
	relation 135984 *-->
	  a role_name "idMap" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 135984 // idMap (<directional composition>)
	  b parent class_ref 139952 // IdMap
      end

      operation 162352 "TMultiVecId"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} {
    };
"
	
	
	
	
      end

      operation 162480 "TMultiVecId"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype2, vaccess2>"
	cpp_decl "    ${comment}template< VecType vtype2template<  VecAccess vaccess2>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : defaultId(v)
    {
        BOOST_STATIC_ASSERT(vaccess2 >= vaccess);
    };
"
	
	
	
	
	comment "/ Copy from another VecId, possibly with another type of access, with the
/ constraint that the access must be compatible (i.e. cannot create
/ a write-access VecId from a read-only VecId."
      end

      operation 162608 "TMultiVecId"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "mv" explicit_type "TMultiVecId<vtype2,vaccess2>"
	cpp_decl "    ${comment}template<  VecType vtype2template<  VecAccess vaccess2>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : defaultId( mv.getDefaultId() )
    {
        BOOST_STATIC_ASSERT( vaccess2 >= vaccess ); 
        //BOOST_STATIC_ASSERT( vtype == V_ALL || vtype2 == vtype );

        std::copy(mv.getIdMap().begin(), mv.getIdMap().end(), std::inserter(idMap, idMap.begin()) );
    };
"
	
	
	
	
	comment "// Only TMultiVecId< V_ALL , vaccess> can declare copy constructors with all 
// other kinds of TMultiVecIds, namely MultiVecCoordId, MultiVecDerivId... 
// In other cases, the copy constructor takes a TMultiVecId of the same type
// ie copy construct a MultiVecCoordId from a const MultiVecCoordId& or a 
// ConstMultiVecCoordId&."
      end

      operation 162736 "setDefaultId"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "id" type class_ref 139824 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        defaultId = id;
    };
"
	
	
	
	
      end

      operation 162864 "setId"
	stereotype "template"
	cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "states" explicit_type "StateSet"
	  param in name "id" type class_ref 139824 // MyVecId
	cpp_decl "    ${comment}template<class StateSet>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        for (typename StateSet::const_iterator it = states.begin(), itend = states.end(); it != itend; ++it)
            idMap[*it] = id;
    };
"
	
	
	
	
      end

      operation 162992 "setId"
	cpp_inline public explicit_return_type "void"
	nparams 2
	  param in name "s" type class_ref 129456 // BaseState
	  param in name "id" type class_ref 139824 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        idMap[s] = id;
    };
"
	
	
	
	
      end

      operation 163120 "assign"
	cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "id" type class_ref 139824 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        defaultId = id;
        idMap.clear();
    };
"
	
	
	
	
      end

      operation 163248 "getId"
	const cpp_inline public return_type class_ref 139824 // MyVecId
	nparams 1
	  param in name "s" type class_ref 129456 // BaseState
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        IdMap_const_iterator it = idMap.find(s);
        if (it != idMap.end()) return it->second;
        else                   return defaultId;
    };
"
	
	
	
	
      end

      operation 163376 "getIdMap"
	const cpp_inline public explicit_return_type "std::map<const BaseState*, MyVecId>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
      return idMap;
    };
"
	
	
	
	
      end

      operation 163504 "getDefaultId"
	const cpp_inline public return_type class_ref 139824 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return defaultId;
    };
"
	
	
	
	
      end

      operation 163632 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if (idMap.empty())
            return defaultId.getName();
        else
        {
            std::ostringstream out;
            out << '{';
            out << defaultId.getName() << \"[*\";
            MyVecId prev = defaultId;
            for (IdMap_const_iterator it = idMap.begin(), itend = idMap.end(); it != itend; ++it)
            {
                if (it->second != prev) // new id
                {
                    out << \"],\";
                    if (it->second.getType() == defaultId.getType())
                        out << it->second.getIndex();
                    else
                        out << it->second.getName();
                    out << '[';
                    prev = it->second;
                }
                else out << ',';
                if (it->first == NULL) out << \"NULL\";
                else
                    out << it->first->getName();
            }
            out << \"]}\";
            return out.str();
        }
    };
"
	
	
	
	
      end

      operation 163760 "operator <<"
	friend cpp_inline public explicit_return_type "std::ostream"
	nparams 2
	  param inout name "out" explicit_type "std::ostream"
	  param in name "v" explicit_type "TMultiVecId<V_ALL, vaccess>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        out << v.getName();
        return out;
    };
"
	
	
	
	
      end

      operation 163888 "null"
	class_operation cpp_inline public explicit_return_type "TMultiVecId<V_ALL, vaccess>"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return TMultiVecId(MyVecId::null()); };
"
	
	
	
	
      end

      operation 164016 "isNull"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        if (!this->defaultId.isNull()) return false;
        for (IdMap_const_iterator it = idMap.begin(), itend = idMap.end(); it != itend; ++it)
            if (!it->second.isNull()) return false;
        return true;
    };
"
	
	
	
	
      end

      operation 164144 "operator []"
	stereotype "template"
	const cpp_inline public explicit_return_type "StateVecAccessor<DataTypes,V_ALL,vaccess>"
	nparams 1
	  param inout name "s" explicit_type "State<DataTypes>"
	cpp_decl "    ${comment}template<class DataTypes>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return StateVecAccessor<DataTypes,V_ALL,vaccess>(s,getId(s));
    };
"
	
	
	
	
	comment " fId.write(mstate);
 fId[mstate].write();   <- THE CURRENT API
 mstate->write(fId.getId(mstate));"
      end

      operation 164272 "operator []"
	stereotype "template"
	const cpp_inline public explicit_return_type "StateVecAccessor<DataTypes,V_ALL,V_READ>"
	nparams 1
	  param in name "s" explicit_type "State<DataTypes>"
	cpp_decl "    ${comment}template<class DataTypes>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return StateVecAccessor<DataTypes,V_ALL,V_READ>(s,getId(s));
    };
"
	
	
	
	
      end
    end

    class 140336 "ConstMultiVecId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_ALL, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 140464 "MultiVecId"
      visibility package stereotype "typedef" explicit_base_type "TMultiVecId<V_ALL, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 141488 "ObjectCreator"
      visibility package 
      nformals 1
      formal name "RealObject" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Typed Creator class used to create instances of object type RealObject"
      classrelation 137008 // <generalisation>
	relation 137008 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 137008 // <generalisation>
	  b parent class_ref 130352 // Creator
      end

      operation 167216 "canCreate"
	cpp_inline public explicit_return_type "bool"
	nparams 2
	  param inout name "context" type class_ref 141104 // BaseContext
	  param inout name "arg" type class_ref 141232 // BaseObjectDescription
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        RealObject* instance = NULL;
        return RealObject::canCreate(instance, context, arg);
    };
"
	
	
	
	
      end

      operation 167344 "createInstance"
	cpp_inline public return_type class_ref 128304 // BaseObject
	nparams 2
	  param inout name "context" type class_ref 141104 // BaseContext
	  param inout name "arg" type class_ref 141232 // BaseObjectDescription
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        RealObject* instance = NULL;
        RealObject::create(instance, context, arg);
        return instance;
    };
"
	
	
	
	
      end

      operation 167472 "type"
	cpp_inline public explicit_return_type "std::type_info"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return typeid(RealObject);
    };
"
	
	
	
	
      end

      operation 167600 "getClass"
	cpp_virtual cpp_inline public return_type class_ref 141360 // BaseClass
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return RealObject::GetClass();
    };
"
	
	
	
	
      end

      operation 167728 "getTarget"
	cpp_virtual cpp_inline public explicit_return_type "char"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}${)}${const}${volatile}${throw}${abstract} {
#ifdef SOFA_TARGET
        return sofa_tostring(SOFA_TARGET);
#else
        return \"\";
#endif
    };
"
	
	
	
	
	comment "/ The name of the library or executable containing the binary code for this component"
      end
    end

    class 141616 "RegisterObject"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief Helper class used to register a class in the ObjectFactory.
 *
 *  This class accumulate information about a given class, as well as creators
 *  for each supported template instanciation, to register a new entry in
 *  the ObjectFactory.
 *
 *  It should be used as a temporary object, finalized when used to initialize
 *  an int static variable. For example :
 *  \\code
 *    int Fluid3DClass = core::RegisterObject(\"Eulerian 3D fluid\")
 *    .add\\< Fluid3D \\>()
 *    .addLicense(\"LGPL\")
 *    .addAuthor(\"Jeremie Allard\")
 *    ;
 *  \\endcode
 *"
      classrelation 137136 // entry (<directional composition>)
	relation 137136 *-->
	  a role_name "entry" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 137136 // entry (<directional composition>)
	  b parent class_ref 132784 // ClassEntry
      end

      operation 167856 "RegisterObject"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 1
	  param in name "description" explicit_type "std::string"
	cpp_decl "    ${comment}${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw};
"
	cpp_def "${comment}${inline}${class}::${name}${(}const ${t0} & ${p0}${)}${throw}{
  ${body}}
"
	
	
	
	
	comment "/ Start the registration by giving the description of this class."
      end

      operation 167984 "addAlias"
	preserve_cpp_body_indent public return_type class_ref 141616 // RegisterObject
	nparams 1
	  param in name "val" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} & ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Add an alias name for this class"
      end

      operation 168112 "addDescription"
	preserve_cpp_body_indent public return_type class_ref 141616 // RegisterObject
	nparams 1
	  param in name "val" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} & ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Add more descriptive text about this class"
      end

      operation 168240 "addAuthor"
	preserve_cpp_body_indent public return_type class_ref 141616 // RegisterObject
	nparams 1
	  param in name "val" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} & ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Specify a list of authors (separated with spaces)"
      end

      operation 168368 "addLicense"
	preserve_cpp_body_indent public return_type class_ref 141616 // RegisterObject
	nparams 1
	  param in name "val" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} & ${class}::${name}${(}${t0} ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Specify a license (LGPL, GPL, ...)"
      end

      operation 168496 "addBaseClasses"
	preserve_cpp_body_indent public return_type class_ref 141616 // RegisterObject
	nparams 1
	  param in name "mclass" type class_ref 141360 // BaseClass
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}const ${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} & ${class}::${name}${(}const ${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Fill the base classes array using the BaseClass reflection system"
      end

      operation 168624 "addCreator"
	preserve_cpp_body_indent public return_type class_ref 141616 // RegisterObject
	nparams 3
	  param in name "classname" explicit_type "std::string"
	  param in name "templatename" explicit_type "std::string"
	  param in name "creator" explicit_type "std::auto_ptr<ObjectFactory::Creator>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} & ${class}::${name}${(}${t0} ${p0}, ${t1} ${p1}, ${t2} ${p2}${)}${const}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ Add a creator able to instance this class with the given templatename.
/
/ See the add<RealObject>() method for an easy way to add a Creator."
      end

      operation 168752 "add"
	stereotype "template"
	cpp_inline public return_type class_ref 141616 // RegisterObject
	nparams 1
	  param in name "defaultTemplate" explicit_type "bool"
	    defaultvalue "false"
	cpp_decl "    ${comment}template<class RealObject>
  ${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        RealObject* p = NULL;
        std::string classname = RealObject::className(p);
        std::string templatename = RealObject::templateName(p);

        if (defaultTemplate)
            entry.defaultTemplate = templatename;

        // This is the only place where we can test which base classes are implemented by this particular object, without having to create any instance
        // Unfortunately, we have to enumerate all classes we are interested in...
/*
        if (implements<RealObject,objectmodel::ContextObject>())
            entry.baseClasses.insert(\"ContextObject\");
        if (implements<RealObject,VisualModel>())
            entry.baseClasses.insert(\"VisualModel\");
        if (implements<RealObject,BehaviorModel>())
            entry.baseClasses.insert(\"BehaviorModel\");
        if (implements<RealObject,CollisionModel>())
            entry.baseClasses.insert(\"CollisionModel\");
        if (implements<RealObject,core::behavior::BaseMechanicalState>())
            entry.baseClasses.insert(\"MechanicalState\");
        if (implements<RealObject,core::behavior::BaseForceField>())
            entry.baseClasses.insert(\"ForceField\");
        if (implements<RealObject,core::behavior::InteractionForceField>())
            entry.baseClasses.insert(\"InteractionForceField\");
        if (implements<RealObject,core::behavior::BaseLMConstraint>())
            entry.baseClasses.insert(\"Constraint\");
        if (implements<RealObject,core::behavior::BaseConstraint>())
            entry.baseClasses.insert(\"Constraint\");
        if (implements<RealObject,core::BaseMapping>())
            entry.baseClasses.insert(\"Mapping\");
        if (implements<RealObject,core::behavior::BaseMechanicalMapping>())
	  entry.baseClasses.insert(\"MechanicalMapping\");
	if (implements<RealObject,core::topology::TopologicalMapping>())
	  entry.baseClasses.insert(\"TopologicalMapping\");
        if (implements<RealObject,core::behavior::BaseMass>())
            entry.baseClasses.insert(\"Mass\");
        if (implements<RealObject,core::behavior::OdeSolver>())
	  entry.baseClasses.insert(\"OdeSolver\");
	if (implements<RealObject,core::behavior::LinearSolver>())
	  entry.baseClasses.insert(\"LinearSolver\");
        if (implements<RealObject,core::behavior::MasterSolver>())
            entry.baseClasses.insert(\"MasterSolver\");
        if (implements<RealObject,core::topology::Topology>())
	  entry.baseClasses.insert(\"Topology\");
        if (implements<RealObject,core::topology::BaseTopologyObject>())
	  entry.baseClasses.insert(\"TopologyObject\");
	if (implements<RealObject,core::behavior::BaseController>())
	  entry.baseClasses.insert(\"Controller\");
	if (implements<RealObject,core::loader::BaseLoader>())
	  entry.baseClasses.insert(\"Loader\");
*/
        addBaseClasses(RealObject::GetClass());

        return addCreator(classname, templatename, std::auto_ptr<ObjectFactory::Creator>(new ObjectCreator<RealObject>));
    };
"
	
	
	
	
	comment "    /// Test whether T* converts to U*,
    /// that is, if T is derived from U
    /// taken from Modern C++ Design
    template <class T, class U>
    class SOFA_CORE_API Conversion
    {
        typedef char Small;
        class Big {char dummy[2];};
        static Small Test(U*);
        static Big Test(...);
        static T* MakeT();
    public:
        enum { exists = sizeof(Test(MakeT())) == sizeof(Small) };
        static int Exists() { return exists; }
    };

    /// Test whether T* converts to U*,
    /// that is, if T is derived from U
    template<class RealClass, class BaseClass>
    bool implements()
    {
        bool res = Conversion<RealClass, BaseClass>::exists;
        //RealClass* p1=NULL;
        //BaseClass* p2=NULL;
        //if (res)
        //    sout << \"class \"<<RealClass::typeName(p1)<<\" implements \"<<BaseClass::typeName(p2)<<sendl;
        //else
        //    sout << \"class \"<<RealClass::typeName(p1)<<\" does not implement \"<<BaseClass::typeName(p2)<<sendl;
        return res;
    }

/ Add a template instanciation of this class.
/
/ \\param defaultTemplate    set to true if this should be the default instance when no template name is given."
      end

      operation 168880 "operator int"
	preserve_cpp_body_indent public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
	comment "/ This is the final operation that will actually commit the additions to the ObjectFactory."
      end
    end

    class 141744 "ParallelCollisionModel"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 137264 // <generalisation>
	relation 137264 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 137264 // <generalisation>
	  b parent class_ref 132016 // CollisionModel
      end

      class 141872 "Iterator"
	visibility package stereotype "typedef" base_type class_ref 131888 // CollisionElementIterator
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 137392 // <dependency>
	  relation 137392 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 137392 // <dependency>
	    b parent class_ref 131888 // CollisionElementIterator
	end
      end

      class 142000 "Topology"
	visibility package stereotype "typedef" base_type class_ref 132272 // BaseMeshTopology
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 137520 // <dependency>
	  relation 137520 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 137520 // <dependency>
	    b parent class_ref 132272 // BaseMeshTopology
	end
      end

      operation 169008 "ParallelCollisionModel"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} {
    };
"
	
	
	
	
	comment "/ Constructor"
      end

      operation 169136 "~ParallelCollisionModel"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 169264 "computeBoundingTreeParallel"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 4
	  param in name "dt" explicit_type "double"
	  param in name "maxDepth" explicit_type "int"
	  param inout name "res1" explicit_type "a1::Shared<bool>"
	  param inout name "res2" explicit_type "a1::Shared<int>"
	    defaultvalue "NULL"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} & ${p2}${v2}, ${t3} * ${p3}${v3}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
      end
    end

    class 142128 "ParallelComputeBoundingTree"
      visibility package stereotype "struct"
      nformals 1
      formal name "T" type "class" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}struct ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      operation 169392 "operator ()"
	cpp_inline public explicit_return_type "void"
	nparams 6
	  param inout name "cm" type class_ref 132016 // CollisionModel
	  param in name "dt" explicit_type "double"
	  param in name "maxDepth" explicit_type "int"
	  param in name "X" explicit_type "Shared_r<T>"
	  param in name "res1" explicit_type "Shared_w<bool>"
	  param in name "res2" explicit_type "Shared_cw<int>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}, ${t4} ${p4}${v4}, ${t5} ${p5}${v5}${)}${const}${volatile}${throw}${abstract} {
	X.read();
	if (dt == 0.0) cm->computeBoundingTree(maxDepth);
	else cm->computeContinuousBoundingTree(dt, maxDepth);
	res1.write(true);
	res2.access() += 1;
    };
"
	
	
	
	
      end

      operation 169520 "operator ()"
	cpp_inline public explicit_return_type "void"
	nparams 5
	  param inout name "cm" type class_ref 132016 // CollisionModel
	  param in name "dt" explicit_type "double"
	  param in name "maxDepth" explicit_type "int"
	  param in name "X" explicit_type "Shared_r<T>"
	  param in name "res1" explicit_type "Shared_w<bool>"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} ${p1}${v1}, ${t2} ${p2}${v2}, ${t3} ${p3}${v3}, ${t4} ${p4}${v4}${)}${const}${volatile}${throw}${abstract} {
	X.read();
	if (dt == 0.0) cm->computeBoundingTree(maxDepth);
	else cm->computeContinuousBoundingTree(dt, maxDepth);
	res1.write(true);
    };
"
	
	
	
	
      end
    end

    class 142256 "Shader"
      abstract visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief A basic interface to define a Shader for different system (OpenGL, DirectX, ...).
 *
 *
 *"
      classrelation 137648 // <generalisation>
	relation 137648 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 137648 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 137776 // <generalisation>
	relation 137776 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 137776 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 169648 "~Shader"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 169776 "start"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Start the shader"
      end

      operation 169904 "stop"
	abstract cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/ Stop the shader"
      end

      operation 170032 "isActive"
	abstract cpp_virtual public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	
	
	
	
	comment "/Tells if it must be activated automatically(value false : the visitor will switch the shader)
/or manually (value true : useful when another component wants to use it for itself only)"
      end
    end

    class 142384 "ShaderElement"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief A basic interface to define an element to be used with a Shader.
 *
 *
 *"
      classrelation 137904 // <generalisation>
	relation 137904 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 137904 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 138032 // <generalisation>
	relation 138032 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 138032 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 170160 "~ShaderElement"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end
    end

    class 142512 "SofaLibrary"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief An Generic Library
 *
 *  It reads the content of the Object Factory and builds a library of components sorted inside categories.
 *  This Interface is used for the Modeler mainly. 
 *"
      class 142640 "VecCategory"
	visibility package stereotype "typedef" base_type class_ref 130608 // CategoryLibrary
	cpp_decl "${comment}typedef std::vector<${type}*> ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 138160 // <dependency>
	  relation 138160 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 138160 // <dependency>
	    b parent class_ref 130608 // CategoryLibrary
	end
      end

      class 142768 "VecCategoryIterator"
	visibility package stereotype "typedef" explicit_base_type "VecCategory::const_iterator"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 170288 "~SofaLibrary"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} {};
"
	
	
	
	
      end

      operation 170416 "build"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 1
	  param in name "examples" explicit_type "std::vector< std::string >"
	    defaultvalue "std::vector< std::string >()"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "//Automatically create and destroy all the components available: easy way to verify the default constructor and destructor
//#define TEST_CREATION_COMPONENT

${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 170544 "clear"
	preserve_cpp_body_indent cpp_virtual public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 170672 "getComponentDescription"
	preserve_cpp_body_indent const public explicit_return_type "std::string"
	nparams 1
	  param in name "componentName" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 170800 "getCategories"
	const cpp_inline public return_type class_ref 142640 // VecCategory
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} & ${name}${(}${)}${const}${volatile}${throw}${abstract} {return categories;};
"
	
	
	
	
      end

      operation 170928 "getCategory"
	preserve_cpp_body_indent const public return_type class_ref 130608 // CategoryLibrary
	nparams 1
	  param in name "categoryName" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}const ${type} * ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 171056 "getComponent"
	preserve_cpp_body_indent const public return_type class_ref 130736 // ComponentLibrary
	nparams 1
	  param in name "componentName" explicit_type "std::string"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}const ${type} * ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}const ${type} * ${class}::${name}${(}const ${t0} & ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 171184 "getNumComponents"
	const cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {return numComponents;};
"
	
	
	
	
      end

      operation 171312 "createCategory"
	cpp_virtual cpp_inline protected return_type class_ref 130608 // CategoryLibrary
	nparams 2
	  param in name "category" explicit_type "std::string"
	  param in name "" explicit_type "uint"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} * ${name}${(}const ${t0} & ${p0}${v0}, ${t1} ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {return new CategoryLibrary(category);};
"
	
	
	
	
      end

      operation 171440 "addCategory"
	preserve_cpp_body_indent cpp_virtual protected explicit_return_type "void"
	nparams 1
	  param inout name "category" type class_ref 130608 // CategoryLibrary
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${t0} * ${p0}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      operation 171568 "computeNumComponents"
	preserve_cpp_body_indent protected explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract};
"
	cpp_def "${comment}${inline}${type} ${class}::${name}${(}${)}${const}${volatile}${throw}${staticnl}{
  ${body}}
"
	
	
	
	
      end

      classrelation 138288 // categories (<directional composition>)
	relation 138288 *-->
	  a role_name "categories" protected
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 138288 // categories (<directional composition>)
	  b parent class_ref 142640 // VecCategory
      end

      attribute 136880 "exampleFiles"
	protected explicit_type " std::string "
	stereotype "std::vector"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${stereotype}<${type}> ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 137008 "numComponents"
	protected explicit_type "int"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 143920 "VecCoordId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_COORD, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 144048 "VecDerivId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_DERIV, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 144176 "MatrixDerivId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_MATDERIV, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 144304 "ConstMatrixDerivId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_MATDERIV, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 144432 "VecType"
      visibility package stereotype "enum"
      cpp_decl "${comment}enum ${name} {
${items}
};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Types of vectors that can be stored in State"
      attribute 137136 "V_ALL"
	public type class_ref 144432 // VecType
	init_value " 0"
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 137264 "V_COORD"
	public type class_ref 144432 // VecType
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 137392 "V_DERIV"
	public type class_ref 144432 // VecType
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 137520 "V_MATDERIV"
	public type class_ref 144432 // VecType
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 137648 "V_CONST"
	public type class_ref 144432 // VecType
	init_value " V_MATDERIV ///< @deprecated
"
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 144560 "VecAccess"
      visibility package stereotype "enum"
      cpp_decl "${comment}enum ${name} {
${items}
};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/< @deprecated
/ Types of vectors that can be stored in State"
      attribute 137776 "V_READ"
	public type class_ref 144560 // VecAccess
	init_value "0"
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      attribute 137904 "V_WRITE"
	public type class_ref 144560 // VecAccess
	cpp_decl "  ${name}${value},${comment}"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end
    end

    class 144688 "TStandardVec<V_COORD,vaccess>"
      visibility package 
      nformals 1
      formal name "VecAccess vaccess" type "" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 144816 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_COORD, vaccess>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 173360 "position"
	class_operation cpp_inline public return_type class_ref 144816 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(1);};
"
	
	
	
	
      end

      operation 173488 "restPosition"
	class_operation cpp_inline public return_type class_ref 144816 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(2);};
"
	
	
	
	
      end

      operation 173616 "freePosition"
	class_operation cpp_inline public return_type class_ref 144816 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(3);};
"
	
	
	
	
      end

      operation 173744 "resetPosition"
	class_operation cpp_inline public return_type class_ref 144816 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(4);};
"
	
	
	
	
      end

      class 144944 "anonymous1"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum  {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 138032 "V_FIRST_DYNAMIC_INDEX"
	  public type class_ref 144944 // anonymous1
	  init_value " 5 "
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 173872 "getName"
	class_operation cpp_inline public explicit_return_type "std::string"
	nparams 1
	  param in name "v" type class_ref 144816 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        std::string result;
        switch(v.getIndex())
        {
        case 0: result+= \"null\";
            break;
        case 1: result+= \"position\";
            break;
        case 2: result+= \"restPosition\";
            break;
        case 3: result+= \"freePosition\";
            break;
		case 4: result+= \"resetPosition\";
            break;
        default:
            std::ostringstream out;
            out << v.getIndex();
            result+= out.str();
            break;
        }
        result+= \"(V_COORD)\";
        return result;
    };
"
	
	
	
	
	comment "/< This is the first index used for dynamically allocated vectors"
      end
    end

    class 145072 "TStandardVec<V_DERIV,vaccess>"
      visibility package 
      nformals 1
      formal name "VecAccess vaccess" type "" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 145200 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_DERIV, vaccess>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 174000 "velocity"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(1);};
"
	
	
	
	
      end

      operation 174128 "resetVelocity"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(2);};
"
	
	
	
	
      end

      operation 174256 "freeVelocity"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(3);};
"
	
	
	
	
      end

      operation 174384 "normal"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(4);};
"
	
	
	
	
      end

      operation 174512 "force"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(5);};
"
	
	
	
	
      end

      operation 174640 "externalForce"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(6);};
"
	
	
	
	
      end

      operation 174768 "dx"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(7);};
"
	
	
	
	
      end

      operation 174896 "dforce"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(8);};
"
	
	
	
	
      end

      operation 175024 "accFromFrame"
	class_operation cpp_inline public return_type class_ref 145200 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(9);};
"
	
	
	
	
      end

      class 145328 "anonymous2"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum  {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 138160 "V_FIRST_DYNAMIC_INDEX"
	  public type class_ref 145328 // anonymous2
	  init_value " 10 "
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 175152 "getName"
	class_operation cpp_inline public explicit_return_type "std::string"
	nparams 1
	  param in name "v" type class_ref 145200 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        std::string result;
        switch(v.getIndex())
        {
        case 0: result+= \"null\";
            break;
        case 1: result+= \"velocity\";
            break;
        case 2: result+= \"resetVelocity\";
            break;
        case 3: result+= \"freeVelocity\";
            break;
        case 4: result+= \"normal\";
            break;
        case 5: result+= \"force\";
            break;
        case 6: result+= \"externalForce\";
            break;
        case 7: result+= \"dx\";
            break;
        case 8: result+= \"dforce\";
            break;
        case 9: result+= \"accFromFrame\";
            break;
        default:
            std::ostringstream out;
            out << v.getIndex();
            result+= out.str();
            break;
        }
        result+= \"(V_DERIV)\";
        return result;
    };
"
	
	
	
	
	comment "/< This is the first index used for dynamically allocated vectors"
      end
    end

    class 145456 "TStandardVec<V_MATDERIV,vaccess>"
      visibility package 
      nformals 1
      formal name "VecAccess vaccess" type "" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      class 145584 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_MATDERIV, vaccess>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 175280 "holonomicC"
	class_operation cpp_inline public return_type class_ref 145584 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(1);};
"
	
	
	
	
      end

      operation 175408 "nonHolonomicC"
	class_operation cpp_inline public return_type class_ref 145584 // MyVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return MyVecId(2);};
"
	
	
	
	
      end

      class 145712 "anonymous3"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum  {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 138288 "V_FIRST_DYNAMIC_INDEX"
	  public type class_ref 145712 // anonymous3
	  init_value " 3 "
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 175536 "getName"
	class_operation cpp_inline public explicit_return_type "std::string"
	nparams 1
	  param in name "v" type class_ref 145584 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        std::string result;
        switch(v.getIndex())
        {
        case 0: result+= \"null\";
            break;
        case 1: result+= \"holonomic\";
            break;
        case 2: result+= \"nonHolonomic\";
            break;
        default:
            std::ostringstream out;
            out << v.getIndex();
            result+= out.str();
            break;
        }
        result+= \"(V_MATDERIV)\";
        return result;
    };
"
	
	
	
	
	comment "/< This is the first index used for dynamically allocated vectors"
      end
    end

    class 145840 "TStandardVec<V_ALL,vaccess>"
      visibility package 
      nformals 1
      formal name "VecAccess vaccess" type "" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 138672 // <generalisation>
	relation 138672 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 138672 // <generalisation>
	  b parent class_ref 145968 // typedef2
      end

      classrelation 138800 // <generalisation>
	relation 138800 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 138800 // <generalisation>
	  b parent class_ref 146096 // typedef3
      end

      classrelation 138928 // <generalisation>
	relation 138928 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 138928 // <generalisation>
	  b parent class_ref 146224 // typedef4
      end

      class 146352 "MyVecId"
	visibility package stereotype "typedef" explicit_base_type "TVecId<V_ALL, vaccess>"
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
      end

      operation 175664 "getFirstDynamicIndex"
	class_operation cpp_inline public explicit_return_type "uint"
	nparams 1
	  param in name "t" type class_ref 144432 // VecType
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        switch(t)
        {
        case V_COORD:
            return TStandardVec<V_COORD,vaccess>::V_FIRST_DYNAMIC_INDEX;
        case V_DERIV:
            return TStandardVec<V_DERIV,vaccess>::V_FIRST_DYNAMIC_INDEX;
        case V_MATDERIV:
            return TStandardVec<V_MATDERIV,vaccess>::V_FIRST_DYNAMIC_INDEX;
        default:
            return 0;
        }
    };
"
	
	
	
	
      end

      operation 175792 "getName"
	class_operation cpp_inline public explicit_return_type "std::string"
	nparams 1
	  param in name "v" type class_ref 146352 // MyVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        switch(v.getType())
        {
        case V_COORD:
            return TStandardVec<V_COORD,vaccess>::getName((TVecId<V_COORD,vaccess>)v);
        case V_DERIV:
            return TStandardVec<V_DERIV,vaccess>::getName((TVecId<V_DERIV,vaccess>)v);
        case V_MATDERIV:
            return TStandardVec<V_MATDERIV,vaccess>::getName((TVecId<V_MATDERIV,vaccess>)v);
        default:
            std::string result;
            std::ostringstream out;
            out << v.getIndex() << \"(\" << v.getType() << \")\";
            result = out.str();
            return result;
        }
    };
"
	
	
	
	
      end
    end

    class 145968 "typedef2"
      visibility package stereotype "typedef" explicit_base_type "TStandardVec<V_COORD,vaccess>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 146096 "typedef3"
      visibility package stereotype "typedef" explicit_base_type "TStandardVec<V_DERIV,vaccess>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 146224 "typedef4"
      visibility package stereotype "typedef" explicit_base_type "TStandardVec<V_MATDERIV,vaccess>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 146480 "typedef5"
      visibility package stereotype "typedef" explicit_base_type "TStandardVec<vtype, vaccess>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 146608 "TVecId<V_ALL,vaccess>"
      visibility package 
      nformals 1
      formal name "VecAccess vaccess" type "" explicit_default_value ""
        explicit_extends ""
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Identify any vector stored in State"
      classrelation 139184 // <generalisation>
	relation 139184 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 139184 // <generalisation>
	  b parent class_ref 146736 // typedef6
      end

      class 146864 "Type"
	visibility package stereotype "typedef" base_type class_ref 144432 // VecType
	cpp_decl "${comment}typedef ${type} ${name};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	classrelation 139312 // <dependency>
	  relation 139312 -_->
	    a default
	      cpp default "#include in source"
	      classrelation_ref 139312 // <dependency>
	    b parent class_ref 144432 // VecType
	end
      end

      classrelation 139440 // type (<directional composition>)
	relation 139440 *-->
	  a role_name "type" public
	    cpp default "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	    classrelation_ref 139440 // type (<directional composition>)
	  b parent class_ref 144432 // VecType
      end

      attribute 138544 "index"
	public explicit_type "uint"
	cpp_decl "    ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};
"
	java_decl ""
	php_decl ""
	python_decl ""
	idl_decl ""
      end

      operation 177584 "TVecId"
	cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${name}${(}${)}${volatile}${throw} : type(V_ALL), index(0) { };
"
	
	
	
	
      end

      operation 177712 "TVecId"
	cpp_inline public explicit_return_type ""
	nparams 2
	  param in name "t" type class_ref 144432 // VecType
	  param in name "i" explicit_type "uint"
	cpp_decl "    ${comment}${inline}${name}${(}${t0} ${p0}${v0}, ${t1} ${p1}${v1}${)}${volatile}${throw} : type(t), index(i) { };
"
	
	
	
	
      end

      operation 177840 "TVecId"
	stereotype "template"
	cpp_inline public explicit_return_type ""
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype2, vaccess2>"
	cpp_decl "    ${comment}template< VecType vtype2template<  VecAccess vaccess2>
  ${inline}${name}${(}const ${t0} & ${p0}${v0}${)}${volatile}${throw} : type(v.getType()), index(v.getIndex())
    {
        BOOST_STATIC_ASSERT(vaccess2 >= vaccess);
    };
"
	
	
	
	
      end

      operation 177968 "getType"
	const cpp_inline public return_type class_ref 144432 // VecType
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return type; };
"
	
	
	
	
	comment "operator TVecId<V_ALL, V_READ>() const { return TVecId<V_ALL, V_READ>(getType(), getIndex()); }"
      end

      operation 178096 "getIndex"
	const cpp_inline public explicit_return_type "uint"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return index; };
"
	
	
	
	
      end

      operation 178224 "operator =="
	stereotype "template"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype2, vaccess2>"
	cpp_decl "    ${comment}template< VecType vtype2template<  VecAccess vaccess2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return getType() == v.getType() && getIndex() == v.getIndex();
    };
"
	
	
	
	
      end

      operation 178352 "operator !="
	stereotype "template"
	const cpp_inline public explicit_return_type "bool"
	nparams 1
	  param in name "v" explicit_type "TVecId<vtype2, vaccess2>"
	cpp_decl "    ${comment}template< VecType vtype2template<  VecAccess vaccess2>
  ${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} & ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
        return getType() != v.getType() || getIndex() != v.getIndex();
    };
"
	
	
	
	
      end

      operation 178480 "null"
	class_operation cpp_inline public return_type class_ref 139568 // TVecId
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return TVecId(V_ALL, 0);};
"
	
	
	
	
      end

      operation 178608 "isNull"
	const cpp_inline public explicit_return_type "bool"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { return this->index == 0; };
"
	
	
	
	
      end

      operation 178736 "getName"
	const cpp_inline public explicit_return_type "std::string"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        return TStandardVec<V_ALL, vaccess>::getName(*this);
    };
"
	
	
	
	
      end

      operation 178864 "operator <<"
	friend cpp_inline public explicit_return_type "std::ostream"
	nparams 2
	  param inout name "out" explicit_type "std::ostream"
	  param in name "v" type class_ref 139568 // TVecId
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} & ${name}${(}${t0} & ${p0}${v0}, const ${t1} & ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        out << v.getName();
        return out;
    };
"
	
	
	
	
      end
    end

    class 146736 "typedef6"
      visibility package stereotype "typedef" explicit_base_type "TStandardVec<V_ALL, vaccess>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
    end

    class 146992 "ConstVecId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_ALL, V_READ>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Identify one vector stored in State
/ A ConstVecId only provides a read-only access to the underlying vector."
    end

    class 147120 "VecId"
      visibility package stereotype "typedef" explicit_base_type "TVecId<V_ALL, V_WRITE>"
      cpp_decl "${comment}typedef ${type} ${name};
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "/ Identify one vector stored in State
/ A VecId only provides a read-write access to the underlying vector.
/ It derives from ConstVecId so that it can be used in all methods requiring read access"
    end

    class 147248 "VisualManager"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      classrelation 139568 // <generalisation>
	relation 139568 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 139568 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 139696 // <generalisation>
	relation 139696 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 139696 // <generalisation>
	  b parent class_ref 147376 // VisualModel
      end

      operation 178992 "~VisualManager"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 179120 "preDrawScene"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param inout name "" explicit_type "helper::gl::VisualParameters"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief Called before rendering the scene"
      end

      operation 179248 "postDrawScene"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param inout name "" explicit_type "helper::gl::VisualParameters"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief Called after rendering the scene"
      end

      operation 179376 "drawScene"
	cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 1
	  param inout name "" explicit_type "helper::gl::VisualParameters"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}${)}${const}${volatile}${throw}${abstract} { return false; };
"
	
	
	
	
	comment "*
     *  \\brief Called instead of rendering the scene
     *
     *  Return true if this object actually did the rendering, or false if it wasn't done."
      end
    end

    class 147376 "VisualModel"
      visibility package 
      cpp_decl "${comment}${template}class ${name}${inherit} {
${members}};
${inlines}
"
      java_decl ""
      php_decl ""
      python_2_2 python_decl ""
      idl_decl ""
      explicit_switch_type ""
      
      comment "*
 *  \\brief An interface which all VisualModel inherit.
 *
 *  This Interface is used for the VisualModel, which all visible objects must
 *  implement.
 *
 *  VisualModels are drawn by calling their draw method. The method update is
 *  used to recompute some internal data (such as normals) after the simulation
 *  has computed a new timestep.
 *
 *  Most VisualModel are bound by a Mapping to a BehaviorModel or
 *  MechanicalState."
      classrelation 139824 // <generalisation>
	relation 139824 ---|>
	  a public
	    cpp default "${type}"
	    classrelation_ref 139824 // <generalisation>
	  b parent class_ref 128176 // typedef1
      end

      classrelation 139952 // <generalisation>
	relation 139952 ---|>
	  a private
	    cpp default "${type}"
	    classrelation_ref 139952 // <generalisation>
	  b parent class_ref 128304 // BaseObject
      end

      operation 179504 "~VisualModel"
	cpp_virtual cpp_inline public explicit_return_type ""
	nparams 0
	cpp_decl "    ${comment}${inline}${virtual}${name}${(}${)}${volatile}${throw} { };
"
	
	
	
	
	comment "/ Destructor"
      end

      operation 179632 "initVisual"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { initTextures(); };
"
	
	
	
	
	comment "*
     *  \\brief Initialize the textures, or other graphical resources.
     *
     *  Called once before the first frame is drawn, and if the graphical
     *  context has been recreated."
      end

      operation 179760 "initTextures"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief Initialize the textures, or other graphical resources.
     *
     *  @deprecated Use initVisual() instead."
      end

      class 147504 "Pass"
	visibility package stereotype "enum"
	cpp_decl "${comment}enum ${name} {
${items}
};
"
	java_decl ""
	php_decl ""
	python_2_2 python_decl ""
	idl_decl ""
	explicit_switch_type ""
	
	attribute 138672 "Std"
	  public type class_ref 147504 // Pass
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 138800 "Transparent"
	  public type class_ref 147504 // Pass
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end

	attribute 138928 "Shadow"
	  public type class_ref 147504 // Pass
	  cpp_decl "  ${name}${value},${comment}"
	  java_decl ""
	  php_decl ""
	  python_decl ""
	  idl_decl ""
	end
      end

      operation 179888 "fwdDraw"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" type class_ref 147504 // Pass
	    defaultvalue "Std"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief Called before objects in the current branch are displayed"
      end

      operation 180016 "bwdDraw"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" type class_ref 147504 // Pass
	    defaultvalue "Std"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief Called after objects in the current branch are displayed"
      end

      operation 180144 "drawVisual"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief Display the VisualModel object."
      end

      operation 180272 "drawTransparent"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
    };
"
	
	
	
	
	comment "virtual void drawVisual() = 0;
*
     *  \\brief Display transparent surfaces.
     *
     *  Transparent objects should use this method to get a correct display order."
      end

      operation 180400 "drawShadow"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {
        drawVisual();
    };
"
	
	
	
	
	comment "*
     *  \\brief Display shadow-casting surfaces.
     *
     *  This method default to calling draw(). Object that do not cast any
     *  shadows, or that use a different LOD for them should reimplement it."
      end

      operation 180528 "updateVisual"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { update(); };
"
	
	
	
	
	comment "*
     *  \\brief used to update the model if necessary."
      end

      operation 180656 "parallelUpdateVisual"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} { };
"
	
	
	
	
	comment "*
     *  \\brief used to update the model if necessary."
      end

      operation 180784 "update"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 0
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${)}${const}${volatile}${throw}${abstract} {};
"
	
	
	
	
	comment "*
     *  \\brief used to update the model if necessary.
     *
     *  @deprecated Use updateVisual() instead."
      end

      operation 180912 "addBBox"
	cpp_virtual cpp_inline public explicit_return_type "bool"
	nparams 2
	  param inout name "" explicit_type "double"
	  param inout name "" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} * ${p0}${v0}, ${t1} * ${p1}${v1}${)}${const}${volatile}${throw}${abstract} {
        return false;
    };
"
	
	
	
	
	comment "*
     *  \\brief used to add the bounding-box of this visual model to the
     *  given bounding box in order to compute the scene bounding box or
     *  cull hidden objects.
     *
     *  \\return false if the visual model does not define any bounding box,
     *  which should only be the case for \"debug\" objects, as this lack of
     *  information might affect performances and leads to incorrect scene
     *  bounding box."
      end

      operation 181040 "applyTranslation"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 3
	  param in name "" explicit_type "double"
	  param in name "" explicit_type "double"
	  param in name "" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}, const ${t1} ${p1}${v1}, const ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract} {
    };
"
	
	
	
	
	comment "/ Translate the positions
/
/ This method is optional, it is used when the user want to interactively change the position of an object"
      end

      operation 181168 "applyRotation"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 3
	  param in name "" explicit_type "double"
	  param in name "" explicit_type "double"
	  param in name "" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}, const ${t1} ${p1}${v1}, const ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract} {
    };
"
	
	
	
	
	comment "/ Rotate the positions using Euler Angles in degree
/
/ This method is optional, it is used when the user want to interactively change the position of an object"
      end

      operation 181296 "applyRotation"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 1
	  param in name "" explicit_type "defaulttype::Quat"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}${)}${const}${volatile}${throw}${abstract} {
    };
"
	
	
	
	
	comment "/ Rotate the positions
/
/ This method is optional, it is used when the user want to interactively change the position of an object"
      end

      operation 181424 "applyScale"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 3
	  param in name "" explicit_type "double"
	  param in name "" explicit_type "double"
	  param in name "" explicit_type "double"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}const ${t0} ${p0}${v0}, const ${t1} ${p1}${v1}, const ${t2} ${p2}${v2}${)}${const}${volatile}${throw}${abstract} {
    };
"
	
	
	
	
	comment "/ Scale the positions
/
/ This method is optional, it is used when the user want to interactively change the position of an object"
      end

      operation 181552 "exportOBJ"
	cpp_virtual cpp_inline public explicit_return_type "void"
	nparams 6
	  param in name "" explicit_type "std::string"
	  param inout name "" explicit_type "std::ostream"
	  param inout name "" explicit_type "std::ostream"
	  param inout name "" explicit_type "int"
	  param inout name "" explicit_type "int"
	  param inout name "" explicit_type "int"
	cpp_decl "    ${comment}${friend}${static}${inline}${virtual}${type} ${name}${(}${t0} ${p0}${v0}, ${t1} * ${p1}${v1}, ${t2} * ${p2}${v2}, ${t3} & ${p3}${v3}, ${t4} & ${p4}${v4}, ${t5} & ${p5}${v5}${)}${const}${volatile}${throw}${abstract} {
    };
"
	
	
	
	
	comment "*
     *  \\brief Append this mesh to an OBJ format stream.
     *
     *  The number of vertices position, normal, and texture coordinates already written is given as parameters.
     *  This method should update them."
      end
    end
  end

  deploymentview 128048 "core"
    //deployment diagram settings
    package_name_in_tab default show_context default write_horizontally default auto_label_position default draw_all_relations default shadow default
    draw_component_as_icon default show_component_req_prov default show_component_rea default show_stereotype_properties default
    artifact 128048 "BaseMapping"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 128176 // typedef1
	class_ref 128048 // BaseMapping
      end
    end

    artifact 128176 "BaseState"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 129456 // BaseState
      end
    end

    artifact 128304 "BehaviorModel"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 129584 // BehaviorModel
      end
    end

    artifact 128432 "CallContext"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 129712 // Processor
	class_ref 129968 // CallContext
      end
    end

    artifact 128560 "CategoryLibrary"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 130480 // Creator
	class_ref 130608 // CategoryLibrary
      end
    end

    artifact 128688 "CollisionElement"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 131248 // BaseCollisionElementIterator
	class_ref 131504 // TCollisionElementIterator
	class_ref 131888 // CollisionElementIterator
      end
    end

    artifact 128816 "CollisionModel"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 132016 // CollisionModel
      end
    end

    artifact 128944 "ComponentLibrary"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 131120 // ClassEntry
	class_ref 130736 // ComponentLibrary
      end
    end

    artifact 129072 "ConstraintParams"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 129328 // ConstraintParams
      end
    end

    artifact 129200 "DataEngine"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 133424 // DataEngine
      end
    end

    artifact 129328 "DevBaseMonitor"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 133680 // DevBaseMonitor
      end
    end

    artifact 129456 "ExecParams"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 132912 // ExecParams
      end
    end

    artifact 129584 "Mapping"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 133936 // Mapping
      end
    end

    artifact 129712 "MechanicalParams"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 128688 // MechanicalParams
      end
    end

    artifact 129840 "MultiVecId"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 136112 // StateVecAccessor<DataTypes,V_COORD,V_READ>
	class_ref 136496 // StateVecAccessor<DataTypes,V_COORD,V_WRITE>
	class_ref 136880 // StateVecAccessor<DataTypes,V_DERIV,V_READ>
	class_ref 137264 // StateVecAccessor<DataTypes,V_DERIV,V_WRITE>
	class_ref 137648 // StateVecAccessor<DataTypes,V_MATDERIV,V_READ>
	class_ref 138032 // StateVecAccessor<DataTypes,V_MATDERIV,V_WRITE>
	class_ref 138416 // StateVecAccessor<DataTypes,V_ALL,V_READ>
	class_ref 138672 // StateVecAccessor<DataTypes,V_ALL,V_WRITE>
	class_ref 138928 // TMultiVecId
	class_ref 139696 // TMultiVecId<V_ALL,vaccess>
	class_ref 128560 // ConstMultiVecCoordId
	class_ref 128432 // MultiVecCoordId
	class_ref 128944 // ConstMultiVecDerivId
	class_ref 128816 // MultiVecDerivId
	class_ref 129200 // ConstMultiMatrixDerivId
	class_ref 129072 // MultiMatrixDerivId
	class_ref 140336 // ConstMultiVecId
	class_ref 140464 // MultiVecId
      end
    end

    artifact 129968 "ObjectFactory"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 130224 // ObjectFactory
	class_ref 141488 // ObjectCreator
	class_ref 141616 // RegisterObject
      end
    end

    artifact 130096 "ParallelCollisionModel"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 141744 // ParallelCollisionModel
	class_ref 142128 // ParallelComputeBoundingTree
      end
    end

    artifact 130224 "Shader"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 142256 // Shader
	class_ref 142384 // ShaderElement
      end
    end

    artifact 130352 "SofaLibrary"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 142512 // SofaLibrary
      end
    end

    artifact 130480 "State"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 135856 // State
      end
    end

    artifact 130608 "VecId"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 144432 // VecType
	class_ref 144560 // VecAccess
	class_ref 144688 // TStandardVec<V_COORD,vaccess>
	class_ref 145072 // TStandardVec<V_DERIV,vaccess>
	class_ref 145456 // TStandardVec<V_MATDERIV,vaccess>
	class_ref 145968 // typedef2
	class_ref 146096 // typedef3
	class_ref 146224 // typedef4
	class_ref 145840 // TStandardVec<V_ALL,vaccess>
	class_ref 146480 // typedef5
	class_ref 139568 // TVecId
	class_ref 146736 // typedef6
	class_ref 146608 // TVecId<V_ALL,vaccess>
	class_ref 146992 // ConstVecId
	class_ref 147120 // VecId
	class_ref 133168 // ConstVecCoordId
	class_ref 143920 // VecCoordId
	class_ref 133296 // ConstVecDerivId
	class_ref 144048 // VecDerivId
	class_ref 144304 // ConstMatrixDerivId
	class_ref 144176 // MatrixDerivId
      end
    end

    artifact 130736 "VisualManager"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 147248 // VisualManager
      end
    end

    artifact 130864 "VisualModel"
      stereotype "source"
      cpp_h "#ifndef ${NAMESPACE}_${NAME}_H
#define ${NAMESPACE}_${NAME}_H

${comment}
${includes}
${declarations}
${namespace_start}
${definition}
${namespace_end}
#endif
"
      cpp_src "${comment}
${includes}
${namespace_start}
${members}
${namespace_end}"
      associated_classes
	class_ref 147376 // VisualModel
      end
    end
  end

  package_ref 128176 // objectmodel

  package_ref 128304 // topology

  package_ref 128432 // behavior

  package_ref 128560 // collision

  package_ref 128688 // loader
end
