size2.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_GF_SIZE2_H
#define PXR_BASE_GF_SIZE2_H


#include "pxr/pxr.h"
#include "pxr/base/arch/inttypes.h"
#include "pxr/base/gf/vec2i.h"
#include "pxr/base/gf/api.h"

#include <iosfwd>

PXR_NAMESPACE_OPEN_SCOPE

class GfSize2 {
public:
    GfSize2() {
        Set(0, 0);
    }

    GfSize2(const GfSize2& o) {
        *this = o;
    }

    explicit GfSize2(const GfVec2i&o) {
        Set(o[0], o[1]);
    }

    GfSize2(const size_t v[2]) {
        Set(v);
    }

    GfSize2(size_t v0, size_t v1) {
        Set(v0, v1);
    }

    GfSize2 & Set(const size_t v[2]) {
        _vec[0] = v[0]; 
        _vec[1] = v[1]; 
        return *this;
    }

    GfSize2 & Set(size_t v0, size_t v1) {
        _vec[0] = v0; 
        _vec[1] = v1; 
        return *this;
    }

    size_t & operator [](size_t i) {
        return _vec[i];
    }

    const size_t & operator [](size_t i) const {
        return _vec[i];
    }

    bool operator ==(const GfSize2 &v) const {
        return _vec[0] == v._vec[0] && _vec[1] == v._vec[1];
    }

    bool operator !=(const GfSize2 &v) const {
        return ! (*this == v);
    }

    GfSize2 & operator +=(const GfSize2 &v) {
        _vec[0] += v._vec[0]; 
        _vec[1] += v._vec[1]; 
        return *this;
    }

    GfSize2 & operator -=(const GfSize2 &v) {
        _vec[0] -= v._vec[0]; 
        _vec[1] -= v._vec[1]; 
        return *this;
    }

    GfSize2 & operator *=(GfSize2 const &v) {
        _vec[0] *= v._vec[0];
        _vec[1] *= v._vec[1];
        return *this;
    }

    GfSize2 & operator *=(int d) {
        _vec[0] = _vec[0] * d;
        _vec[1] = _vec[1] * d;
        return *this;
    }

    GfSize2 & operator /=(int d) {
        _vec[0] = _vec[0] / d;
        _vec[1] = _vec[1] / d;
        return *this;
    }

    friend GfSize2 operator +(const GfSize2 &v1, const GfSize2 &v2) {
        return GfSize2(v1._vec[0]+v2._vec[0],
                       v1._vec[1]+v2._vec[1]);
    }

    friend GfSize2 operator -(const GfSize2 &v1, const GfSize2 &v2) {
        return GfSize2(v1._vec[0]-v2._vec[0],
                       v1._vec[1]-v2._vec[1]);
    }

    friend GfSize2 operator *(const GfSize2 &v1, const GfSize2 &v2) {
        return GfSize2(v1._vec[0]*v2._vec[0],
                       v1._vec[1]*v2._vec[1]);
    }

    friend GfSize2 operator *(const GfSize2 &v1, int s) {
        return GfSize2(v1._vec[0]*s,
                       v1._vec[1]*s);
    }

    friend GfSize2 operator *(int s, const GfSize2 &v1) {
        return GfSize2(v1._vec[0]*s,
                       v1._vec[1]*s);
    }

    friend GfSize2 operator /(const GfSize2 &v1, int s) {
        return GfSize2(v1._vec[0]/s,
                       v1._vec[1]/s);
    }

    GF_API
    friend std::ostream &operator<<(std::ostream &o, GfSize2 const &v);

    operator GfVec2i() const {
        return GfVec2i(_vec[0], _vec[1]);
    }
 private:
    size_t _vec[2];
};

// Friend functions must be declared
GF_API std::ostream &operator<<(std::ostream &o, GfSize2 const &v);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_GF_SIZE2_H