SVF::PointsTo::PointsToIterator Class Reference

#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. More...
	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. More...
const PointsToIterator	operator++ (int)
	Post-increment: it++. More...
u32_t	operator* () const
	Dereference: *it. More...
bool	operator== (const PointsToIterator &rhs) const
	Equality: *this == rhs. More...
bool	operator!= (const PointsToIterator &rhs) const
	Inequality: *this != rhs. More...

Private Member Functions
bool	atEnd () const

Private Attributes
const PointsTo *	pt
	PointsTo we are iterating over. More...
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*

(

void

)

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++

(

void

)

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 { ... }

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

private

PointsTo we are iterating over.

Definition at line 222 of file PointsTo.h.

sbvIt

SparseBitVector ::iterator SVF::PointsTo::PointsToIterator::sbvIt

Definition at line 227 of file PointsTo.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/MemoryModel/PointsTo.h
• /home/runner/work/SVF/SVF/svf/lib/MemoryModel/PointsTo.cpp