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]; }