alex/GY-63_MS5611
1
0
Fork 0
mirror of https://github.com/RobTillaart/Arduino.git synced 2024-09-19 16:46:11 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Set 0.1.09 - added const where possible

Browse Source
This commit is contained in:
RobTillaart 2016-12-18 11:19:56 +01:00
parent 82a6117e48
commit f69a50d82f
3 changed files with 59 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
libraries/Set/Set.cpp
View File

@ -1,11 +1,12 @@
//
// FILE: Set.cpp
// AUTHOR: Rob Tillaart
// VERSION: 0.1.08
// VERSION: 0.1.09
// PURPOSE: SET library for Arduino
// URL: http://forum.arduino.cc/index.php?topic=279044.0
// URL:
//
// HISTORY:
// 0.1.09 2015-07-12 const + constructor
// 0.1.08 memset for clr()
// 0.1.07 faster first/next/last/prev; interface
// 0.1.06 added flag to constructor to optimize +,-,*,
@ -26,12 +27,13 @@
//
// CONSTRUCTORS
//
Set::Set(bool clear)
Set::Set(const bool clear)
{
if (clear)
{
clr();
}
_current = -1;
}
Set::Set(const Set &t)
@ -40,34 +42,35 @@ Set::Set(const Set &t)
{
_mem[i] = t._mem[i];
}
_current = -1;
}
/////////////////////////////////////////////////////
//
// METHODS
//
void Set::add(uint8_t v)
void Set::add(const uint8_t v)
{
uint8_t mask = 1 << (v & 7);
uint8_t idx = v / 8;
_mem[idx] |= mask;
}
void Set::sub(uint8_t v)
void Set::sub(const uint8_t v)
{
uint8_t mask = 1 << (v & 7);
uint8_t idx = v / 8;
_mem[idx] &= ~mask;
}
void Set::invert(uint8_t v)
void Set::invert(const uint8_t v)
{
uint8_t mask = 1 << (v & 7);
uint8_t idx = v / 8;
_mem[idx] ^= mask;
}
bool Set::has(uint8_t v)
bool Set::has(const uint8_t v)
{
uint8_t mask = 1 << (v & 7);
uint8_t idx = v / 8;
@ -125,19 +128,19 @@ int Set::next()
return findNext(p, q);
}
int Set::findNext(uint8_t p, uint8_t q)
int Set::findNext(const uint8_t p, const uint8_t q)
{
for (uint8_t i=p; i<32; i++)
for (uint8_t i = p; i < 32; i++)
{
uint8_t b = _mem[i];
if (b != 0)
{
uint8_t mask = 1<<q;
for (uint8_t j=q; j<8; j++)
uint8_t mask = 1 << q;
for (uint8_t j = q; j < 8; j++)
{
if (b & mask)
{
_current = i*8 + j;
_current = i * 8 + j;
return _current;
}
mask <<= 1;
@ -163,26 +166,26 @@ int Set::last()
return findPrev(31, 7);
}
int Set::findPrev(uint8_t p, uint8_t q)
int Set::findPrev(const uint8_t p, const uint8_t q)
{
uint8_t m = 1 << q;
for (uint8_t i=p; i!=255; --i) // uint < 0
for (uint8_t i = p; i != 255; --i) // uint < 0
{
uint8_t b = _mem[i];
if (b != 0)
{
uint8_t mask = m;
for (uint8_t j=q; j!=255; --j)
for (uint8_t j = q; j != 255; --j)
{
if (b & mask)
{
_current = i*8 + j;
_current = i * 8 + j;
return _current;
}
mask >>= 1;
}
}
m = 1<<7;
m = 1 << 7;
q = 7;
}
_current = -1;
@ -195,81 +198,81 @@ int Set::findPrev(uint8_t p, uint8_t q)
// OPERATORS
//
Set Set::operator + (Set &t) // union
Set Set::operator + (const Set &t) // union
{
Set s(false);
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
s._mem[i] = this->_mem[i] | t._mem[i];
}
return s;
}
Set Set::operator - (Set &t) // diff
Set Set::operator - (const Set &t) // diff
{
Set s(false);
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
s._mem[i] = this->_mem[i] & ~t._mem[i];
}
return s;
}
Set Set::operator * (Set &t) // intersection
Set Set::operator * (const Set &t) // intersection
{
Set s(false);
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
s._mem[i] = this->_mem[i] & t._mem[i];
}
return s;
}
void Set::operator += (Set &t) // union
void Set::operator += (const Set &t) // union
{
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
_mem[i] |= t._mem[i];
}
}
void Set::operator -= (Set &t) // diff
void Set::operator -= (const Set &t) // diff
{
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
_mem[i] &= ~t._mem[i];
}
}
void Set::operator *= (Set &t) // intersection
void Set::operator *= (const Set &t) // intersection
{
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
_mem[i] &= t._mem[i];
}
}
bool Set::operator == (Set &t) // equal
bool Set::operator == (const Set &t) const // equal
{
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
if (_mem[i] != t._mem[i]) return false;
}
return true;
}
bool Set::operator != (Set &t) // not equal
bool Set::operator != (const Set &t) const // not equal
{
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
if (_mem[i] != t._mem[i]) return true;
}
return false;
}
bool Set::operator <= (Set &t) // subSet
bool Set::operator <= (const Set &t) const // subSet
{
for (uint8_t i=0; i<32; i++)
for (uint8_t i = 0; i < 32; i++)
{
if ((_mem[i] & ~t._mem[i]) > 0) return false;
}

40
libraries/Set/Set.h
View File

@ -1,9 +1,9 @@
//
// FILE: Set.h
// AUTHOR: Rob Tillaart
// VERSION: 0.1.08
// VERSION: 0.1.09
// PURPOSE: SET library for Arduino
// URL: http://forum.arduino.cc/index.php?topic=279044.0
// URL:
//
// HISTORY:
// see Set.cpp file
@ -18,35 +18,35 @@
#include <Arduino.h>
#endif
#define SET_LIB_VERSION "0.1.08"
#define SET_LIB_VERSION "0.1.09"
class Set
{
public:
Set(bool clear = true); // create empty Set
explicit Set(const bool clear = true); // create empty Set
Set(const Set &t); // create copy Set
void clr(); // clear the Set
void invert(); // flip all elements in the Set
uint8_t count(); // return the #elements
uint8_t count() const; // return the #elements
// bool isEmpty();
void add(uint8_t); // add element to the Set
void sub(uint8_t); // remove element from Set
void invert(uint8_t); // flip element in Set
bool has(uint8_t); // element is in Set
void add(const uint8_t); // add element to the Set
void sub(const uint8_t); // remove element from Set
void invert(const uint8_t); // flip element in Set
bool has(const uint8_t) const; // element is in Set
Set operator + (Set &); // union
Set operator - (Set &); // diff
Set operator * (Set &); // intersection
Set operator + (const Set &); // union
Set operator - (const Set &); // diff
Set operator * (const Set &); // intersection
void operator += (Set &); // union
void operator -= (Set &); // diff
void operator *= (Set &); // intersection
void operator += (const Set &); // union
void operator -= (const Set &); // diff
void operator *= (const Set &); // intersection
bool operator == (Set &); // equal
bool operator != (Set &); // not equal
bool operator <= (Set &); // is subSet,
bool operator == (const Set &) const; // equal
bool operator != (const Set &) const; // not equal
bool operator <= (const Set &) const; // is subSet,
// a superSet b is not implemented as one could
// say b subSet a (b <= a)
// a <= b
@ -62,8 +62,8 @@ public:
private:
uint8_t _mem[32]; // can hold 0..255
int _current;
int findNext(uint8_t, uint8_t); // helper for first, next
int findPrev(uint8_t, uint8_t); // helper for last, prev
int findNext(const uint8_t, const uint8_t); // helper for first, next
int findPrev(const uint8_t, const uint8_t); // helper for last, prev
};
#endif
//

2
libraries/Set/library.properties
View File

@ -1,5 +1,5 @@
name=Set
version=0.1.08
version=0.1.09
author=Rob Tillaart <rob.tillaart@gmail.com>
maintainer=Rob Tillaart <rob.tillaart@gmail.com>
sentence=Library to implement SET datastructure.