wmvariable.h

Go to the documentation of this file.

#ifndef wmvariable_h
#define wmvariable_h
 
// Wx includes
#include "lib/wxobject.h"
#include "lib/wxany.h"
 
// Wm includes
#include "lib/wmnametree.h"
#include "lib/wmopaqueptr.h"
#include "wmsimplearrays.h"
#include "array/array.h"
 
// STL includes
#include <typeinfo>
#include <utility>
 
// forward declarations
class WmSolverBase;
 
class WmVariable : public WxObject
{
public:
    virtual ~WmVariable();
 
    virtual void setup(const WxCryptSet& wxc);
 
    virtual void copy(const WmVariable& var);
 
    virtual void fill(const std::vector<WxAny>& fillValues)
    {
    }
 
    virtual void swap(WmVariable& otherVar);
 
    virtual bool checkCompatible(const WmVariable& var) const;
 
    virtual void dump(WxIoBase& io, WxIoNodeType& grpNode) const;
 
    virtual void load(WxIoBase& io, const WxIoNodeType& grpNode);
 
    bool hasComponent(const std::string& componentName) const;
 
    virtual const std::type_info& getElementTypeForComponent(unsigned int index) const;
 
    virtual const std::type_info& getElementType() const;
 
    unsigned int getNumComponents() const;
 
    typedef unsigned variableComponent_t;
 
    std::vector<std::string> getComponentNames() const;
 
    variableComponent_t getIndexForComponent(const std::string& componentName) const;
 
    const std::string& getComponentName(const variableComponent_t index) const;
 
    virtual const WxAny min(const int componentIndex) const
    {
        return WxAny();
    }
 
    virtual const WxAny absoluteMin(const int componentIndex) const
    {
        return WxAny();
    }
 
    //    /**
    //     * Returns a list of subdomain names on which the variable exists
    //     *
    //     * @return vector of subdomain names
    //     */
    //    virtual std::vector<std::string> getSubdomainNames() const {return
    //    std::vector<std::string>();}
 
    const WmSolverBase& getParent() const;
 
protected:
    WmVariable(const WmConstOpaquePtr& parent_solver);
 
    WmVariable(const std::string& name,
               const std::vector<std::string>& orderedComponentNames);
 
    const std::type_info& getRealTypeID() const;
 
    std::string getRealTypeStr() const;
 
    typedef WmNameTree<variableComponent_t>::const_iterator component_const_iterator_t;
 
    WmNameTree<variableComponent_t> _componentTree;
    unsigned _numComponents;
 
    std::vector<std::string> _orderedComponentNames;
 
    struct SwapImpl
    {
        virtual void swap_impl(WmVariable& varA, WmVariable& varB) const;
        virtual bool checkCompatible_impl(const WmVariable& varA,
                                          const WmVariable& varB) const;
        virtual ~SwapImpl() = default;
    };
 
    SwapImpl* p_impl;
 
private:
    WmVariable& operator=(const WmVariable& var);
    WmVariable(const WmVariable& var);
 
    const WmSolverBase* _p_parent;
    bool _hasBeenSetup;
};
 
class WmDistributedVariable : public virtual WmVariable
{
 
public:
    virtual void setup(const WxCryptSet& wxc);
 
    virtual void updateGhosts()
    {
    }
 
    virtual void updateGhosts_register(const int key)
    {
    }
 
    virtual void updateGhosts_nb(const int key)
    {
    }
 
    virtual void updateGhosts_wait(const int key)
    {
    }
 
    const std::vector<std::string>& subdomain_names() const
    {
        return _subdomain_names;
    }
 
    bool on_subdomain(const std::string& subdomain_name) const;
 
    virtual wxm::array::patch_array_t& patch_array(const int component_index,
                                                   const int patch_index) = 0;
 
    virtual const wxm::array::patch_array_t& patch_array(const int component_index,
                                                         const int patch_index) const = 0;
 
protected:
    std::vector<std::string> _subdomain_names;
 
    std::vector<std::string> _virtual_names;
 
    WmDistributedVariable(const WmConstOpaquePtr& parent_solver);
 
    //  /**
    //   * Constructor sets up basic distributed variable container, and all properties
    // otherwise set through setup() method in the no-argument form.
    //   * Calls to setup() for this instance will have no affect.
    //   * Protected because direct WmDistributedVariable is not intended to be a complete
    // type.
    //   * @param name name of this instance
    //   * @param orderedComponentNames name for each component of the variable
    //   */
    //  WmDistributedVariable(const std::string & name, const std::vector<std::string> &
    // orderedComponentNames );
 
private:
    WmDistributedVariable();
 
    WmDistributedVariable(const WmDistributedVariable& other);
 
    WmDistributedVariable& operator=(const WmDistributedVariable& other);
};
 
// namespace wxm
//{
// namespace variable
//{
//    typedef WmVariable variable_t;
//    typedef WmDistributedVariable distributed_variable_t;
//}
//}
 
#endif //  wmvariable_h