int32_t SharedVariant::getSpaceUsage() const {
int32_t size = sizeof(SharedVariant);
if (!IS_REFCOUNTED_TYPE(m_type)) return size;
switch (m_type) {
case KindOfObject:
if (getIsObj()) {
return size + m_data.obj->getSpaceUsage();
}
// fall through
case KindOfString:
size += sizeof(StringData) + m_data.str->size();
break;
default:
assert(is(KindOfArray));
if (getSerializedArray()) {
size += sizeof(StringData) + m_data.str->size();
} else if (isPacked()) {
auto size = m_data.packed->size();
size += sizeof(ImmutablePackedArray) + size * sizeof(SharedVariant*);
for (size_t i = 0, n = m_data.packed->size(); i < n; i++) {
size += m_data.packed->vals()[i]->getSpaceUsage();
}
} else {
auto array = m_data.array;
size += array->getStructSize();
for (size_t i = 0, n = array->size(); i < n; i++) {
size += array->getKeyIndex(i)->getSpaceUsage();
size += array->getValIndex(i)->getSpaceUsage();
}
}
break;
}
return size;
}
std::string getMidiNoteText(uint8_t note, bool minor, bool usesSharps,
uint8_t numAccidentals, bool forceAccidentals)
{
if (!isValidMidiNote(note))
throw std::out_of_range("Invalid MIDI note value");
const uint8_t pitch = getMidiNotePitch(note);
// Find the index of the key (for the pitchClasses and keyText arrays).
const int tonic = getKeyIndex(minor, usesSharps, numAccidentals);
// Initial value needs to be larger than any possible distance.
uint8_t minDistance = 100;
// Index of the text representation that is the best match.
uint8_t bestMatch = 0;
// Find the correct text representation of the pitch, by finding the
// representation that is the shortest number of steps away from the
// tonic in the circle of fifths.
for (uint8_t i = 0; i < NUM_PITCH_CLASSES; i++)
{
if (pitchClasses[i] == pitch)
{
uint8_t dist = abs(tonic - i);
if (std::min(dist, minDistance) == dist)
{
minDistance = dist;
bestMatch = i;
}
}
}
std::string text = keyText[bestMatch];
// Add in a natural sign by default.
if (text.length() == 1)
{
text.append("=");
}
int lowerLimit = tonic - 1;
int upperLimit = tonic + 5;
if (minor)
{
lowerLimit -= 3;
upperLimit -= 3;
}
// Remove accidentals or natural signs for notes in the key signature.
if (lowerLimit <= bestMatch && upperLimit >= bestMatch &&
!forceAccidentals)
{
if (text.length() > 1)
{
text.erase(text.begin() + 1);
}
}
return text;
}
void SharedVariant::getStats(SharedVariantStats *stats) const {
stats->initStats();
stats->variantCount = 1;
switch (m_type) {
case KindOfUninit:
case KindOfNull:
case KindOfBoolean:
case KindOfInt64:
case KindOfDouble:
case KindOfStaticString:
stats->dataSize = sizeof(m_data.dbl);
stats->dataTotalSize = sizeof(SharedVariant);
break;
case KindOfObject:
if (getIsObj()) {
SharedVariantStats childStats;
m_data.obj->getSizeStats(&childStats);
stats->addChildStats(&childStats);
break;
}
// fall through
case KindOfString:
stats->dataSize = m_data.str->size();
stats->dataTotalSize = sizeof(SharedVariant) + sizeof(StringData) +
stats->dataSize;
break;
default:
assert(is(KindOfArray));
if (getSerializedArray()) {
stats->dataSize = m_data.str->size();
stats->dataTotalSize = sizeof(SharedVariant) + sizeof(StringData) +
stats->dataSize;
break;
}
if (isPacked()) {
stats->dataTotalSize = sizeof(SharedVariant) +
sizeof(ImmutablePackedArray);
auto size = m_data.packed->size();
stats->dataTotalSize += sizeof(SharedVariant*) * size;
for (size_t i = 0; i < size; i++) {
SharedVariant *v = m_data.packed->vals()[i];
SharedVariantStats childStats;
v->getStats(&childStats);
stats->addChildStats(&childStats);
}
} else {
auto array = m_data.array;
stats->dataTotalSize = sizeof(SharedVariant) + array->getStructSize();
for (size_t i = 0, n = array->size(); i < n; i++) {
SharedVariantStats childStats;
array->getKeyIndex(i)->getStats(&childStats);
stats->addChildStats(&childStats);
array->getValIndex(i)->getStats(&childStats);
stats->addChildStats(&childStats);
}
}
break;
}
}
void removePair(MAP* map, ELEMENT key){
// hier uitwerken
int x = 0;
int p = getKeyIndex(map, key);
if (p != -1) {
for ( x = p; x < map -> size - 1; x ++) {
map -> keys [x] = map -> keys[x + 1];
map -> values [x] = map -> values[x +1];
}
map -> size --;
}
}
int main(void)
{
DDRB = 0x0F;
int keyboardPushed = 0;
int confirmed = 0;
int col = 0;
int keyIndex = -100;
int keyboard[16] = {
7, 8, 9, 47,
4, 5, 6, 42,
1, 2, 3, 45,
-1, 0, -2, 43
};
uint8_t columnIndexes[4] = {
0b11111110,
0b11111101,
0b11111011,
0b11110111
};
lcd_init();
lcd_clrscr();
lcd_home();
while (1) {
PORTB = columnIndexes[col];
keyboardPushed = isKeyboardPushed();
keyIndex = getKeyIndex(col);
if (keyIndex == -100) {
displayValues();
}
if (keyboardPushed == 1 && confirmed == 0 && keyIndex != -100) {
confirmed = 1;
keyHandler(keyboard[keyIndex]);
} else if (keyboardPushed == 0 && confirmed == 1) {
confirmed = 0;
}
_delay_ms(25);
if (keyboardPushed == 0 && ++col==4) {
col=0;
}
}
}
std::string getKeyText(bool minor, bool usesSharps, uint8_t numAccidentals)
{
int tonic = getKeyIndex(minor, usesSharps, numAccidentals);
return keyText[tonic];
}
