SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

git-svn-id: svn://db.shs.com.ru/pip@471 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5

Browse Source
This commit is contained in:
Бычков Андрей
2017-04-26 13:55:05 +00:00
parent ed059005f9
commit 9c3a2cf8ca
15 changed files with 373 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
main.cpp
View File

@@ -83,37 +83,84 @@ public:
}
};
#include "piframe.h"
int main(int argc, char *argv[]) {
PIString s("123");
typedef PIString & MyT;
MyT i(s);
PIVariant v = PIVariant::fromValue(i);
piCout << v << v.value<__PIVariantTypeInfo__<MyT>::PureType>();
/*typedef PIString MyT;
piCout << typeid(MyT).name();
piCout << typeid(MyT&).name();
piCout << typeid(const MyT).name();
piCout << typeid(const MyT &).name();
piCout << typeid(MyT*).name();
piCout << typeid(const MyT*).name();
piCout << "";
piCout << typeid(TypeInfo<MyT>::PureType).name();
piCout << typeid(TypeInfo<MyT&>::PureType).name();
piCout << typeid(TypeInfo<const MyT>::PureType).name();
piCout << typeid(TypeInfo<const MyT&>::PureType).name();
piCout << typeid(TypeInfo<MyT*>::PureType).name();
piCout << typeid(TypeInfo<const MyT*>::PureType).name();*/
// v = PIVariant::fromValue(a);
/*
enum VCO_Aim_Type {VCO_Aim_Type_None, VCO_Aim_Type_Detected, VCO_Aim_Type_New, VCO_Aim_Type_Confirmed, VCO_Aim_Type_Deleted = 127};
#pragma pack (push, 1)
struct VCO_Element {
VCO_Element() {}
VCO_Aim_Type type;
double elapsed;
float wls_a; // m/s
float wls_b; // m
float speed;
float acceleration; // m/s^2
float prediction_pos; // m
float variance; // m
float power;
float angle;
int id;
int missed;
int missed_ml;
int confirmed;
int history_size;
bool tracing;
bool _found;
bool _checked;
bool _delete;
PIVector<PIVector<double> > history;
};
#pragma pack (pop)
struct VCO_ElementX {
VCO_Aim_Type type;
double elapsed;
float wls_a; // m/s
float wls_b; // m
float speed;
float acceleration; // m/s^2
float prediction_pos; // m
float variance; // m
float power;
float angle;
int id;
int missed;
int missed_ml;
int confirmed;
int history_size;
bool tracing;
bool _found;
bool _checked;
bool _delete;
};
struct VCO_ElementY : VCO_ElementX {
PIVector<PIVector<double> > history;
};
VCO_Element v;
VCO_ElementX x;
VCO_ElementY y;
piCout << sizeof(x);
piCout << sizeof(y) << sizeof(y.history) << sizeof(y) - sizeof(y.history) ;
piCout << sizeof(v) << sizeof(v.history) << sizeof(v) - sizeof(v.history) ;
return 0;*/
// PIDiagnostics d;
// piCout << d.receiveBytesPerSec();
// piSleep(3);
// piCout << d.receiveBytesPerSec();
// PIVector<float> in;
// for (int i = 0; i < 50; ++i)
// in << i%10;
PIVector<PIVector<double> > in;
in.resize(5);
for (int i = 0; i < in.size_s(); ++i)
for (int j = 0; j < 20; ++j)
in[i] << j+i*100;
// piCout << in.size() << in[0].size();
PIFrame<double> f0;
PIFrame<double> f1(30, 40);
//in.resize(1);
PIFrame<double> f2(in);
f0 = f2;
piCout << f0;
piCout << f1;
piCout << f2;
piCout << f2.rows() << f2.cols() << f2.length() << f2.rows()*f2.cols();
return 0;
// PIFFTWf fft;
// fft.preparePlan(50, PIFFTWf::foReal);
// PIVector<complexf> out = fft.calcFFT(in);

179
src_main/containers/pideque.h
View File

@@ -84,106 +84,107 @@ public:
class iterator {
friend class PIDeque<T>;
private:
iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
inline iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
PIDeque<T> * parent;
size_t pos;
public:
iterator(): parent(0), pos(0) {}
T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {++pos;}
void operator ++(int) {++pos;}
void operator --() {--pos;}
void operator --(int) {--pos;}
bool operator ==(const iterator & it) const {return (pos == it.pos);}
bool operator !=(const iterator & it) const {return (pos != it.pos);}
inline iterator(): parent(0), pos(0) {}
inline T & operator *() {return (*parent)[pos];}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {++pos;}
inline void operator ++(int) {++pos;}
inline void operator --() {--pos;}
inline void operator --(int) {--pos;}
inline bool operator ==(const iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const iterator & it) const {return (pos != it.pos);}
};
class const_iterator {
friend class PIDeque<T>;
private:
const_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
inline const_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
const PIDeque<T> * parent;
size_t pos;
public:
const_iterator(): parent(0), pos(0) {}
//T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {++pos;}
void operator ++(int) {++pos;}
void operator --() {--pos;}
void operator --(int) {--pos;}
bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
inline const_iterator(): parent(0), pos(0) {}
//inline T & operator *() {return (*parent)[pos];}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {++pos;}
inline void operator ++(int) {++pos;}
inline void operator --() {--pos;}
inline void operator --(int) {--pos;}
inline bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
};
class reverse_iterator {
friend class PIDeque<T>;
private:
reverse_iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
inline reverse_iterator(PIDeque<T> * v, size_t p): parent(v), pos(p) {}
PIDeque<T> * parent;
size_t pos;
public:
reverse_iterator(): parent(0), pos(0) {}
T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {--pos;}
void operator ++(int) {--pos;}
void operator --() {++pos;}
void operator --(int) {++pos;}
bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
inline reverse_iterator(): parent(0), pos(0) {}
inline T & operator *() {return (*parent)[pos];}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {--pos;}
inline void operator ++(int) {--pos;}
inline void operator --() {++pos;}
inline void operator --(int) {++pos;}
inline bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
};
class const_reverse_iterator {
friend class PIDeque<T>;
private:
const_reverse_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
inline const_reverse_iterator(const PIDeque<T> * v, size_t p): parent(v), pos(p) {}
const PIDeque<T> * parent;
size_t pos;
public:
const_reverse_iterator(): parent(0), pos(0) {}
//T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {--pos;}
void operator ++(int) {--pos;}
void operator --() {++pos;}
void operator --(int) {++pos;}
bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
inline const_reverse_iterator(): parent(0), pos(0) {}
//inline T & operator *() {return (*parent)[pos];}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {--pos;}
inline void operator ++(int) {--pos;}
inline void operator --() {++pos;}
inline void operator --(int) {++pos;}
inline bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
};
iterator begin() {return iterator(this, 0);}
iterator end() {return iterator(this, pid_size);}
const_iterator begin() const {return const_iterator(this, 0);}
const_iterator end() const {return const_iterator(this, pid_size);}
reverse_iterator rbegin() {return reverse_iterator(this, pid_size - 1);}
reverse_iterator rend() {return reverse_iterator(this, -1);}
const_reverse_iterator rbegin() const {return const_reverse_iterator(this, pid_size - 1);}
const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
inline iterator begin() {return iterator(this, 0);}
inline iterator end() {return iterator(this, pid_size);}
inline const_iterator begin() const {return const_iterator(this, 0);}
inline const_iterator end() const {return const_iterator(this, pid_size);}
inline reverse_iterator rbegin() {return reverse_iterator(this, pid_size - 1);}
inline reverse_iterator rend() {return reverse_iterator(this, -1);}
inline const_reverse_iterator rbegin() const {return const_reverse_iterator(this, pid_size - 1);}
inline const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
size_t size() const {return pid_size;}
ssize_t size_s() const {return pid_size;}
size_t length() const {return pid_size;}
size_t capacity() const {return pid_rsize;}
size_t _start() const {return pid_start;}
bool isEmpty() const {return (pid_size == 0);}
inline size_t size() const {return pid_size;}
inline ssize_t size_s() const {return pid_size;}
inline size_t length() const {return pid_size;}
inline size_t capacity() const {return pid_rsize;}
inline size_t _start() const {return pid_start;}
inline bool isEmpty() const {return (pid_size == 0);}
T & operator [](size_t index) {return pid_data[pid_start + index];}
T & at(size_t index) {return pid_data[pid_start + index];}
const T & operator [](size_t index) const {return pid_data[pid_start + index];}
const T & at(size_t index) const {return pid_data[pid_start + index];}
T & back() {return pid_data[pid_start + pid_size - 1];}
const T & back() const {return pid_data[pid_start + pid_size - 1];}
T & front() {return pid_data[pid_start];}
const T & front() const {return pid_data[pid_start];}
bool operator ==(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return false; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return false; return true;}
bool operator !=(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return true; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return true; return false;}
bool contains(const T & v) const {for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) return true; return false;}
int etries(const T & v) const {int ec = 0; for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) ++ec; return ec;}
inline T & operator [](size_t index) {return pid_data[pid_start + index];}
inline T & at(size_t index) {return pid_data[pid_start + index];}
inline const T & operator [](size_t index) const {return pid_data[pid_start + index];}
inline const T & at(size_t index) const {return pid_data[pid_start + index];}
inline T & back() {return pid_data[pid_start + pid_size - 1];}
inline const T & back() const {return pid_data[pid_start + pid_size - 1];}
inline T & front() {return pid_data[pid_start];}
inline const T & front() const {return pid_data[pid_start];}
inline bool operator ==(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return false; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return false; return true;}
inline bool operator !=(const PIDeque<T> & t) const {if (pid_size != t.pid_size) return true; for (size_t i = 0; i < pid_size; ++i) if (t[i] != (*this)[i]) return true; return false;}
inline bool contains(const T & v) const {for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) return true; return false;}
inline int etries(const T & v) const {int ec = 0; for (size_t i = pid_start; i < pid_start + pid_size; ++i) if (v == pid_data[i]) ++ec; return ec;}
inline T * data(size_t index = 0) {return &(pid_data[pid_start + index]);}
inline const T * data(size_t index = 0) const {return &(pid_data[pid_start + index]);}
T * data(size_t index = 0) {return &(pid_data[pid_start + index]);}
const T * data(size_t index = 0) const {return &(pid_data[pid_start + index]);}
inline PIDeque<T> & clear() {resize(0); return *this;}
inline PIDeque<T> & fill(const T & f = T()) {
//if (sizeof(T) == 1) memset(pid_data, f, pid_size);
@@ -296,37 +297,43 @@ public:
typedef int (*CompareFunc)(const T * , const T * );
static int compare_func(const T * t0, const T * t1) {return (*t0) < (*t1) ? -1 : ((*t0) == (*t1) ? 0 : 1);}
PIDeque<T> & sort(CompareFunc compare = compare_func) {piqsort(pid_data + pid_start, pid_size, sizeof(T), (int(*)(const void * , const void * ))compare); return *this;}
inline PIDeque<T> & sort(CompareFunc compare = compare_func) {piqsort(pid_data + pid_start, pid_size, sizeof(T), (int(*)(const void * , const void * ))compare); return *this;}
PIDeque<T> & enlarge(llong pid_size) {llong ns = size_s() + pid_size; if (ns <= 0) clear(); else resize(size_t(ns)); return *this;}
inline PIDeque<T> & enlarge(llong pid_size) {llong ns = size_s() + pid_size; if (ns <= 0) clear(); else resize(size_t(ns)); return *this;}
PIDeque<T> & removeOne(const T & v) {for (size_t i = 0; i < pid_size; ++i) if (pid_data[i + pid_start] == v) {remove(i); return *this;} return *this;}
PIDeque<T> & removeAll(const T & v) {for (ssize_t i = 0; i < ssize_t(pid_size); ++i) if (pid_data[i + pid_start] == v) {remove(i); --i;} return *this;}
inline PIDeque<T> & removeOne(const T & v) {for (size_t i = 0; i < pid_size; ++i) if (pid_data[i + pid_start] == v) {remove(i); return *this;} return *this;}
inline PIDeque<T> & removeAll(const T & v) {for (ssize_t i = 0; i < ssize_t(pid_size); ++i) if (pid_data[i + pid_start] == v) {remove(i); --i;} return *this;}
PIDeque<T> & push_back(const T & v) {alloc(pid_size + 1, true); PIINTROSPECTION_CONTAINER_USED(sizeof(T)); elementNew(pid_data + pid_start + pid_size - 1, v); return *this;}
PIDeque<T> & append(const T & v) {return push_back(v);}
PIDeque<T> & operator <<(const T & v) {return push_back(v);}
PIDeque<T> & operator <<(const PIDeque<T> & t) {
inline PIDeque<T> & push_back(const T & v) {alloc(pid_size + 1, true); PIINTROSPECTION_CONTAINER_USED(sizeof(T)); elementNew(pid_data + pid_start + pid_size - 1, v); return *this;}
inline PIDeque<T> & append(const T & v) {return push_back(v);}
inline PIDeque<T> & append(const PIDeque<T> & t) {
size_t ps = pid_size;
alloc(pid_size + t.pid_size, true);
newT(pid_data + ps + pid_start, t.pid_data + t.pid_start, t.pid_size);
return *this;
}
inline PIDeque<T> & operator <<(const T & v) {return push_back(v);}
inline PIDeque<T> & operator <<(const PIDeque<T> & t) {
size_t ps = pid_size;
alloc(pid_size + t.pid_size, true);
newT(pid_data + ps + pid_start, t.pid_data + t.pid_start, t.pid_size);
return *this;
}
PIDeque<T> & push_front(const T & v) {insert(0, v); return *this;}
PIDeque<T> & prepend(const T & v) {return push_front(v);}
inline PIDeque<T> & push_front(const T & v) {insert(0, v); return *this;}
inline PIDeque<T> & prepend(const T & v) {return push_front(v);}
PIDeque<T> & pop_back() {if (pid_size == 0) return *this; resize(pid_size - 1); return *this;}
PIDeque<T> & pop_front() {if (pid_size == 0) return *this; remove(0); return *this;}
inline PIDeque<T> & pop_back() {if (pid_size == 0) return *this; resize(pid_size - 1); return *this;}
inline PIDeque<T> & pop_front() {if (pid_size == 0) return *this; remove(0); return *this;}
T take_back() {T t(back()); pop_back(); return t;}
T take_front() {T t(front()); pop_front(); return t;}
inline T take_back() {T t(back()); pop_back(); return t;}
inline T take_front() {T t(front()); pop_front(); return t;}
template <typename ST>
PIDeque<ST> toType() const {PIDeque<ST> ret(pid_size); for (uint i = 0; i < pid_size; ++i) ret[i] = ST(pid_data[i + pid_start]); return ret;}
private:
void _reset() {pid_size = pid_rsize = pid_start = 0; pid_data = 0;}
inline void _reset() {pid_size = pid_rsize = pid_start = 0; pid_data = 0;}
/*void * qmemmove(void * dst, void * src, size_t size) {
if (piAbs<ssize_t>(ssize_t(dst) - ssize_t(src)) >= size)
memcpy(dst, src, size);
@@ -356,7 +363,7 @@ private:
for (size_t i = 0; i < s; ++i)
elementNew(dst + i, src[i]);
}
static T * newRaw(size_t s) {
inline static T * newRaw(size_t s) {
//std::cout << std::dec << " ![("<<this<<")newRaw " << s << " elements ... <" << std::endl;
//uchar * ret = new uchar[s * sizeof(T)];
uchar * ret = (uchar*)(malloc(s * sizeof(T)));//new uchar[];
@@ -378,13 +385,13 @@ private:
}
//cout << " > ok]~" << endl;
}
static void deleteRaw(T *& d) {
inline static void deleteRaw(T *& d) {
//cout << " ~[("<<this<<")deleteRaw " << std::dec << pid_rsize << " elements " << std::hex << "0x" << (llong)d << " ... <\n" << endl;
if ((uchar*)d != 0) free((uchar*)d);
d = 0;
//cout << " > ok]~" << endl;
}
static void zeroRaw(T * d, size_t s) {
inline static void zeroRaw(T * d, size_t s) {
//cout << " ~[("<<this<<")zeroRaw " << std::dec << s << " elements " << std::hex << "0x" << (llong)d << " ... <\n" << endl;
if ((uchar*)d != 0) memset(d, 0, s*sizeof(T));
//cout << " > ok]~" << endl;

86
src_main/containers/piframe.h Normal file
View File

@@ -0,0 +1,86 @@
#ifndef PIFRAME_H
#define PIFRAME_H
#include "pivector.h"
template <typename T>
class PIFrame {
public:
inline PIFrame() {rows_ = cols_ = 0;}
inline PIFrame(size_t rows, size_t cols, const T & f = T()) {
rows_ = rows;
cols_ = cols;
mat.resize(rows*cols, f);
}
inline PIFrame(const PIVector<PIVector<T> > & v) {
rows_ = v.size();
if (rows_) {
cols_ = v[0].size();
for (size_t i = 0; i < rows_; i++) {
mat.append(v[i]);
}
mat.resize(rows_*cols_);
}
if (mat.isEmpty()) rows_ = cols_ = 0;
}
inline size_t rows() const {return rows_;}
inline size_t cols() const {return cols_;}
// inline size_t size() const {return mat.size();}
// inline ssize_t size_s() const {return mat.size_s();}
inline size_t length() const {return mat.length();}
inline bool isEmpty() const {return mat.isEmpty();}
class PIFrameRow {
friend class PIFrame<T>;
private:
inline PIFrameRow(PIFrame<T> * p, size_t row) : p_(p) {st_ = p_->cols_ * row;}
PIFrame<T> * p_;
size_t st_;
public:
inline size_t size() const {return p_->cols_;}
inline T & operator [](size_t index) {return p_->mat[st_ + index];}
inline const T & operator [](size_t index) const {return p_->mat[st_ + index];}
};
class PIFrameRowConst {
friend class PIFrame<T>;
private:
inline PIFrameRowConst(const PIFrame<T> * p, size_t row) : p_(p) {st_ = p_->cols_ * row;}
const PIFrame<T> * p_;
size_t st_;
public:
inline size_t size() const {return p_->cols_;}
inline const T & operator [](size_t index) const {return p_->mat[st_ + index];}
};
inline PIFrameRow operator[](size_t index) {return PIFrameRow(this, index);}
inline PIFrameRowConst operator[](size_t index) const {return PIFrameRowConst(this, index);}
private:
size_t rows_, cols_;
PIVector<T> mat;
};
template<typename T>
inline PICout operator <<(PICout s, const PIFrame<T> & v) {
s.setControl(0, true);
s << "{";
for (size_t i = 0; i < v.rows(); ++i) {
s << "{ ";
for (size_t j = 0; j < v.cols(); ++j) {
s << v[i][j];
if (j < v.cols() - 1) s << ", ";
}
s << " }";
if (i < v.rows() - 1) s << PICoutManipulators::NewLine ;
}
if (v.isEmpty()) s << "{ }";
s << "}";
s.restoreControl();
return s;
}
#endif // PIFRAME_H

143
src_main/containers/pivector.h
View File

@@ -77,107 +77,108 @@ public:
class iterator {
friend class PIVector<T>;
private:
iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
inline iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
PIVector<T> * parent;
size_t pos;
public:
iterator(): parent(0), pos(0) {}
T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {++pos;}
void operator ++(int) {++pos;}
void operator --() {--pos;}
void operator --(int) {--pos;}
bool operator ==(const iterator & it) const {return (pos == it.pos);}
bool operator !=(const iterator & it) const {return (pos != it.pos);}
inline iterator(): parent(0), pos(0) {}
inline T & operator *() {return (*parent)[pos];}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {++pos;}
inline void operator ++(int) {++pos;}
inline void operator --() {--pos;}
inline void operator --(int) {--pos;}
inline bool operator ==(const iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const iterator & it) const {return (pos != it.pos);}
};
class const_iterator {
friend class PIVector<T>;
private:
const_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
inline const_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
const PIVector<T> * parent;
size_t pos;
public:
const_iterator(): parent(0), pos(0) {}
inline const_iterator(): parent(0), pos(0) {}
//T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {++pos;}
void operator ++(int) {++pos;}
void operator --() {--pos;}
void operator --(int) {--pos;}
bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {++pos;}
inline void operator ++(int) {++pos;}
inline void operator --() {--pos;}
inline void operator --(int) {--pos;}
inline bool operator ==(const const_iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const const_iterator & it) const {return (pos != it.pos);}
};
class reverse_iterator {
friend class PIVector<T>;
private:
reverse_iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
inline reverse_iterator(PIVector<T> * v, size_t p): parent(v), pos(p) {}
PIVector<T> * parent;
size_t pos;
public:
reverse_iterator(): parent(0), pos(0) {}
T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {--pos;}
void operator ++(int) {--pos;}
void operator --() {++pos;}
void operator --(int) {++pos;}
bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
inline reverse_iterator(): parent(0), pos(0) {}
inline T & operator *() {return (*parent)[pos];}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {--pos;}
inline void operator ++(int) {--pos;}
inline void operator --() {++pos;}
inline void operator --(int) {++pos;}
inline bool operator ==(const reverse_iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const reverse_iterator & it) const {return (pos != it.pos);}
};
class const_reverse_iterator {
friend class PIVector<T>;
private:
const_reverse_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
inline const_reverse_iterator(const PIVector<T> * v, size_t p): parent(v), pos(p) {}
const PIVector<T> * parent;
size_t pos;
public:
const_reverse_iterator(): parent(0), pos(0) {}
inline const_reverse_iterator(): parent(0), pos(0) {}
//T & operator *() {return (*parent)[pos];}
const T & operator *() const {return (*parent)[pos];}
void operator ++() {--pos;}
void operator ++(int) {--pos;}
void operator --() {++pos;}
void operator --(int) {++pos;}
bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
inline const T & operator *() const {return (*parent)[pos];}
inline void operator ++() {--pos;}
inline void operator ++(int) {--pos;}
inline void operator --() {++pos;}
inline void operator --(int) {++pos;}
inline bool operator ==(const const_reverse_iterator & it) const {return (pos == it.pos);}
inline bool operator !=(const const_reverse_iterator & it) const {return (pos != it.pos);}
};
iterator begin() {return iterator(this, 0);}
iterator end() {return iterator(this, piv_size);}
const_iterator begin() const {return const_iterator(this, 0);}
const_iterator end() const {return const_iterator(this, piv_size);}
reverse_iterator rbegin() {return reverse_iterator(this, piv_size - 1);}
reverse_iterator rend() {return reverse_iterator(this, -1);}
const_reverse_iterator rbegin() const {return const_reverse_iterator(this, piv_size - 1);}
const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
inline iterator begin() {return iterator(this, 0);}
inline iterator end() {return iterator(this, piv_size);}
inline const_iterator begin() const {return const_iterator(this, 0);}
inline const_iterator end() const {return const_iterator(this, piv_size);}
inline reverse_iterator rbegin() {return reverse_iterator(this, piv_size - 1);}
inline reverse_iterator rend() {return reverse_iterator(this, -1);}
inline const_reverse_iterator rbegin() const {return const_reverse_iterator(this, piv_size - 1);}
inline const_reverse_iterator rend() const {return const_reverse_iterator(this, -1);}
size_t size() const {return piv_size;}
ssize_t size_s() const {return piv_size;}
size_t length() const {return piv_size;}
size_t capacity() const {return piv_rsize;}
bool isEmpty() const {return (piv_size == 0);}
inline size_t size() const {return piv_size;}
inline ssize_t size_s() const {return piv_size;}
inline size_t length() const {return piv_size;}
inline size_t capacity() const {return piv_rsize;}
inline bool isEmpty() const {return (piv_size == 0);}
T & operator [](size_t index) {return piv_data[index];}
T & at(size_t index) {return piv_data[index];}
const T & operator [](size_t index) const {return piv_data[index];}
const T & at(size_t index) const {return piv_data[index];}
T & back() {return piv_data[piv_size - 1];}
const T & back() const {return piv_data[piv_size - 1];}
T & front() {return piv_data[0];}
const T & front() const {return piv_data[0];}
bool operator ==(const PIVector<T> & t) const {if (piv_size != t.piv_size) return false; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return false; return true;}
bool operator !=(const PIVector<T> & t) const {if (piv_size != t.piv_size) return true; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return true; return false;}
bool contains(const T & v) const {for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return true; return false;}
int etries(const T & v) const {int ec = 0; for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) ++ec; return ec;}
ssize_t indexOf(const T & v) const {for (ssize_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return i; return -1;}
ssize_t lastIndexOf(const T & v) const {for (ssize_t i = piv_size - 1; i >= 0; --i) if (v == piv_data[i]) return i; return -1;}
inline T & operator [](size_t index) {return piv_data[index];}
inline T & at(size_t index) {return piv_data[index];}
inline const T & operator [](size_t index) const {return piv_data[index];}
inline const T & at(size_t index) const {return piv_data[index];}
inline T & back() {return piv_data[piv_size - 1];}
inline const T & back() const {return piv_data[piv_size - 1];}
inline T & front() {return piv_data[0];}
inline const T & front() const {return piv_data[0];}
inline bool operator ==(const PIVector<T> & t) const {if (piv_size != t.piv_size) return false; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return false; return true;}
inline bool operator !=(const PIVector<T> & t) const {if (piv_size != t.piv_size) return true; for (size_t i = 0; i < piv_size; ++i) if (t[i] != piv_data[i]) return true; return false;}
inline bool contains(const T & v) const {for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return true; return false;}
inline int etries(const T & v) const {int ec = 0; for (size_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) ++ec; return ec;}
inline ssize_t indexOf(const T & v) const {for (ssize_t i = 0; i < piv_size; ++i) if (v == piv_data[i]) return i; return -1;}
inline ssize_t lastIndexOf(const T & v) const {for (ssize_t i = piv_size - 1; i >= 0; --i) if (v == piv_data[i]) return i; return -1;}
inline T * data(size_t index = 0) {return &(piv_data[index]);}
inline const T * data(size_t index = 0) const {return &(piv_data[index]);}
T * data(size_t index = 0) {return &(piv_data[index]);}
const T * data(size_t index = 0) const {return &(piv_data[index]);}
inline PIVector<T> & clear() {resize(0); return *this;}
inline PIVector<T> & fill(const T & f = T()) {
//if (sizeof(T) == 1) memset(piv_data, f, piv_size);
@@ -230,7 +231,7 @@ public:
elementNew(piv_data + index, v);
return *this;
}
PIVector<T> & insert(size_t index, const PIVector<T> & other) {
inline PIVector<T> & insert(size_t index, const PIVector<T> & other) {
if (other.isEmpty()) return *this;
ssize_t os = piv_size - index;
alloc(piv_size + other.piv_size);
@@ -270,6 +271,12 @@ public:
inline PIVector<T> & push_back(const T & v) {alloc(piv_size + 1); elementNew(piv_data + piv_size - 1, v); return *this;}
inline PIVector<T> & append(const T & v) {return push_back(v);}
inline PIVector<T> & append(const PIVector<T> & other) {
size_t ps = piv_size;
alloc(piv_size + other.piv_size);
newT(piv_data + ps, other.piv_data, other.piv_size);
return *this;
}
inline PIVector<T> & operator <<(const T & v) {return push_back(v);}
inline PIVector<T> & operator <<(const PIVector<T> & other) {
size_t ps = piv_size;

2
src_main/io/pibinarylog.h
View File

@@ -268,7 +268,7 @@ public:
static BinLogInfo getLogInfo(const PIString & path);
protected:
PIString fullPathPrefix() const {return "binlog";}
PIString fullPathPrefix() const {return PIStringAscii("binlog");}
PIString constructFullPathDevice() const;
void configureFromFullPathDevice(const PIString & full_path);
int readDevice(void *read_to, int max_size);

2
src_main/io/pifile.h
View File

@@ -286,7 +286,7 @@ public:
//! \}
protected:
PIString fullPathPrefix() const {return "file";}
PIString fullPathPrefix() const {return PIStringAscii("file");}
PIString constructFullPathDevice() const;
void configureFromFullPathDevice(const PIString & full_path);
int readDevice(void * read_to, int max_size);

2
src_main/io/pipacketextractor.h
View File

@@ -157,7 +157,7 @@ private:
int readDevice(void * read_to, int max_size) {if (dev == 0) return -1; return dev->read(read_to, max_size);}
int writeDevice(const void * data, int max_size) {if (dev == 0) return -1; return dev->write(data, max_size);}
bool threadedRead(uchar * readed, int size);
PIString fullPathPrefix() const {return "pckext";}
PIString fullPathPrefix() const {return PIStringAscii("pckext");}
PIString constructFullPathDevice() const;
bool openDevice() {if (dev == 0) return false; return dev->open();}

12
src_main/io/pipeer.cpp
View File

@@ -448,11 +448,12 @@ bool PIPeer::sendInternal(const PIString & to, const PIByteArray & data) {
void PIPeer::dtReceived(const PIString & from, const PIByteArray & data) {
PIByteArray ba = data;
dataReceived(from, data);
dataReceivedEvent(from, data);
if (trust_peer.isEmpty() || trust_peer == from) {
read_buffer_mutex.lock();
if (read_buffer.size_s() < read_buffer_size) read_buffer.enqueue(data);
if (read_buffer.size_s() < read_buffer_size) read_buffer.enqueue(ba);
read_buffer_mutex.unlock();
}
}
@@ -860,10 +861,11 @@ bool PIPeer::openDevice() {
diag_d.reset();
diag_s.reset();
//piCoutObj << "open...";
PIMutexLocker ml(peers_mutex);
if (trust_peer.isEmpty())
return !peers.isEmpty();
return hasPeer(trust_peer);
return true;
// PIMutexLocker ml(peers_mutex);
// if (trust_peer.isEmpty())
// return !peers.isEmpty();
// return hasPeer(trust_peer);
}

2
src_main/io/pipeer.h
View File

@@ -166,7 +166,7 @@ private:
bool openDevice();
bool closeDevice();
PIString fullPathPrefix() const {return "peer";}
PIString fullPathPrefix() const {return PIStringAscii("peer");}
PIString constructFullPathDevice() const;
void configureFromFullPathDevice(const PIString &full_path);
int readDevice(void * read_to, int max_size);

2
src_main/io/piserial.h
View File

@@ -205,7 +205,7 @@ public:
//! \}
protected:
PIString fullPathPrefix() const {return "ser";}
PIString fullPathPrefix() const {return PIStringAscii("ser");}
PIString constructFullPathDevice() const;
void configureFromFullPathDevice(const PIString & full_path);
bool configureDevice(const void * e_main, const void * e_parent = 0);

29
src_main/io/pisharedmemory.cpp
View File

@@ -54,7 +54,7 @@
*
*/
//REGISTER_DEVICE(PISharedMemory);
REGISTER_DEVICE(PISharedMemory)
PRIVATE_DEFINITION_START(PISharedMemory)
PIByteArray name;
@@ -71,7 +71,7 @@ PRIVATE_DEFINITION_END(PISharedMemory)
PISharedMemory::PISharedMemory(): PIIODevice() {
initPrivate();
dsize = -1;
dsize = 65536;
}
@@ -93,6 +93,7 @@ PISharedMemory::PISharedMemory(const PISharedMemory & other) {
bool PISharedMemory::openDevice() {
close();
piCoutObj << "try open" << path() << dsize;
#ifdef WINDOWS
DWORD m = PAGE_READWRITE;
if (!isWriteable()) m = PAGE_READONLY;
@@ -100,14 +101,14 @@ bool PISharedMemory::openDevice() {
PRIVATE->name.push_back(0);
PRIVATE->map = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, m, 0, (DWORD)dsize, (const char *)PRIVATE->name.data());
if (!PRIVATE->map) {
piCoutObj << "CreateFileMapping error," << errorString();
piCoutObj << path() << dsize << "CreateFileMapping error," << errorString();
return false;
}
if (!isWriteable()) m = FILE_MAP_READ;
else m = FILE_MAP_ALL_ACCESS;
PRIVATE->data = MapViewOfFile(PRIVATE->map, m, 0, 0, dsize);
if (!PRIVATE->data) {
piCoutObj << "MapViewOfFile error," << errorString();
piCoutObj << path() << dsize << "MapViewOfFile error," << errorString();
CloseHandle(PRIVATE->map);
return false;
}
@@ -166,6 +167,26 @@ bool PISharedMemory::closeDevice() {
}
PIString PISharedMemory::constructFullPathDevice() const {
PIString ret;
ret << path() << ":" << dsize;
return ret;
}
void PISharedMemory::configureFromFullPathDevice(const PIString & full_path) {
initPrivate();
PIStringList pl = full_path.split(":");
for (int i = 0; i < pl.size_s(); ++i) {
PIString p(pl[i]);
switch (i) {
case 0: setPath(p); break;
case 1: dsize = p.toInt(); break;
}
}
}
void PISharedMemory::initPrivate() {
#ifdef WINDOWS
PRIVATE->map = 0;

3
src_main/io/pisharedmemory.h
View File

@@ -71,6 +71,9 @@ public:
protected:
bool openDevice();
bool closeDevice();
PIString fullPathPrefix() const {return PIStringAscii("shm");}
PIString constructFullPathDevice() const;
void configureFromFullPathDevice(const PIString & full_path);
int readDevice(void * read_to, int max_size) {return read(read_to, max_size, 0);}
int writeDevice(const void * data, int max_size) {return write(data, max_size, 0);}

4
src_main/io/pitransparentdevice.cpp
View File

@@ -61,9 +61,7 @@ int PITransparentDevice::writeDevice(const void * data, int max_size) {
}
PIString PITransparentDevice::fullPathPrefix() const {
return PIStringAscii("tr");
}
bool PITransparentDevice::openDevice() {

2
src_main/io/pitransparentdevice.h
View File

@@ -41,7 +41,7 @@ protected:
bool closeDevice();
int readDevice(void * read_to, int max_size);
int writeDevice(const void * data, int max_size);
PIString fullPathPrefix() const;
PIString fullPathPrefix() const {return PIStringAscii("tr");}
PIMutex que_mutex;
PIQueue<PIByteArray> que;

2
src_main/io/piusb.h
View File

@@ -126,7 +126,7 @@ public:
void flush();
protected:
PIString fullPathPrefix() const {return "usb";}
PIString fullPathPrefix() const {return PIStringAscii("usb");}
bool configureDevice(const void * e_main, const void * e_parent = 0);
PIString constructFullPathDevice() const;
void configureFromFullPathDevice(const PIString & full_path);