Revert "Octave: cleanup/restructure library files"
This reverts commit bf12d76d03.
Reverting a series of Octave commits for re-applying again without
incorrect whitespace changes.
This commit is contained in:
William S Fulton
parent
457ba43989
commit
23373e9ffd
42 changed files with 3698 additions and 4284 deletions
|
|
@ -1,345 +1,357 @@
|
|||
//
|
||||
// octiterators.swg - Octave STL iterator support
|
||||
//
|
||||
|
||||
// Users can derive form the OctIterator to implement their
|
||||
// own iterators. As an example (real one since we use it for STL/STD
|
||||
// containers), the template OctIterator_T does the
|
||||
// implementation for generic C++ iterators.
|
||||
/* -----------------------------------------------------------------------------
|
||||
* octiterators.swg
|
||||
*
|
||||
* Users can derive form the OctSwigIterator to implemet their
|
||||
* own iterators. As an example (real one since we use it for STL/STD
|
||||
* containers), the template OctSwigIterator_T does the
|
||||
* implementation for generic C++ iterators.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
%include <std_common.i>
|
||||
|
||||
%fragment("OctIterator", "header", fragment = "<stddef.h>")
|
||||
{
|
||||
%fragment("OctSwigIterator","header",fragment="<stddef.h>") {
|
||||
namespace swig {
|
||||
struct stop_iteration {
|
||||
};
|
||||
|
||||
namespace swig
|
||||
{
|
||||
struct OctSwigIterator {
|
||||
private:
|
||||
octave_value _seq;
|
||||
|
||||
struct OctStopIteration {
|
||||
};
|
||||
|
||||
struct OctIterator {
|
||||
|
||||
private:
|
||||
|
||||
octave_value _seq;
|
||||
|
||||
protected:
|
||||
|
||||
OctIterator(octave_value seq) : _seq(seq) {
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
virtual ~OctIterator() {}
|
||||
|
||||
virtual octave_value value() const = 0;
|
||||
|
||||
virtual OctIterator* incr(size_t n = 1) = 0;
|
||||
|
||||
virtual OctIterator* decr(size_t n = 1) {
|
||||
throw OctStopIteration();
|
||||
}
|
||||
|
||||
virtual ptrdiff_t distance(const OctIterator& x) const {
|
||||
throw std::invalid_argument("operation not supported");
|
||||
}
|
||||
|
||||
virtual bool equal(const OctIterator& x) const {
|
||||
throw std::invalid_argument("operation not supported");
|
||||
}
|
||||
|
||||
virtual OctIterator* copy() const = 0;
|
||||
|
||||
octave_value next() {
|
||||
octave_value obj = value();
|
||||
incr();
|
||||
return obj;
|
||||
}
|
||||
|
||||
octave_value previous() {
|
||||
decr();
|
||||
return value();
|
||||
}
|
||||
|
||||
OctIterator* advance(ptrdiff_t n) {
|
||||
return (n > 0) ? incr(n) : decr(-n);
|
||||
}
|
||||
|
||||
bool operator== (const OctIterator& x) const {
|
||||
return equal(x);
|
||||
}
|
||||
|
||||
bool operator!= (const OctIterator& x) const {
|
||||
return ! operator== (x);
|
||||
}
|
||||
|
||||
OctIterator* operator++ () {
|
||||
incr();
|
||||
return this;
|
||||
}
|
||||
|
||||
OctIterator* operator-- () {
|
||||
decr();
|
||||
return this;
|
||||
}
|
||||
|
||||
OctIterator* operator+ (ptrdiff_t n) const {
|
||||
return copy()->advance(n);
|
||||
}
|
||||
|
||||
OctIterator* operator- (ptrdiff_t n) const {
|
||||
return copy()->advance(-n);
|
||||
}
|
||||
|
||||
ptrdiff_t operator- (const OctIterator& x) const {
|
||||
return x.distance(*this);
|
||||
}
|
||||
|
||||
static swig_type_info* descriptor() {
|
||||
static int init = 0;
|
||||
static swig_type_info* desc = 0;
|
||||
if (!init) {
|
||||
desc = SWIG_TypeQuery("swig::OctIterator *");
|
||||
init = 1;
|
||||
}
|
||||
return desc;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
%fragment("OctIterator_T", "header", fragment = "<stddef.h>", fragment = "OctIterator", fragment = "StdTraits", fragment = "StdIteratorTraits")
|
||||
{
|
||||
|
||||
namespace swig
|
||||
{
|
||||
|
||||
template<typename OutIterator>
|
||||
class OctIterator_T : public OctIterator
|
||||
protected:
|
||||
OctSwigIterator(octave_value seq) : _seq(seq)
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
virtual ~OctSwigIterator() {}
|
||||
|
||||
public:
|
||||
virtual octave_value value() const = 0;
|
||||
|
||||
typedef OutIterator out_iterator;
|
||||
typedef typename std::iterator_traits<out_iterator>::value_type value_type;
|
||||
typedef OctIterator_T<out_iterator> self_type;
|
||||
virtual OctSwigIterator *incr(size_t n = 1) = 0;
|
||||
|
||||
OctIterator_T(out_iterator curr, octave_value seq)
|
||||
: OctIterator(seq), current(curr) {
|
||||
}
|
||||
|
||||
const out_iterator& get_current() const {
|
||||
return current;
|
||||
}
|
||||
|
||||
bool equal(const OctIterator& iter) const {
|
||||
const self_type* iters = dynamic_cast<const self_type*>(&iter);
|
||||
if (iters) {
|
||||
return (current == iters->get_current());
|
||||
} else {
|
||||
throw std::invalid_argument("bad iterator type");
|
||||
}
|
||||
}
|
||||
|
||||
ptrdiff_t distance(const OctIterator& iter) const {
|
||||
const self_type* iters = dynamic_cast<const self_type*>(&iter);
|
||||
if (iters) {
|
||||
return std::distance(current, iters->get_current());
|
||||
} else {
|
||||
throw std::invalid_argument("bad iterator type");
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
out_iterator current;
|
||||
|
||||
};
|
||||
|
||||
template <class ValueType>
|
||||
struct OctFromOper {
|
||||
typedef const ValueType& argument_type;
|
||||
typedef octave_value result_type;
|
||||
result_type operator()(argument_type v) const {
|
||||
return swig::from(v);
|
||||
}
|
||||
};
|
||||
|
||||
template < typename OutIterator, typename ValueType = typename std::iterator_traits<OutIterator>::value_type, typename FromOper = OctFromOper<ValueType> >
|
||||
class OctIteratorOpen_T : public OctIterator_T<OutIterator>
|
||||
virtual OctSwigIterator *decr(size_t n = 1)
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
FromOper from;
|
||||
typedef OutIterator out_iterator;
|
||||
typedef ValueType value_type;
|
||||
typedef OctIterator_T<out_iterator> base;
|
||||
typedef OctIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
|
||||
|
||||
OctIteratorOpen_T(out_iterator curr, octave_value seq)
|
||||
: OctIterator_T<OutIterator> (curr, seq) {
|
||||
}
|
||||
|
||||
octave_value value() const {
|
||||
return from(static_cast<const value_type&>(* (base::current)));
|
||||
}
|
||||
|
||||
OctIterator* copy() const {
|
||||
return new self_type(*this);
|
||||
}
|
||||
|
||||
OctIterator* incr(size_t n = 1) {
|
||||
while (n--) {
|
||||
++base::current;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
OctIterator* decr(size_t n = 1) {
|
||||
while (n--) {
|
||||
--base::current;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template < typename OutIterator, typename ValueType = typename std::iterator_traits<OutIterator>::value_type, typename FromOper = OctFromOper<ValueType> >
|
||||
class OctIteratorClosed_T : public OctIterator_T<OutIterator>
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
FromOper from;
|
||||
typedef OutIterator out_iterator;
|
||||
typedef ValueType value_type;
|
||||
typedef OctIterator_T<out_iterator> base;
|
||||
typedef OctIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
|
||||
|
||||
OctIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, octave_value seq)
|
||||
: OctIterator_T<OutIterator> (curr, seq), begin(first), end(last) {
|
||||
}
|
||||
|
||||
octave_value value() const {
|
||||
if (base::current == end) {
|
||||
throw OctStopIteration();
|
||||
} else {
|
||||
return from(static_cast<const value_type&>(* (base::current)));
|
||||
}
|
||||
}
|
||||
|
||||
OctIterator* copy() const {
|
||||
return new self_type(*this);
|
||||
}
|
||||
|
||||
OctIterator* incr(size_t n = 1) {
|
||||
while (n--) {
|
||||
if (base::current == end) {
|
||||
throw OctStopIteration();
|
||||
} else {
|
||||
++base::current;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
OctIterator* decr(size_t n = 1) {
|
||||
while (n--) {
|
||||
if (base::current == begin) {
|
||||
throw OctStopIteration();
|
||||
} else {
|
||||
--base::current;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
out_iterator begin;
|
||||
out_iterator end;
|
||||
|
||||
};
|
||||
|
||||
template<typename OutIter>
|
||||
inline OctIterator* make_output_iterator(const OutIter& current, const OutIter& begin, const OutIter& end, octave_value seq = octave_value())
|
||||
{
|
||||
return new OctIteratorClosed_T<OutIter> (current, begin, end, seq);
|
||||
throw stop_iteration();
|
||||
}
|
||||
|
||||
template<typename OutIter>
|
||||
inline OctIterator* make_output_iterator(const OutIter& current, octave_value seq = octave_value())
|
||||
virtual ptrdiff_t distance(const OctSwigIterator &x) const
|
||||
{
|
||||
return new OctIteratorOpen_T<OutIter> (current, seq);
|
||||
throw std::invalid_argument("operation not supported");
|
||||
}
|
||||
|
||||
}
|
||||
virtual bool equal (const OctSwigIterator &x) const
|
||||
{
|
||||
throw std::invalid_argument("operation not supported");
|
||||
}
|
||||
|
||||
virtual OctSwigIterator *copy() const = 0;
|
||||
|
||||
octave_value next()
|
||||
{
|
||||
octave_value obj = value();
|
||||
incr();
|
||||
return obj;
|
||||
}
|
||||
|
||||
octave_value previous()
|
||||
{
|
||||
decr();
|
||||
return value();
|
||||
}
|
||||
|
||||
OctSwigIterator *advance(ptrdiff_t n)
|
||||
{
|
||||
return (n > 0) ? incr(n) : decr(-n);
|
||||
}
|
||||
|
||||
bool operator == (const OctSwigIterator& x) const
|
||||
{
|
||||
return equal(x);
|
||||
}
|
||||
|
||||
bool operator != (const OctSwigIterator& x) const
|
||||
{
|
||||
return ! operator==(x);
|
||||
}
|
||||
|
||||
OctSwigIterator* operator ++ () {
|
||||
incr();
|
||||
return this;
|
||||
}
|
||||
|
||||
OctSwigIterator* operator -- () {
|
||||
decr();
|
||||
return this;
|
||||
}
|
||||
|
||||
OctSwigIterator* operator + (ptrdiff_t n) const
|
||||
{
|
||||
return copy()->advance(n);
|
||||
}
|
||||
|
||||
OctSwigIterator* operator - (ptrdiff_t n) const
|
||||
{
|
||||
return copy()->advance(-n);
|
||||
}
|
||||
|
||||
ptrdiff_t operator - (const OctSwigIterator& x) const
|
||||
{
|
||||
return x.distance(*this);
|
||||
}
|
||||
|
||||
static swig_type_info* descriptor() {
|
||||
static int init = 0;
|
||||
static swig_type_info* desc = 0;
|
||||
if (!init) {
|
||||
desc = SWIG_TypeQuery("swig::OctSwigIterator *");
|
||||
init = 1;
|
||||
}
|
||||
return desc;
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
%fragment("OctIterator");
|
||||
%fragment("OctSwigIterator_T","header",fragment="<stddef.h>",fragment="OctSwigIterator",fragment="StdTraits",fragment="StdIteratorTraits") {
|
||||
namespace swig {
|
||||
template<typename OutIterator>
|
||||
class OctSwigIterator_T : public OctSwigIterator
|
||||
{
|
||||
public:
|
||||
typedef OutIterator out_iterator;
|
||||
typedef typename std::iterator_traits<out_iterator>::value_type value_type;
|
||||
typedef OctSwigIterator_T<out_iterator> self_type;
|
||||
|
||||
namespace swig
|
||||
OctSwigIterator_T(out_iterator curr, octave_value seq)
|
||||
: OctSwigIterator(seq), current(curr)
|
||||
{
|
||||
}
|
||||
|
||||
const out_iterator& get_current() const
|
||||
{
|
||||
return current;
|
||||
}
|
||||
|
||||
|
||||
bool equal (const OctSwigIterator &iter) const
|
||||
{
|
||||
const self_type *iters = dynamic_cast<const self_type *>(&iter);
|
||||
if (iters) {
|
||||
return (current == iters->get_current());
|
||||
} else {
|
||||
throw std::invalid_argument("bad iterator type");
|
||||
}
|
||||
}
|
||||
|
||||
ptrdiff_t distance(const OctSwigIterator &iter) const
|
||||
{
|
||||
const self_type *iters = dynamic_cast<const self_type *>(&iter);
|
||||
if (iters) {
|
||||
return std::distance(current, iters->get_current());
|
||||
} else {
|
||||
throw std::invalid_argument("bad iterator type");
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
out_iterator current;
|
||||
};
|
||||
|
||||
template <class ValueType>
|
||||
struct from_oper
|
||||
{
|
||||
typedef const ValueType& argument_type;
|
||||
typedef octave_value result_type;
|
||||
result_type operator()(argument_type v) const
|
||||
{
|
||||
return swig::from(v);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename OutIterator,
|
||||
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
|
||||
typename FromOper = from_oper<ValueType> >
|
||||
class OctSwigIteratorOpen_T : public OctSwigIterator_T<OutIterator>
|
||||
{
|
||||
public:
|
||||
FromOper from;
|
||||
typedef OutIterator out_iterator;
|
||||
typedef ValueType value_type;
|
||||
typedef OctSwigIterator_T<out_iterator> base;
|
||||
typedef OctSwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
|
||||
|
||||
OctSwigIteratorOpen_T(out_iterator curr, octave_value seq)
|
||||
: OctSwigIterator_T<OutIterator>(curr, seq)
|
||||
{
|
||||
}
|
||||
|
||||
octave_value value() const {
|
||||
return from(static_cast<const value_type&>(*(base::current)));
|
||||
}
|
||||
|
||||
OctSwigIterator *copy() const
|
||||
{
|
||||
return new self_type(*this);
|
||||
}
|
||||
|
||||
OctSwigIterator *incr(size_t n = 1)
|
||||
{
|
||||
while (n--) {
|
||||
++base::current;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
OctSwigIterator *decr(size_t n = 1)
|
||||
{
|
||||
while (n--) {
|
||||
--base::current;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename OutIterator,
|
||||
typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
|
||||
typename FromOper = from_oper<ValueType> >
|
||||
class OctSwigIteratorClosed_T : public OctSwigIterator_T<OutIterator>
|
||||
{
|
||||
public:
|
||||
FromOper from;
|
||||
typedef OutIterator out_iterator;
|
||||
typedef ValueType value_type;
|
||||
typedef OctSwigIterator_T<out_iterator> base;
|
||||
typedef OctSwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
|
||||
|
||||
OctSwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, octave_value seq)
|
||||
: OctSwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
|
||||
{
|
||||
}
|
||||
|
||||
octave_value value() const {
|
||||
if (base::current == end) {
|
||||
throw stop_iteration();
|
||||
} else {
|
||||
return from(static_cast<const value_type&>(*(base::current)));
|
||||
}
|
||||
}
|
||||
|
||||
OctSwigIterator *copy() const
|
||||
{
|
||||
return new self_type(*this);
|
||||
}
|
||||
|
||||
OctSwigIterator *incr(size_t n = 1)
|
||||
{
|
||||
while (n--) {
|
||||
if (base::current == end) {
|
||||
throw stop_iteration();
|
||||
} else {
|
||||
++base::current;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
OctSwigIterator *decr(size_t n = 1)
|
||||
{
|
||||
while (n--) {
|
||||
if (base::current == begin) {
|
||||
throw stop_iteration();
|
||||
} else {
|
||||
--base::current;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
private:
|
||||
out_iterator begin;
|
||||
out_iterator end;
|
||||
};
|
||||
|
||||
template<typename OutIter>
|
||||
inline OctSwigIterator*
|
||||
make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, octave_value seq = octave_value())
|
||||
{
|
||||
return new OctSwigIteratorClosed_T<OutIter>(current, begin, end, seq);
|
||||
}
|
||||
|
||||
template<typename OutIter>
|
||||
inline OctSwigIterator*
|
||||
make_output_iterator(const OutIter& current, octave_value seq = octave_value())
|
||||
{
|
||||
return new OctSwigIteratorOpen_T<OutIter>(current, seq);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
%fragment("OctSwigIterator");
|
||||
namespace swig
|
||||
{
|
||||
|
||||
// Throw a StopIteration exception
|
||||
%ignore OctStopIteration;
|
||||
struct OctStopIteration {};
|
||||
%typemap(throws) OctStopIteration {
|
||||
error("OctStopIteration exception");
|
||||
// Throw a StopIteration exception
|
||||
%ignore stop_iteration;
|
||||
struct stop_iteration {};
|
||||
|
||||
%typemap(throws) stop_iteration {
|
||||
error("stop_iteration exception");
|
||||
SWIG_fail;
|
||||
}
|
||||
|
||||
// Mark methods that return new objects
|
||||
%newobject OctIterator::copy;
|
||||
%newobject OctIterator::operator+ (ptrdiff_t n) const;
|
||||
%newobject OctIterator::operator- (ptrdiff_t n) const;
|
||||
// Mark methods that return new objects
|
||||
%newobject OctSwigIterator::copy;
|
||||
%newobject OctSwigIterator::operator + (ptrdiff_t n) const;
|
||||
%newobject OctSwigIterator::operator - (ptrdiff_t n) const;
|
||||
|
||||
%catches(swig::OctStopIteration) OctIterator::value() const;
|
||||
%catches(swig::OctStopIteration) OctIterator::incr(size_t n = 1);
|
||||
%catches(swig::OctStopIteration) OctIterator::decr(size_t n = 1);
|
||||
%catches(std::invalid_argument) OctIterator::distance(const OctIterator& x) const;
|
||||
%catches(std::invalid_argument) OctIterator::equal(const OctIterator& x) const;
|
||||
%catches(swig::OctStopIteration) OctIterator::next();
|
||||
%catches(swig::OctStopIteration) OctIterator::previous();
|
||||
%catches(swig::OctStopIteration) OctIterator::advance(ptrdiff_t n);
|
||||
%catches(swig::OctStopIteration) OctIterator::operator+= (ptrdiff_t n);
|
||||
%catches(swig::OctStopIteration) OctIterator::operator-= (ptrdiff_t n);
|
||||
%catches(swig::OctStopIteration) OctIterator::operator+ (ptrdiff_t n) const;
|
||||
%catches(swig::OctStopIteration) OctIterator::operator- (ptrdiff_t n) const;
|
||||
%nodirector OctSwigIterator;
|
||||
|
||||
%nodirector OctIterator;
|
||||
struct OctIterator {
|
||||
%catches(swig::stop_iteration) OctSwigIterator::value() const;
|
||||
%catches(swig::stop_iteration) OctSwigIterator::incr(size_t n = 1);
|
||||
%catches(swig::stop_iteration) OctSwigIterator::decr(size_t n = 1);
|
||||
%catches(std::invalid_argument) OctSwigIterator::distance(const OctSwigIterator &x) const;
|
||||
%catches(std::invalid_argument) OctSwigIterator::equal (const OctSwigIterator &x) const;
|
||||
%catches(swig::stop_iteration) OctSwigIterator::next();
|
||||
%catches(swig::stop_iteration) OctSwigIterator::previous();
|
||||
%catches(swig::stop_iteration) OctSwigIterator::advance(ptrdiff_t n);
|
||||
%catches(swig::stop_iteration) OctSwigIterator::operator += (ptrdiff_t n);
|
||||
%catches(swig::stop_iteration) OctSwigIterator::operator -= (ptrdiff_t n);
|
||||
%catches(swig::stop_iteration) OctSwigIterator::operator + (ptrdiff_t n) const;
|
||||
%catches(swig::stop_iteration) OctSwigIterator::operator - (ptrdiff_t n) const;
|
||||
|
||||
|
||||
struct OctSwigIterator
|
||||
{
|
||||
protected:
|
||||
|
||||
OctIterator(octave_value seq);
|
||||
OctSwigIterator(octave_value seq);
|
||||
|
||||
public:
|
||||
virtual ~OctSwigIterator();
|
||||
|
||||
virtual ~OctIterator();
|
||||
virtual octave_value value() const = 0;
|
||||
virtual OctIterator* incr(size_t n = 1) = 0;
|
||||
virtual OctIterator* decr(size_t n = 1);
|
||||
virtual ptrdiff_t distance(const OctIterator& x) const;
|
||||
virtual bool equal(const OctIterator& x) const;
|
||||
virtual OctIterator* copy() const = 0;
|
||||
|
||||
virtual OctSwigIterator *incr(size_t n = 1) = 0;
|
||||
|
||||
virtual OctSwigIterator *decr(size_t n = 1);
|
||||
|
||||
virtual ptrdiff_t distance(const OctSwigIterator &x) const;
|
||||
|
||||
virtual bool equal (const OctSwigIterator &x) const;
|
||||
|
||||
virtual OctSwigIterator *copy() const = 0;
|
||||
|
||||
octave_value next();
|
||||
octave_value previous();
|
||||
OctIterator* advance(ptrdiff_t n);
|
||||
bool operator== (const OctIterator& x) const;
|
||||
bool operator!= (const OctIterator& x) const;
|
||||
OctIterator* operator++ ();
|
||||
OctIterator* operator-- ();
|
||||
OctIterator* operator+ (ptrdiff_t n) const;
|
||||
OctIterator* operator- (ptrdiff_t n) const;
|
||||
ptrdiff_t operator- (const OctIterator& x) const;
|
||||
OctSwigIterator *advance(ptrdiff_t n);
|
||||
|
||||
bool operator == (const OctSwigIterator& x) const;
|
||||
bool operator != (const OctSwigIterator& x) const;
|
||||
OctSwigIterator* operator ++ ();
|
||||
OctSwigIterator* operator -- ();
|
||||
OctSwigIterator* operator + (ptrdiff_t n) const;
|
||||
OctSwigIterator* operator - (ptrdiff_t n) const;
|
||||
ptrdiff_t operator - (const OctSwigIterator& x) const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue