Real3x3Proxy.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Real3x3Proxy.h                                              (C) 2000-2008 */
/*                                                                           */
/* Proxy d'un 'Real3x3'.                                                     */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_REAL3X3PROXY_H
#define ARCANE_UTILS_REAL3X3PROXY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Real3x3.h"
#include "arcane/utils/Real3Proxy.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_UTILS_EXPORT Real3x3Proxy
{
 public:
 
  Real3x3Proxy(Real3x3& value,const MemoryAccessInfo& info)
  : x(value.x,info), y(value.y,info), z(value.z,info), m_value(value), m_info(info) {}
  Real3x3Proxy(const Real3x3Proxy& f)
  : x(f.x), y(f.y), z(f.z), m_value(f.m_value), m_info(f.m_info) {}
  const Real3x3& operator=(const Real3x3Proxy f)
    { x=f.x; y=f.y; z=f.z; return m_value; }
  const Real3x3& operator=(Real3x3 f)
    { x=f.x; y=f.y; z=f.z; return m_value; }
  const Real3x3& operator= (Real v)
    { x = y = z = v; return m_value; }
  operator const Real3x3&() const
    {
      return getValue();
    }
  //operator Real3x3()
  //{
  //  return getValueMutable();
  //}
 
 public:
 
  Real3Proxy x; 
  Real3Proxy y; 
  Real3Proxy z; 
 
 private:
 
  Real3x3& m_value;
  MemoryAccessInfo m_info;
 
 public:
 
  Real3x3 copy() const  { return m_value; }
  Real3x3Proxy& reset() { x.reset(); y.reset(); z.reset(); return (*this); }
  Real3x3Proxy& assign(Real3 ax,Real3 ay,Real3 az)
    { x = ax; y = ay; z = az; return (*this); }
  Real3x3Proxy& assign(Real3x3 f)
    { x = f.x; y = f.y; z = f.z; return (*this); }
  bool isNearlyZero() const
    { return x.isNearlyZero() && y.isNearlyZero() && z.isNearlyZero(); }
  std::istream& assign(std::istream& i);
  std::ostream& print(std::ostream& o) const;
  std::ostream& printXyz(std::ostream& o) const;
 
  Real3x3Proxy& add(Real3x3 b) { x += b.x; y += b.y; z += b.z; return (*this); }
  Real3x3Proxy& sub(Real3x3 b) { x -= b.x; y -= b.y; z -= b.z; return (*this); }
  Real3x3Proxy& addSame(Real3 b) { x += b; y += b; z += b; return (*this); }
  Real3x3Proxy& subSame(Real3 b) { x -= b; y -= b; z -= b; return (*this); }
  Real3x3Proxy& mulSame(Real3 b) { x *= b; y *= b; z *= b; return (*this); }
  Real3x3Proxy& divSame(Real3 b) { x /= b; y /= b; z /= b; return (*this); }
  Real3x3Proxy& operator+= (Real3x3 b) { return add(b); }
  Real3x3Proxy& operator-= (Real3x3 b) { return sub(b); }
  void operator*= (Real b)  { x *= b; y *= b; z *= b; }
  void operator/= (Real  b) { x /= b; y /= b; z /= b; }
  Real3x3 operator+(Real3x3 b)  const { return Real3x3(x+b.x,y+b.y,z+b.z); }
  Real3x3 operator-(Real3x3 b)  const { return Real3x3(x-b.x,y-b.y,z-b.z); }
  Real3x3 operator-() const { return Real3x3(-x,-y,-z); }
 
 public:
  const Real3x3& getValue() const
    {
      m_info.setRead();
      return m_value;
    }
  Real3x3& getValueMutable()
    {
      m_info.setReadOrWrite();
      return m_value;
    }
 private:
 
  static bool _eq(Real a,Real b)
    { return TypeEqualT<Real>::isEqual(a,b); }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline std::ostream&
operator<< (std::ostream& o,Real3x3Proxy t)
{
  return t.printXyz(o);
}
inline std::istream&
operator>> (std::istream& i,Real3x3Proxy& t)
{
  return t.assign(i);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline bool
operator==(const Real3x3& a,const Real3x3Proxy& b)
{
  return a==b.getValue();
}
inline bool
operator==(const Real3x3Proxy& a,const Real3x3& b)
{
  return a.getValue()==b;
}
inline bool
operator==(const Real3x3Proxy& a,const Real3x3Proxy& b)
{
  return a.getValue()==b.getValue();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline bool
operator!=(const Real3x3& a,const Real3x3Proxy& b)
{
  return a!=b.getValue();
}
inline bool
operator!=(const Real3x3Proxy& a,const Real3x3& b)
{
  return a.getValue()!=b;
}
inline bool
operator!=(const Real3x3Proxy& a,const Real3x3Proxy& b)
{
  return a.getValue()!=b.getValue();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline Real3x3
operator*(Real sca,Real3x3Proxy vec)
{
  return Real3x3(vec.x*sca,vec.y*sca,vec.z*sca);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline Real3x3
operator*(const Real3x3Proxy& vec,Real sca)
{
  return Real3x3(vec.x*sca,vec.y*sca,vec.z*sca);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline Real3x3
operator/(const Real3x3Proxy& vec,Real sca)
{
  return Real3x3(vec.x/sca,vec.y/sca,vec.z/sca);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline bool
operator<(Real3x3Proxy v1,Real3x3Proxy v2)
{
  if (v1.x==v2.x){
    if (v1.y==v2.y)
      return v1.z<v2.z;
    else
      return v1.y<v2.y;
  }
  return (v1.x<v2.x);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif