#include <PointsTo.h>

Public Types
using	iterator_category = std::forward_iterator_tag

using	value_type = u32_t

using	difference_type = std::ptrdiff_t

using	pointer = u32_t *

using	reference = u32_t &

Public Member Functions
	PointsToIterator ()=delete
	Deleted because we don't want iterators with null pt.

	PointsToIterator (const PointsToIterator &pt)

	PointsToIterator (PointsToIterator &&pt) noexcept

	PointsToIterator (const PointsTo *pt, bool end=false)

PointsToIterator &	operator= (const PointsToIterator &rhs)

PointsToIterator &	operator= (PointsToIterator &&rhs) noexcept

const PointsToIterator &	operator++ ()
	Pre-increment: ++it.

const PointsToIterator	operator++ (int)
	Post-increment: it++.

u32_t	operator* () const
	Dereference: *it.

bool	operator== (const PointsToIterator &rhs) const
	Equality: *this == rhs.

bool	operator!= (const PointsToIterator &rhs) const
	Inequality: *this != rhs.

Private Member Functions
bool	atEnd () const

Private Attributes
const PointsTo *	pt
	PointsTo we are iterating over.

union {

SparseBitVector ::iterator sbvIt

CoreBitVector::iterator cbvIt

BitVector::iterator bvIt

};

Detailed Description

Definition at line 181 of file PointsTo.h.

Member Typedef Documentation

◆ difference_type

using SVF::PointsTo::PointsToIterator::difference_type = std::ptrdiff_t

Definition at line 186 of file PointsTo.h.

◆ iterator_category

using SVF::PointsTo::PointsToIterator::iterator_category = std::forward_iterator_tag

Definition at line 184 of file PointsTo.h.

◆ pointer

using SVF::PointsTo::PointsToIterator::pointer = u32_t *

Definition at line 187 of file PointsTo.h.

◆ reference

using SVF::PointsTo::PointsToIterator::reference = u32_t &

Definition at line 188 of file PointsTo.h.

◆ value_type

using SVF::PointsTo::PointsToIterator::value_type = u32_t

Definition at line 185 of file PointsTo.h.

Constructor & Destructor Documentation

◆ PointsToIterator() [1/4]

SVF::PointsTo::PointsToIterator::PointsToIterator ( )

delete

Deleted because we don't want iterators with null pt.

◆ PointsToIterator() [2/4]

SVF::PointsTo::PointsToIterator::PointsToIterator ( const PointsToIterator & pt )

Definition at line 411 of file PointsTo.cpp.

    : pt(pt.pt)
{
    if (this->pt->type == PointsTo::Type::SBV)
    {
        new (&sbvIt) SparseBitVector<>::iterator(pt.sbvIt);
    }
    else if (this->pt->type == PointsTo::Type::CBV)
    {
        new (&cbvIt) CoreBitVector::iterator(pt.cbvIt);
    }
    else if (this->pt->type == PointsTo::Type::BV)
    {
        new (&bvIt) BitVector::iterator(pt.bvIt);
    }
    else
    {
        assert(false && "PointsToIterator::PointsToIterator&: unknown type");
        abort();
    }
}

◆ PointsToIterator() [3/4]

SVF::PointsTo::PointsToIterator::PointsToIterator ( PointsToIterator && pt )

noexcept

Definition at line 433 of file PointsTo.cpp.

             : pt(pt.pt)
{
    if (this->pt->type == PointsTo::Type::SBV)
    {
        new (&sbvIt) SparseBitVector<>::iterator(std::move(pt.sbvIt));
    }
    else if (this->pt->type == PointsTo::Type::CBV)
    {
        new (&cbvIt) CoreBitVector::iterator(std::move(pt.cbvIt));
    }
    else if (this->pt->type == PointsTo::Type::BV)
    {
        new (&bvIt) BitVector::iterator(std::move(pt.bvIt));
    }
    else
    {
        assert(false && "PointsToIterator::PointsToIterator&&: unknown type");
        abort();
    }
}

◆ PointsToIterator() [4/4]

SVF::PointsTo::PointsToIterator::PointsToIterator	(	const PointsTo *	pt,
		bool	end = `false`
	)

explicit

Returns an iterator to the beginning of pt if end is false, and to the end of pt if end is true.

Definition at line 389 of file PointsTo.cpp.

    : pt(pt)
{
    if (pt->type == Type::CBV)
    {
        new (&cbvIt) CoreBitVector::iterator(end ? pt->cbv.end() : pt->cbv.begin());
    }
    else if (pt->type == Type::SBV)
    {
        new (&sbvIt) SparseBitVector<>::iterator(end ? pt->sbv.end() : pt->sbv.begin());
    }
    else if (pt->type == Type::BV)
    {
        new (&bvIt) BitVector::iterator(end ? pt->bv.end() : pt->bv.begin());
    }
    else
    {
        assert(false && "PointsToIterator::PointsToIterator: unknown type");
        abort();
    }
}

Member Function Documentation

◆ atEnd()

bool SVF::PointsTo::PointsToIterator::atEnd ( ) const

private

Definition at line 552 of file PointsTo.cpp.

{
    assert(pt != nullptr && "PointsToIterator::atEnd: iterator iterating over nothing!");
    if (pt->type == Type::CBV) return cbvIt == pt->cbv.end();
    else if (pt->type == Type::SBV) return sbvIt == pt->sbv.end();
    else if (pt->type == Type::BV) return bvIt == pt->bv.end();
    else
    {
        assert(false && "PointsToIterator::atEnd: unknown type");
        abort();
    }
}

◆ operator!=()

bool SVF::PointsTo::PointsToIterator::operator!= ( const PointsToIterator & rhs ) const

Inequality: *this != rhs.

Definition at line 545 of file PointsTo.cpp.

{
    assert(pt == rhs.pt
           && "PointsToIterator::!=: comparing iterators from different PointsTos!");
    return !(*this == rhs);
}

◆ operator*()

NodeID SVF::PointsTo::PointsToIterator::operator* ( ) const

Dereference: *it.

Definition at line 516 of file PointsTo.cpp.

{
    assert(!atEnd() && "PointsToIterator: dereferencing end!");
    if (pt->type == Type::CBV) return pt->getExternalNode(*cbvIt);
    else if (pt->type == Type::SBV) return pt->getExternalNode(*sbvIt);
    else if (pt->type == Type::BV) return pt->getExternalNode(*bvIt);
    else
    {
        assert(false && "PointsToIterator::*: unknown type");
        abort();
    }
}

◆ operator++() [1/2]

const PointsTo::PointsToIterator & SVF::PointsTo::PointsToIterator::operator++ ( )

Pre-increment: ++it.

Definition at line 497 of file PointsTo.cpp.

{
    assert(!atEnd() && "PointsToIterator::++(pre): incrementing past end!");
    if (pt->type == Type::CBV) ++cbvIt;
    else if (pt->type == Type::SBV) ++sbvIt;
    else if (pt->type == Type::BV) ++bvIt;
    else assert(false && "PointsToIterator::++(void): unknown type");
 
    return *this;
}

◆ operator++() [2/2]

const PointsTo::PointsToIterator SVF::PointsTo::PointsToIterator::operator++ ( int )

Post-increment: it++.

Definition at line 508 of file PointsTo.cpp.

{
    assert(!atEnd() && "PointsToIterator::++(pre): incrementing past end!");
    PointsToIterator old = *this;
    ++*this;
    return old;
}

◆ operator=() [1/2]

PointsTo::PointsToIterator & SVF::PointsTo::PointsToIterator::operator= ( const PointsToIterator & rhs )

Definition at line 455 of file PointsTo.cpp.

{
    this->pt = rhs.pt;
 
    if (this->pt->type == PointsTo::Type::SBV)
    {
        new (&sbvIt) SparseBitVector<>::iterator(rhs.sbvIt);
    }
    else if (this->pt->type == PointsTo::Type::CBV)
    {
        new (&cbvIt) CoreBitVector::iterator(rhs.cbvIt);
    }
    else if (this->pt->type == PointsTo::Type::BV)
    {
        new (&bvIt) BitVector::iterator(rhs.bvIt);
    }
    else assert(false && "PointsToIterator::PointsToIterator&: unknown type");
 
    return *this;
}

◆ operator=() [2/2]

PointsTo::PointsToIterator & SVF::PointsTo::PointsToIterator::operator= ( PointsToIterator && rhs )

noexcept

Definition at line 476 of file PointsTo.cpp.

{
    this->pt = rhs.pt;
 
    if (this->pt->type == PointsTo::Type::SBV)
    {
        new (&sbvIt) SparseBitVector<>::iterator(std::move(rhs.sbvIt));
    }
    else if (this->pt->type == PointsTo::Type::CBV)
    {
        new (&cbvIt) CoreBitVector::iterator(std::move(rhs.cbvIt));
    }
    else if (this->pt->type == PointsTo::Type::BV)
    {
        new (&bvIt) BitVector::iterator(std::move(rhs.bvIt));
    }
    else assert(false && "PointsToIterator::PointsToIterator&&: unknown type");
 
    return *this;
}

◆ operator==()

bool SVF::PointsTo::PointsToIterator::operator== ( const PointsToIterator & rhs ) const

Equality: *this == rhs.

Definition at line 529 of file PointsTo.cpp.

{
    assert(pt == rhs.pt
           && "PointsToIterator::==: comparing iterators from different PointsTos!");
 
    // Handles end implicitly.
    if (pt->type == Type::CBV) return cbvIt == rhs.cbvIt;
    else if (pt->type == Type::SBV) return sbvIt == rhs.sbvIt;
    else if (pt->type == Type::BV) return bvIt == rhs.bvIt;
    else
    {
        assert(false && "PointsToIterator::==: unknown type");
        abort();
    }
}

Member Data Documentation

◆ [union]

union { ... } SVF::PointsTo::PointsToIterator

Iterator into the backing data structure. Discriminated by pt->type. TODO: std::variant when we move to C++17.

◆ bvIt

BitVector::iterator SVF::PointsTo::PointsToIterator::bvIt

Definition at line 229 of file PointsTo.h.

◆ cbvIt

CoreBitVector::iterator SVF::PointsTo::PointsToIterator::cbvIt

Definition at line 228 of file PointsTo.h.

◆ pt

const PointsTo* SVF::PointsTo::PointsToIterator::pt