gzXYZ.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzXYZ.h
// Module       : gzXYZ
// Description  : Class definition of XYZ templates
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  020322  Created file 
//
// ******************************************************************************

#ifndef __GZ_XYZ_H__
#define __GZ_XYZ_H__

#include "gzBasicTypes.h"

//******************************************************************************
// Class    : gzXY
//                                  
// Purpose  : Returns (x,y) pair of T
//                                  
// Notes    : 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  020322  Created 
//                                  
//******************************************************************************
template <class T> class gzXY 
{
public:

    gzXY(T _x=0,T _y=0):x(_x),y(_y)     {};

    gzXY <T> operator *(const T &right)         { return gzXY<T>(x*right,y*right); }

    gzXY <T> operator /(const T &right)         { return gzXY<T>(x/right,y/right); }

    gzXY <T> operator +(const gzXY<T> &right)   { return gzXY<T>(x+right.x,y+right.y); }

    gzXY <T> operator -(const gzXY<T> &right)   { return gzXY<T>(x-right.x,y-right.y); }

    gzBool operator==(const gzXY<T> &right)     { return (x==right.x)&&(y==right.y); }

    gzBool operator!=(const gzXY<T> &right)     { return (x!=right.x)||(y!=right.y); }

    // Public values

    T x,y;
};

// Some common pairs

typedef gzXY<gzULong>   gzULongXY;
typedef gzXY<gzLong>    gzLongXY;
typedef gzXY<gzFloat>   gzFloatXY;
typedef gzXY<gzDouble>  gzDoubleXY;
typedef gzXY<gzReal>    gzRealXY;
typedef gzXY<gzShort>   gzShortXY;

//******************************************************************************
// Class    : gzXYZ
//                                  
// Purpose  : Returns (x,y,z) pair of T
//                                  
// Notes    : 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  020322  Created 
//                                  
//******************************************************************************
template <class T> class gzXYZ 
{
public:

    gzXYZ(T _x=0,T _y=0,T _z=0):x(_x),y(_y),z(_z)       {};

    gzXYZ <T> operator *(const T &right)            { return gzXYZ<T>(x*right,y*right,z*right); }

    gzXYZ <T> operator /(const T &right)            { return gzXYZ<T>(x/right,y/right,z/right); }

    gzXYZ <T> operator +(const gzXYZ<T> &right)     { return gzXYZ<T>(x+right.x,y+right.y,z+right.z); }

    gzXYZ <T> operator -(const gzXYZ<T> &right)     { return gzXYZ<T>(x-right.x,y-right.y,z-right.z); }

    gzBool operator==(const gzXYZ<T> &right)        { return (x==right.x) && (y==right.y) && (z==right.z); }

    gzBool operator!=(const gzXYZ<T> &right)        { return (x!=right.x) || (y!=right.y) || (z!=right.z); }

    // Public values

    T x,y,z;
};


// Some common pairs

typedef gzXYZ<gzULong>  gzULongXYZ;
typedef gzXYZ<gzLong>   gzLongXYZ;
typedef gzXYZ<gzFloat>  gzFloatXYZ;
typedef gzXYZ<gzDouble> gzDoubleXYZ;
typedef gzXYZ<gzReal>   gzRealXYZ;
typedef gzXYZ<gzShort>  gzShortXYZ;



#endif // __GZ_XYZ_H__

---