UTRegionHStripe.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTGeometry.h"
#include "UTPoolAllocator.h"


// \cond DOXYGEN_DOCUMENT_NEVER


//==================================================================================================
struct RegionHStripeRect_t
//==================================================================================================
{
    float left;
    float right;
};


//==================================================================================================
class RegionHStripe_t
//==================================================================================================
:   public BTreeNode_t< RegionHStripe_t, float >
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                            RegionHStripe_t( const Rect_t& rect, PoolAllocator_t* allocator );
                            RegionHStripe_t(    const RegionHStripe_t& copy_x,
                                                float top,
                                                float bottom,
                                                PoolAllocator_t* allocator );
    inline                  ~RegionHStripe_t();     // Should never be called.  Instead...
    inline void             Delete(PoolAllocator_t* allocator);

    inline void*            operator new( size_t size, PoolAllocator_t* allocator );
    inline void             operator delete( void* block, PoolAllocator_t* allocator );

    inline int              Compare(float other_top) const;
    inline                  operator float() const;

    bool                    Contains( float left, float right );
                                // Returns true if the stripe ENTIRELY contains from left to right
    bool                    Contains(float x);
                                // Returns true if the stripe contains the x value
    bool                    Overlapping( float left, float right );
                                // Returns true if the stripe PARTIALLY contains from left to right
    inline bool             Excludes( float left, float right );
                                // Returns true if the stripe DOES NOT contain ANY of the space from
                                // left to right
    bool                    Add( float left, float right, PoolAllocator_t* allocator );
                                // Returns true if anything was changed
    bool                    Remove( float left, float right, PoolAllocator_t* allocator );
                                // Returns true if anything was changed
    bool                    ConstrainSides( float left, float right );
                                // Returns true if anything was changed
    void                    Shift(const Point_t& offset);
    bool                    EqualInXDomain(const RegionHStripe_t& other);

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void                    MakeRoomToAddOne(PoolAllocator_t* allocator);

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    float                   m_top;
    float                   m_bottom;
    int                     m_base_index;
    int                     m_num_allocated_stripe_left_right_pairs;
    RegionHStripeRect_t*    m_rects_left_right_pairs;
    int                     m_num_valid_stripe_left_right_pairs;

    friend class Region_t;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class RegionHStripe_t
//===
//==================================================================================================
//==================================================================================================
inline void*
RegionHStripe_t::operator new( size_t size, PoolAllocator_t* allocator )
{
    return allocator->Allocate(size);
}


inline
RegionHStripe_t::~RegionHStripe_t()
{
    // GCC 4.3.2 supports the syntax for placement operator delete to be declared, but not for it
    // to be invoked.  Some cursory research shows that if placement operator delete was
    // standardized, that was fairly recent.

    // From: Bjarne Stroustrup's C++ Style and Technique FAQ
    // http://public.research.att.com/~bs/bs_faq2.html#placement-delete
    // Q: Is there a "placement delete"?
    // A: No but if you need one you can write your own.

    // Placement delete is defined for this class not to implement it, but to assure that Delete is
    // called instead.  The real destructor should never be invoked.
    rel_assert("This should never be called");
}


inline void
RegionHStripe_t::operator delete( void* block, PoolAllocator_t* allocator )
{
    // Placement delete is defined for this class not to implement it, but to assure that Release
    // is called instead.  See above.

    rel_assert("This should never be called");
}


inline void
RegionHStripe_t::Delete(PoolAllocator_t* allocator)
{
    if(m_rects_left_right_pairs)
        allocator->Release(m_rects_left_right_pairs);
    allocator->Release(this);
}


inline int
RegionHStripe_t::Compare(float other_top) const
{
    if(m_top < other_top)
        return -1;
    if(m_top > other_top)
        return 1;
    return 0;
}


inline
RegionHStripe_t::operator float() const
{
    return m_top;
}


inline bool
RegionHStripe_t::Excludes( float left, float right )
{
    return !Overlapping( left, right );
}


// \endcond