int main()
{
int n, a, b, c, d, e;
scanf("%d", &n);
assert(maxsize > n);
for(int i = 0; i < n; i++) {
scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);
br[2*i] = (bracket<int, int>(b, e));
br[2*i+1] = (bracket<int, int>(d, -e));
t[2*i] = (Interval(a, IAux1(Ins, IAux2(&br[2*i], &br[2*i+1]))));
t[2*i+1] = (Interval(c, IAux1(Del, IAux2(&br[2*i], &br[2*i+1]))));
}
std::sort(t.begin(), t.begin()+2*n);
ITNode<bracket<int, int> >* head = new ITNode<bracket<int,int> > ();
long long max = head->treeMax;
for(int i = 0; i < 2*n; i++) {
#ifdef debugid
std::cout << "---\n";
#endif
//std::cout << *head << "\n";
if(t[i].y.x == Ins) {
head = insertKey(head, t[i].y.y.y);
head = insertKey(head, t[i].y.y.x);
} else {
head = deleteKey(head, t[i].y.y.x);
head = deleteKey(head, t[i].y.y.y);
}
if(head->treeMax > max)
max = head->treeMax;
}
printf("%lld\n", max);
}
ITNode<Key>* insertKey(ITNode<Key>* arg, Key * k)
{
#ifdef debugid
std::cout << "Inserting.. " << *k << " to " << *arg << "\n";
#endif
if(arg->key == NULL)
{
delete(arg);
return new ITNode<Key> (k);
}
if(k == arg->key)
return arg;
if(arg->compareNode(k)) {
if(arg->lesser->key == NULL) {
delete(arg->lesser);
arg->lesser = new ITNode<Key> (k);
} else {
arg->lesser = insertKey(arg->lesser, k);
}
arg->updateHeight();
arg->accum += k->val;
arg->updateTreeMax();
if(arg->greater == NULL || /*arg->lesser->height > arg->greater->height + 1*/ arg->getBalance() == 2) {
if(arg->greater == NULL || /*arg->lesser->lesser->height > arg->lesser->greater->height*/ arg->lesser->getBalance() == 1) {
return arg->rotateRight();
} else {
arg->lesser = arg->lesser->rotateLeft();
return arg->rotateRight();
}
} else {
return arg;
}
} else {
if(arg->greater->key == NULL) {
delete(arg->greater);
arg->greater = new ITNode<Key> (k);
} else {
arg->greater = insertKey(arg->greater, k);
}
arg->updateHeight();
arg->updateTreeMax();
if(arg->lesser == NULL || /*arg->greater->height > arg->lesser->height + 1*/ arg->getBalance() == -2) {
if(arg->lesser == NULL || /*arg->greater->lesser->height < arg->greater->greater->height*/ arg->greater->getBalance() == -1) {
return arg->rotateLeft();
} else {
arg->greater = arg->greater->rotateRight();
return arg->rotateLeft();
}
} else {
return arg;
}
}
}
/* ????????? ? ??????? ????? */
void insertKey(keyType key, data x, struct tree **T)
{ if (NULL == *T) {
*T = (struct tree *) malloc(sizeof(**T));
(*T)->key = key;
(*T)->info = x;
(*T)->left = NULL;
(*T)->right = NULL;
}
else if (key < (*T)->key)
insertKey(key, x, &(*T)->left);
else if (key > (*T)->key)
insertKey(key, x, &(*T)->right);
else
fprintf(stderr, "????????? ? ???? ? ???????!\n");
}
int main()
{
HashTable H;
H = initializeTable(353);
int i;
int key;
Position P;
////insertKey(1,H);
//insertKey(2,H);
//insertKey(3,H);
////deleteKey(1,H);
//deleteKey(2,H);
//deleteKey(3,H);
for(i=0; i<100; i++)
{
key = i;
insertKey(key, H);
}
//deleteKey(100, H);
//for(i=99; i>=0; i--)
// deleteKey(i, H);
P = FindKey(6,H);
printf("Index %d is found\n",P);
PrintHashTable(H);
DestroyTable(H);
std::cout<<std::endl;
}
int insert(int offset, long long key) {
long long key_promoted = -1;
int return_value = -1;
int new_offset = -1;
int offset_child_right = -1;
int offset_child_left = -1;
page_tree *page;
// verifica se eh necessario criar um novo no raiz
if ((return_value = insertKey(offset, key, &offset_child_left, &offset_child_right, &key_promoted)) == PROMOTED) {
// aloca nova pagina na ram
allocPage(&page);
// insere chave na nova pagina criada (ainda na RAM)
pageInsert(page, key_promoted, offset_child_left, offset_child_right);
//emanuel
page->child[0] = offset_left;
page->child[0] = offset_child_left;
// move o ponteiro para o final do arquivo para pegar a posicao da nova pagina
fseek(bTreeFile, 0L, SEEK_END);
new_offset = ftell(bTreeFile);
// salva a pagina no disco
savePage(new_offset, page);
update_root_offset(new_offset);
free(page);
}
return return_value;
}
void MapVariant::merge(const VectorVariant * vec, ArrayOp op) {
const HphpVector<Variant*> &elems = vec->getElems();
unsigned int size = elems.size();
if (op == Plus) {
m_elems.reserve(m_elems.size() + size);
for (unsigned int i = 0; i < size; i++) {
Variant key((int64)i);
int index = getIndex(key);
if (index < 0) {
insertKey(key);
Variant * elem;
ArrayFuncs::element(elem, elems[i]);
m_elems.push_back(elem);
}
}
} else {
ASSERT(op == Merge);
for (unsigned int i = 0; i < size; i++) {
appendKey();
Variant * elem;
ArrayFuncs::element(elem, elems[i]);
m_elems.push_back(elem);
}
}
}
bool insertKey(TreeNodePtr node, TreeItemPtr key){
assert(node != NULL && key != NULL);
int pos = getItemOrNext(node, key->key);
bool keyFound = isKeyFound(node, pos, key->key);
if(keyFound){
node->items[pos]->data = key->data;
return false;
}
if(isLeaf(node)){
addKey(node, pos, key);
return true;
}
if(node->nodes[pos]->keyCount == MAX_KEY_COUNT){
if(!splitChild(node, pos)) return false;
//after we splitted, a chance, that a key
//added in node is less then a new key, is apperaring
assert(node->items[pos] != NULL);
if(node->items[pos]->key < key->key) pos++;
assert(pos == node->keyCount || node->items[pos]->key > key->key);
}
bool res = insertKey(node->nodes[pos], key);
if(res) node->subtreeKeyCount[pos]++;
return res;
}
void replaceSel(FILE* fw, int data[], int len)
{
int index, keyVal;
int runNum = 1;
bufferNode BUFFER[BUFSIZE]={'\0',};
// 버퍼에서 BUFSIZE만큼 레코드 판독
for(index=0; index<BUFSIZE; index++)
{
BUFFER[index].key = data[index];
BUFFER[index].state = 0;
}
// 정렬 시작
fprintf(fw, "Run%d: ", runNum);
while(1)
{
if(checkFrozen(BUFFER) == -2) { // 버퍼가 완전히 비어있는경우
fprintf(fw, "\n*"); // 다음줄에 *출력후 종료
break;
}
else if(checkFrozen(BUFFER) == -1) { // 버퍼가 완전히 프로즌된 경우
breakFrozen(BUFFER); // 프로즌 해제후 다음 런 생성
fprintf(fw, "\n");
fprintf(fw, "Run%d: ", ++runNum);
}
keyVal = popLeastKey(BUFFER);
fprintf(fw, "%d ", keyVal);
if(index<len) // 남은데이터가 있으면 데이터 추가 삽입
insertKey(BUFFER, data[index++]);
}
}
int main(void) {
struct tree *T = NULL, *result;
int i;
/* ??????? 10 ????? ? ?????????? ??????? */
for (i = 0; i < 10; i++) {
int ikey = (rand() % 20) + 1;
printf("?????? ?? ??????? ? ???? %d \n", ikey);
insertKey(ikey, "someinfo", &T);
}
printf("?????: ");
printTree(T);
printf("\n");
/* ????????? ?? ???????? ? ???? 5 */
result = search(5, T);
printf("??????? ?: %s\n", result->info);
/* ??????? ?????????? 10 ????? ?? ??????? */
for (i = 0; i < 10; i++) {
int ikey = (rand() % 20) + 1;
printf("??????? ?? ???????? ? ???? %d \n", ikey);
deleteKey(ikey, &T);
}
printf("?????: ");
printTree(T);
printf("\n");
return 0;
}
int main()
{
const int size(1000);
for(int _i_ = 0; _i_ < 2000; _i_++) {
int t[size], z(0);
srand(time(0));
ITNode<int>* head = new ITNode<int>(&z);
for(int i = 1; i < size; i++) {
//std::cout << *head << "\n---\n";
t[i] = rand() % (2 * size);
head = insertKey(head, t + i);
if(!head->is_AVL())
{
std::cout << *head << "\n";
return 255;
}
}
for(int i = 1; i < size/2; i++) {
int j = rand() % size;
head = deleteKey(head, t + j);
//std::cout << *head << "\n---\n";
if(!head->is_AVL())
{
std::cout << *head << "\n";
return 255;
}
}
//std::cout << *head << "\n";
delete(head);
assert(voidNodeNr == 0);
assert(keyNodeNr == 0);
// std::cout << voidNodeNr << " " << keyNodeNr << "\n";
}
}
ITNode<Key>* insertKey(ITNode<Key>* arg, Key * k)
{
//std::cout << "Inserting.. " << *k << " to " << *arg << "\n";
if(k == arg->key)
return arg;
if(*k < * (arg->key)) {
if(arg->lesser->key == NULL) {
delete(arg->lesser);
arg->lesser = new ITNode<Key> (k);
} else {
arg->lesser = insertKey(arg->lesser, k);
}
arg->updateHeight();
if(arg->greater == NULL || /*arg->lesser->height > arg->greater->height + 1*/ arg->getBalance() == 2) {
if(arg->greater == NULL || /*arg->lesser->lesser->height > arg->lesser->greater->height*/ arg->lesser->getBalance() == 1) {
return arg->rotateRight();
} else {
arg->lesser = arg->lesser->rotateLeft();
return arg->rotateRight();
}
} else {
return arg;
}
} else {
if(arg->greater->key == NULL) {
delete(arg->greater);
arg->greater = new ITNode<Key> (k);
} else {
arg->greater = insertKey(arg->greater, k);
}
arg->updateHeight();
if(arg->lesser == NULL || /*arg->greater->height > arg->lesser->height + 1*/ arg->getBalance() == -2) {
if(arg->lesser == NULL || /*arg->greater->lesser->height < arg->greater->greater->height*/ arg->greater->getBalance() == -1) {
return arg->rotateLeft();
} else {
arg->greater = arg->greater->rotateRight();
return arg->rotateLeft();
}
} else {
return arg;
}
}
}
bool insertKeyInTree(TreePtr tree, TreeItemPtr item){
if(NULL == tree) return false;
assert(tree->root != NULL && item != NULL);
if(MAX_KEY_COUNT != tree->root->keyCount)
return insertKey(tree->root, item);
TreeNodePtr newRoot = newTreeNode(0, NULL, false), oldRoot = tree->root;
//newTreeNode also sets childCount to 1, so the following line fixes it
newRoot->childCount = 0;
oldRoot->parent = newRoot;
tree->root = newRoot;
addNode(newRoot, oldRoot, subforestKeyCount(oldRoot), 0);
splitChild(newRoot, 0);
return insertKey(tree->root, item);
}
void writeToScreen(char key,int fd){
int size;
int * pos;
if(fd==STDOUT){
vidmem=(char *)MAIN_SCREEN_ADDRESS;
size= MAIN_SCREEN_SIZE;
if(writepos == size){
scrollMainScreen();
}
insertKey(key,&writepos,vidmem);
set_cursor(getrow(),getcol());
}else if(fd==REGOUT){
vidmem=(char *)VIDMEM_ADDRESS;
size= (UPPER_SCREEN_SIZE)-(LINE_SIZE);
if(upperWritepos == size){
upperWritepos = 0;
}
insertKey(key,&upperWritepos,vidmem);
}
}
int insertKey(int offset, long long key, int* child_left_promoted, int* child_right_promoted, long long* key_promoted)
{
page_tree *curr_page; // pagina atual para busca
page_tree *new_page; // pagina para split
int pos = -1; // posicao em que a chave deveria ser inserida
// trata o caso de arvore vazia
if (offset == NIL) {
*key_promoted = key;
*child_right_promoted = NIL;
*child_left_promoted = NIL;
return PROMOTED;
}
curr_page = loadPage(offset); // carrega a pagina para inspecao
if (pageSearch(curr_page, key, &pos) == SUCCESS) {
fprintf(stderr, "Chave ja existe na arvore\n\n");
return ERROR;
}
int return_value = -1;
int right_offset_child_promoted = -1;
int left_offset_child_promoted = -1;
long long key_promotion = -1;
return_value = insertKey(curr_page->child[pos], key, &left_offset_child_promoted, &right_offset_child_promoted, &key_promotion);
// verifica se nao eh necessaria mais nenhuma operacao na arvore
// ou seja, a chave foi inserida mas nao ha promocao
// ou entao a chave ja existia e foi retornado um erro
if (return_value == NOT_PROMOTED || return_value == ERROR) {
return return_value;
}
// verifica se a chave cabe na pagina atual
if (curr_page->nKeys < ORDER-1) {
pageInsert(curr_page, key_promotion, left_offset_child_promoted, right_offset_child_promoted);
savePage(offset, curr_page);
return NOT_PROMOTED;
}
// se a chave nao couber na pagina, realiza split
//fprintf(stderr, "chamando split... offset vale %d e chave vale %lld\n", offset, key_promotion);
split(key_promotion, right_offset_child_promoted, curr_page, key_promoted, child_left_promoted, child_right_promoted, &new_page);
*child_left_promoted = offset;
savePage(offset, curr_page); // salva a pagina atual
savePage(*child_right_promoted, new_page); // salva a nova pagina apos split
free(curr_page);
free(new_page);
return PROMOTED;
}
// Look up the object for the given index. If an object at the given index
// doesn't exist, it will be allocated.
T& operator[](size_t idx)
{
auto iter = lookupKey(idx);
if(iter == mIdxLookup.cend())
{
iter = insertKey(idx).first;
idx = std::distance(mIdxLookup.cbegin(), iter);
return *mData.insert(mData.begin()+idx, T());
}
return mData[std::distance(mIdxLookup.cbegin(), iter)];
}
/**
Adds item to search arrays. Adding is done so that arrays are always sorted.
If added element would overlap a previously found element, it is not added.
@param aStartPos Start position of the found item
@param aLength Length of found item
@param aType Type of the found item
@leave KErrNone, if successful; otherwise one of the other system-wide error codes.
*/
void CTulAddressStringTokenizer::AddItemL(TInt aStartPos, TInt aLength, TTokenizerSearchCase aType )
{
// Create item element
SFoundItem foundItem;
foundItem.iStartPos = aStartPos;
foundItem.iLength = aLength;
foundItem.iItemType = aType;
// Add item data to arrays
TKeyArrayFix insertKey(0, ECmpTInt);
iFoundItems->InsertIsqAllowDuplicatesL(foundItem, insertKey);
}
std::pair<iterator,bool> insert(size_t idx, T&& obj)
{
auto ins = insertKey(idx);
if(ins.second)
{
idx = std::distance(mIdxLookup.cbegin(), ins.first);
mData.insert(mData.begin()+idx, std::move(obj));
return std::make_pair(mData.begin()+idx, true);
}
idx = std::distance(mIdxLookup.cbegin(), ins.first);
return std::make_pair(mData.begin()+idx, false);
}
ArrayData *MapVariant::set(CVarRef k, CVarRef v, bool copy,
int64 prehash /* = -1 */) {
if (copy) {
return NEW(MapVariant)(this, k, v);
}
uint index = insertKey(k, prehash);
if (index < m_elems.size()) {
*m_elems[index] = v;
} else {
m_elems.push_back(ArrayFuncs::element(v));
}
return NULL;
}
void SystemKeys::configureSystemKeys()
{
XUngrabKey(QX11Info::display(), AnyKey, AnyModifier, QX11Info::appRootWindow(QX11Info::appScreen()));
createModifiers(QX11Info::display());
//List of keys to add
insertKey(XK_c,Mod1Mask|ControlMask,KEY_CLOSE_WINDOW);
insertKey(XK_t,ControlMask,KEY_ALT_TAB);
insertKey(XK_Return,Mod1Mask|ControlMask,KEY_OPEN_TERMINAL);
//Don't edit below here
for (std::map<unsigned int, std::map<unsigned int, key_events> >::iterator k =key_list.begin(); k!= key_list.end(); k++)
{
for (std::map<unsigned int, key_events>::iterator m = k->second.begin();m != k->second.end();m++)
{
//we transform the key to the value Xlib returns
qDebug() << "Adding key to key list: " << k->first << ": " << m->first;
addKey(k->first,m->first);
}
}
}
void
testPrintTree(void)
{
RID insert[] = {
{1,1},
{2,3},
{1,2},
{3,5},
{4,4},
{3,2},
};
int numInserts = 6;
Value **keys;
char *stringKeys[] = {
"i1",
"i11",
"i13",
"i17",
"i23",
"i52"
};
testName = "test b-tree print";
int i, testint;
BTreeHandle *tree = NULL;
keys = createValues(stringKeys, numInserts);
// init
TEST_CHECK(initIndexManager(NULL));
TEST_CHECK(createBtree("testidx", DT_INT, 2));
TEST_CHECK(openBtree(&tree, "testidx"));
printf("0"); // remove it later
// insert keys
for(i = 0; i < numInserts; i++)
TEST_CHECK(insertKey(tree, keys[i], insert[i]));
char * expected = "(0)[1,13,2,23,3]\n(1)[1.1,1,2.3,11,2]\n(2)[1.2,13,3.5,17,3]\n(3)[4.4,23,3.2,52]\n";
//test printTree function
ASSERT_EQUALS_STRING(expected,printTree(tree),"checking b-tree shape"); \
// cleanup
TEST_CHECK(closeBtree(tree));
TEST_CHECK(deleteBtree("testidx"));
TEST_CHECK(shutdownIndexManager());
freeValues(keys, numInserts);
TEST_DONE();
}
MapVariant::MapVariant(const VectorVariant *src, CVarRef k, CVarRef v) :
m_nextIndex(0), m_keys(NULL) {
ASSERT(src);
ASSERT(src->getIndex(k) < 0);
const HphpVector<Variant *> &srcElems = src->getElems();
m_nextIndex = srcElems.size();
for (int i = 0; i < m_nextIndex; i++) {
m_map[Variant((int64)i)] = i;
}
m_elems.reserve(m_nextIndex + 1);
ArrayFuncs::append(m_elems, srcElems);
insertKey(k.toKey());
m_elems.push_back(ArrayFuncs::element(v));
}
void MapVariant::merge(const MapVariant *srcMap, ArrayOp op) {
const HphpVector<Variant*> &elems = srcMap->m_elems;
const std::vector<Variant> &keys = srcMap->getKeyVector();
unsigned int size = keys.size();
if (op == Plus) {
m_elems.reserve(m_elems.size() + elems.size());
for (unsigned int i = 0; i < size; i++) {
CVarRef key = keys[i];
int index = getIndex(key);
if (index < 0) {
insertKey(key);
Variant * elem;
ArrayFuncs::element(elem, elems[i]);
m_elems.push_back(elem);
}
}
} else {
ASSERT(op == Merge);
for (unsigned int i = 0; i < size; i++) {
CVarRef key = keys[i];
Variant * elem;
ArrayFuncs::element(elem, elems[i]);
if (key.isNumeric()) {
appendKey();
m_elems.push_back(elem);
} else {
int index = getIndex(key);
if (index < 0) {
insertKey(key);
m_elems.push_back(elem);
} else {
ArrayFuncs::set(m_elems, index, elem);
}
}
}
}
}
ArrayData *MapVariant::insert(ssize_t pos, CVarRef v, bool copy) {
if (pos >= size()) {
return append(v, false);
}
if (pos < 0) pos = 0;
if (copy) {
ArrayData* ret = NEW(MapVariant)(this);
ret->insert(pos, v, false);
return ret;
}
insertKey(pos);
m_elems.insert(pos, ArrayFuncs::element(v));
return NULL;
}
MapVariant::MapVariant(const MapVariant *src, CVarRef k, CVarRef v) :
m_nextIndex(0), m_keys(NULL) {
ASSERT(src);
m_map = src->m_map;
m_nextIndex = src->m_nextIndex;
int index = src->getIndex(k);
if (index >= 0) {
ArrayFuncs::append(m_elems, src->m_elems);
ArrayFuncs::set(m_elems, index, ArrayFuncs::element(v));
} else {
m_elems.reserve(src->m_elems.size() + 1);
ArrayFuncs::append(m_elems, src->m_elems);
insertKey(k.toKey());
m_elems.push_back(ArrayFuncs::element(v));
}
}
int main()
{
avltree *tree;
/*tree = mkNode( 5, 5,
mkNode( 3, 3,
mkNode( 1, 1,
NULL,
mkNode( 4, 4, NULL, NULL)),
NULL),
NULL);*/
//printBinTree( tree);
//freeBinTree( tree);
tree = NULL;
tree = insertKey( 9,1,tree);
tree = insertKey( 5,1,tree);
tree = insertKey( 10,1,tree);
tree = insertKey( 0,1,tree);
tree = insertKey( 6,1,tree);
tree = insertKey( 11,1,tree);
tree = insertKey(-1,1,tree);
tree = insertKey(1,1,tree);
tree = insertKey(2,1,tree);
tree = deleteKey(10,tree);
//tree = deleteKey(20,tree);
printBinTree(tree);
//tree = deleteKey( 5, tree);
//printBinTree( tree);
printf( "Value for key 10: %d\n", findKey( 10, tree));
printf( "Value for key 20: %d\n", findKey( 20, tree));
freeBinTree( tree);
return 0;
}
static void splitNode(BSTree* tree, BSNode* node)
{
int m = (int)ceil((float)node->keyNum / 2);
int mKey = node->keys[m];
void* mValue = node->values[m];
BSNode* nNode = _initNode(tree->mOrder);
int j = 0, i = 0;
for(i = m + 1; i <= node->keyNum; ++i) {
++j;
nNode->keys[j] = node->keys[i];
nNode->values[j] = node->values[i];
nNode->children[j] = node->children[i];
if (node->children[i])
node->children[i]->parent = nNode;
node->keys[i] = INT_MIN;
node->values[i] = NULL;
node->children[i] = NULL;
}
nNode->children[0] = node->children[m];
if (nNode->children[0])
nNode->children[0]->parent = nNode;
nNode->keyNum = j;
node->keys[m] = INT_MIN;
node->children[m] = NULL;
node->values[m] = NULL;
node->keyNum = m - 1;
BSNode* p = node->parent;
if (p) {
insertKey(p, mKey, mValue, nNode);
nNode->parent = p;
if (p->keyNum > tree->mOrder -1)
splitNode(tree, p);
}
else {
BSNode* nNode2 = initNode(tree->mOrder, mKey, mValue);
nNode2->children[0] = node;
nNode2->children[1] = nNode;
node->parent = nNode2;
nNode->parent = nNode2;
tree->root = nNode2;
}
}
void video_tab(int fd){
int i=0;
int size=0;
int * pos;
if(fd==STDOUT){
vidmem=(char *)MAIN_SCREEN_ADDRESS;
size=MAIN_SCREEN_SIZE;
pos=&writepos;
}else if(fd==REGOUT){
vidmem=(char *)VIDMEM_ADDRESS;
size=UPPER_SCREEN_SIZE;
pos=&upperWritepos;
}
for(i=0; i<TAB_LENGTH && i<size; i++){
insertKey(' ',pos, vidmem);
}
if(fd==STDOUT){
set_cursor(getrow(),getcol());
}
}
ArrayData *MapVariant::lval(CVarRef k, Variant *&ret, bool copy,
int64 prehash /* = -1 */) {
if (copy) {
MapVariant* data = NEW(MapVariant)(this);
ArrayData* data2 = data->lval(k, ret, false, prehash);
if (data2) {
data->release();
return data2;
}
return data;
}
ssize_t index = insertKey(k, prehash);
if (index >= m_elems.size()) {
ret = NEW(Variant)();
m_elems.push_back(ret);
} else {
ret = m_elems[index];
}
return NULL;
}
/******************************************************************************
* Moves the keys in the given set by the given time shift.
******************************************************************************/
void KeyframeController::moveKeys(const QVector<AnimationKey*> keysToMove, TimePoint shift)
{
if(shift == 0)
return;
// First, remove the selected keys from the controller.
QVector<OORef<AnimationKey>> removedKeys;
for(AnimationKey* key : keysToMove) {
int index = keys().indexOf(key);
if(index >= 0) {
removedKeys.push_back(key);
_keys.remove(index);
}
}
// Change times and re-insert keys into the controller.
for(const OORef<AnimationKey>& key : removedKeys) {
key->setTime(key->time() + shift);
insertKey(key.get());
}
updateKeys();
}
MapVariant::MapVariant(const VectorVariant *src, CVarRef k, CVarRef v,
bool copy) {
ASSERT(src);
ASSERT(src->getIndex(k) < 0);
const HphpVector<Variant *> &srcElems = src->getElems();
m_nextIndex = srcElems.size();
for (int i = 0; i < m_nextIndex; i++) {
m_map[Variant((int64)i)] = i;
}
// Called by VectorVariant::setImpl(): special escalation that will NOT
// make a copy of array elements if copy is not requested
m_elems.reserve(m_nextIndex + 1);
if (copy) {
appendImpl(m_elems, src->getElems(), k, ArrayFuncs::element(v));
} else {
m_elems.append(srcElems);
insertKey(k);
m_elems.push_back(ArrayFuncs::element(v));
}
}
