bool FileBrowser::renameInTree(generic_string rootPath, HTREEITEM node, std::vector<generic_string> linarPathArrayFrom, const generic_string & renameTo)
{
HTREEITEM foundItem = findInTree(rootPath, node, linarPathArrayFrom);
if (foundItem == nullptr)
return false;
// found it, rename it
_treeView.renameItem(foundItem, renameTo.c_str());
return true;
}
bool FileBrowser::deleteFromTree(generic_string rootPath, HTREEITEM node, std::vector<generic_string> linarPathArray)
{
HTREEITEM foundItem = findInTree(rootPath, node, linarPathArray);
if (foundItem == nullptr)
return false;
// found it, delete it
_treeView.removeItem(foundItem);
return true;
}
void FileBrowser::addRootFolder(generic_string rootFolderPath)
{
// make sure there's no '\' at the end
if (rootFolderPath[rootFolderPath.length() - 1] == '\\')
{
rootFolderPath = rootFolderPath.substr(0, rootFolderPath.length() - 1);
}
size_t nbFolderUpdaters = _folderUpdaters.size();
for (size_t i = 0; i < nbFolderUpdaters; ++i)
{
if (_folderUpdaters[i]->_rootFolder._rootPath == rootFolderPath)
return;
else
{
size_t pos = rootFolderPath.find(_folderUpdaters[i]->_rootFolder._rootPath);
if (pos == 0)
{
//do nothing, go down to select the dir
generic_string rootPath = _folderUpdaters[i]->_rootFolder._rootPath;
generic_string pathSuffix = rootFolderPath.substr(rootPath.size() + 1, rootFolderPath.size() - rootPath.size());
vector<generic_string> linarPathArray = split(pathSuffix, '\\');
HTREEITEM foundItem = findInTree(rootPath, nullptr, linarPathArray);
if (foundItem)
_treeView.selectItem(foundItem);
return;
}
pos = _folderUpdaters[i]->_rootFolder._rootPath.find(rootFolderPath);
if (pos == 0)
{
::MessageBox(_hParent, TEXT("A sub-folder of the folder you want to open exists.\rPlease remove it from the panel before you add this one."), rootFolderPath.c_str(), MB_OK);
return;
}
}
}
std::vector<generic_string> patterns2Match;
patterns2Match.push_back(TEXT("*.*"));
TCHAR *label = ::PathFindFileName(rootFolderPath.c_str());
TCHAR rootLabel[MAX_PATH];
lstrcpy(rootLabel, label);
size_t len = lstrlen(rootLabel);
if (rootLabel[len - 1] == '\\')
rootLabel[len - 1] = '\0';
FolderInfo directoryStructure(rootLabel, nullptr);
getDirectoryStructure(rootFolderPath.c_str(), patterns2Match, directoryStructure, true, false);
HTREEITEM hRootItem = createFolderItemsFromDirStruct(nullptr, directoryStructure);
_treeView.expand(hRootItem);
_folderUpdaters.push_back(new FolderUpdater(directoryStructure, this));
_folderUpdaters[_folderUpdaters.size() - 1]->startWatcher();
}
Value* valueFromName(char* name) {
Value* v;
List* vl;
vl = varlist;
do {
v = findInTree(vl->data, name);
vl = vl->next;
} while (v == NULL && vl != NULL);
if (v != NULL)
return v;
errmsgf("Variable named '%s' is not SET", name);
return NULL;
}
int main()
{
Tree * testTree;
int (*compare)(void *, void *, void*, void*);
void (*destroy)(void *);
compare = &comparePointer;
destroy = &destroyPointer;
testTree = createAVLTree(compare,destroy);
parseDirectory("testdir/", testTree);
findInTree(testTree, "file.c");
removeFromTree(testTree, "testdir/", "file.c");
destroyAVLTree(testTree);
return(0);
}
LocationID findInTree(treeNode *current, LocationID find){
if(find == current->ID){
if (current->prev == NULL)
return current->ID;
else if (current->prev->prev == NULL)
return current->prev->ID;
else if (current->prev->prev->prev == NULL)
return current->prev->prev->ID;
}
int i=0;
int toGo = NOWHERE;
while(i<current->sizeOfNext && toGo == NOWHERE){
toGo = findInTree(current->nextNodes[i], find);
i++;
}
return toGo;
}
LocationID searchTree(treeBase *Base, LocationID trailValue){
int i = 0;
int inTree = FALSE;
LocationID toGo = NOWHERE;
while(i< Base->sizeOfUsed && inTree == FALSE){
if(trailValue == Base->used[i])
inTree = TRUE;
i++;
}
if(inTree == FALSE){
return NOWHERE;
}
i=0;
while(i<Base->sizeOfNext && toGo == NOWHERE){
toGo = findInTree(Base->nextNodes[i], trailValue);
i++;
}
return toGo;
}
HTREEITEM FileBrowser::findInTree(generic_string rootPath, HTREEITEM node, std::vector<generic_string> linarPathArray)
{
if (node == nullptr) // it's a root. Search the right root with rootPath
{
// Search
if ((node = getRootFromFullPath(rootPath)) == nullptr)
return nullptr;
}
if (linarPathArray.size() == 1)
{
// Search
return findChildNodeFromName(node, linarPathArray[0]);
}
else
{
HTREEITEM childNodeFound = nullptr;
for (HTREEITEM hItemNode = _treeView.getChildFrom(node);
hItemNode != NULL && childNodeFound == nullptr;
hItemNode = _treeView.getNextSibling(hItemNode))
{
TCHAR textBuffer[MAX_PATH];
TVITEM tvItem;
tvItem.mask = TVIF_TEXT;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX_PATH;
tvItem.hItem = hItemNode;
SendMessage(_treeView.getHSelf(), TVM_GETITEM, 0, (LPARAM)&tvItem);
if (linarPathArray[0] == tvItem.pszText)
{
// search recursively the node for an action
linarPathArray.erase(linarPathArray.begin());
return findInTree(rootPath, hItemNode, linarPathArray);
}
}
return nullptr;
}
}
BoolExpr* evaluateBoolExpr(BoolExpr* be) {
int m, p, erroff, ovec[PCREOVECCOUNT];
double j, k, **n, *o;
char* c, *s, *t;
const char* err;
List* stack, *prop, *stackiter;
Value* v, *u, *w;
pcre *re;
re = NULL;
stack = be->stack;
for (m=0;stack->next && stack->next->next;m++)
stack = stack->next->next;
n = malloc((m+2)*sizeof(double*));
m = -1;
stack = newList();
o = NULL;
stackiter = be->stack;
while (stackiter) {
s = NULL;
t = NULL;
w = NULL;
v = NULL;
u = stackiter->data;
if (u->type == '|' || u->type == '&') {
addToListEnd(stack, n[m]);
addToListEnd(stack, u);
stackiter = stackiter->next;
continue;
}
n[++m] = calloc(1, sizeof(double));
if (u->type != 'b') {
v = evaluateValue(u);
w = v;
if (v == NULL) {
freeList(stack);
m++;
for (p=0;p<m;p++) {
free(n[p]);
}
free(n);
return NULL;
}
if (v->type == 's') {
s = v->data;
}
j = evaluateValueAsBool(v);
if (u->type != 'v')
freeValue(v);
} else {
j = evaluateValueAsBool(u);
}
if (isnan(j)) {
m++;
for (p=0;p<m;p++) {
free(n[p]);
}
free(n);
freeList(stack);
return NULL;
}
stackiter = stackiter->next;
if (j) *n[m] = 1;
if (!stackiter) {
break;
}
c = (char*)stackiter->data;
stackiter = stackiter->next;
if (c[0] == '|' || c[0] == '&') {
addToListEnd(stack, n[m]);
addToListEnd(stack, c);
continue;
}
n[++m] = calloc(1, sizeof(double));
u = stackiter->data;
if (u->type != 'b') {
v = evaluateValue(u);
if (v == NULL) {
freeList(stack);
m++;
for (p=0;p<m;p++) {
free(n[p]);
}
free(n);
return NULL;
}
if (v->type == 's') {
t = v->data;
}
if (u->type != 'v')
freeValue(v);
}
k = evaluateValueAsBool(stackiter->data);
if (isnan(k)) {
m++;
for (p=0;p<m;p++) {
free(n[p]);
}
free(n);
freeList(stack);
return NULL;
}
stackiter = stackiter->next;
if (c[0] == '~') {
if (w == NULL) {
continue;
}
s = valueToString(w);
t = valueToString(v);
re = pcre_compile(t, 0, &err, &erroff, NULL);
if (pcre_exec(re, NULL, s, strlen(s), 0, 0, ovec, PCREOVECCOUNT) > -1)
*n[m] = 1;
free(s);
free(t);
if (re) pcre_free(re);
continue;
}
if (c[0] == '?') {
if (w == NULL || v == NULL)
continue;
if (w->type == v->type) {
if (v->type != 'l' || ((List*)v->data)->data == NULL) {
*n[m] = 1;
continue;
}
prop = ((List*)((List*)v->data)->data)->next;
while (prop != NULL) {
if (!findInTree(((List*)((List*)w->data)->data)->data, ((Variable*)prop->data)->name))
break;
prop = prop->next;
}
if (prop == NULL)
*n[m] = 1;
}
}
if (t != NULL && s != NULL) {
if (s == t && c[0] == '=') {
*n[m] = 1;
continue;
}
for (p=0;s[p] != '\0' && s[p] == t[p];p++);
if ((c[0] == '<' && s[p] < t[p]) || (c[0] == '>' && s[p] > t[p]))
*n[m] = 1;
continue;
}
p = 0;
if (c[0] == '=') {
if (fabs(j) < IOTA) {
if (j < 0)
j = -0.0;
else
j = 0.0;
}
if (fabs(k) < IOTA) {
if (k < 0)
k = -0.0;
else
k = 0.0;
}
}
if (j>k) {
if (j<=0.0) {
if (fabs((j-k)/k)>=EPSILON)
p = 1;
} else {
if (fabs((j-k)/j)>=EPSILON)
p = 1;
}
} else {
if (k<=0.0) {
if (fabs((k-j)/j)>=EPSILON)
p = -1;
} else {
if (fabs((k-j)/k)>=EPSILON)
p = -1;
}
}
if ((c[0] == '<' && p<0) || (c[0] == '>' && p>0) || (c[0] == '=' && !p)) {
*n[m] = 1;
}
}
if (m > -1)
o = n[m];
if (stack->data && m > -1) {
addToListEnd(stack, n[m]);
}
m++;
stackiter = NULL;
if (stack->data)
stackiter = stack;
while (stackiter) {
j = *(double*)stackiter->data;
if (!(stackiter->next)) {
o = (double*)stackiter->data;
if (j) *o = 1; else *o = 0;
break;
}
stackiter = stackiter->next;
c = stackiter->data;
stackiter = stackiter->next;
o = (double*)stackiter->data;
k = *o;
if (((j && k) && c[0] == '&') || ((j || k) && c[0] == '|'))
*o = 1;
else
*o = 0;
}
if (o == NULL)
be->lasteval = 1;
else
be->lasteval = *o;
for (p=0;p<m;p++) {
free(n[p]);
}
free(n);
freeList(stack);
if (be->neg) be->lasteval = !be->lasteval;
return be;
}
int testBinarySearchTree(void) {
Tree *head = NULL;
Tree *singleNodeTree = malloc(sizeof(Tree));
Tree *test[2];
if(singleNodeTree == NULL) {
exit(EXIT_FAILURE);
}
singleNodeTree->value = 100;
singleNodeTree->left = NULL;
singleNodeTree->right = NULL;
printf("Start Test of Binary Search Tree.\n");
printf("Initial contents of the tree:\n");
print_ascii_tree(head);
printf("\nadd() 5 to the tree\n");
head = addToTree(head, 5);
print_ascii_tree(head);
printf("\nadd() 2 to the tree\n");
head = addToTree(head, 2);
print_ascii_tree(head);
printf("\nadd() 12 to the tree\n");
head = addToTree(head, 12);
print_ascii_tree(head);
printf("\nadd() 1 to the tree\n");
head = addToTree(head, 1);
print_ascii_tree(head);
printf("\nadd() 8 to the tree\n");
head = addToTree(head, 8);
print_ascii_tree(head);
printf("\nadd() 4 to the tree\n");
head = addToTree(head, 4);
print_ascii_tree(head);
printf("\nadd() 3 to the tree\n");
head = addToTree(head, 3);
print_ascii_tree(head);
printf("\nadd() 10 to the tree\n");
head = addToTree(head, 10);
print_ascii_tree(head);
printf("\nadd() 9 to the tree\n");
head = addToTree(head, 9);
print_ascii_tree(head);
printf("\nadd() 11 to the tree\n");
head = addToTree(head, 11);
print_ascii_tree(head);
printf("\nadd() 7 to the tree\n");
head = addToTree(head, 7);
print_ascii_tree(head);
if( (test[0] = findInTree(head, 3)) == NULL) {
printf("\nfind(3) = Value Not Found\n");
} else {
printf("\nfind(3) = %d\n", test[0]->value);
}
if( (test[0] = findInTree(head, 7)) == NULL) {
printf("\nfind(7) = Value Not Found\n");
} else {
printf("\nfind(7) = %d\n", test[0]->value);
}
if( (test[0] = findInTree(head, 4)) == NULL) {
printf("\nfind(4) = Value Not Found\n");
} else {
printf("\nfind(4) = %d\n", test[0]->value);
}
findParentInTree(head, head, 3, test);
if( test[1] == NULL) {
printf("\nfindParentOfNode(3) = Value Not Found\n");
} else {
printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value);
}
findParentInTree(head, head, 5, test);
if( test[1] == NULL) {
printf("\nfindParentOfNode(5) = Value Not Found\n");
} else {
printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value);
}
findParentInTree(head, head, 2, test);
if( test[1] == NULL) {
printf("\nfindParentOfNode(2) = Value Not Found\n");
} else {
printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value);
}
findParentInTree(head, head, 9, test);
if( test[1] == NULL) {
printf("\nfindParentOfNode(9) = Value Not Found\n");
} else {
printf("\nfindParentOfNode(%d) = %d\n", test[0]->value, test[1]->value);
}
printf("Depth of the tree = %d\n", getTreeDepth(head, 0));
inOrderTraversal(head);
preOrderTraversal(head);
postOrderTraversal(head);
breadthFirstSearch(head);
/* Delete Order: 1, 3, 12, 8, 5 */
printf("\nbefore removing any items\n");
print_ascii_tree(head);
printf("\nremove() 1 from the tree\n");
head = removeFromTree(head, 1);
print_ascii_tree(head);
printf("\nremove() 3 from the tree\n");
head = removeFromTree(head, 3);
print_ascii_tree(head);
printf("\nremove() 12 from the tree\n");
head = removeFromTree(head, 12);
print_ascii_tree(head);
printf("\nremove() 8 from the tree\n");
head = removeFromTree(head, 8);
print_ascii_tree(head);
printf("\nremove() 5 from the tree\n");
head = removeFromTree(head, 5);
print_ascii_tree(head);
printf("\nremove() 11 from the tree\n");
head = removeFromTree(head, 11);
print_ascii_tree(head);
printf("Depth of the tree = %d\n", getTreeDepth(head, 0));
inOrderTraversal(head);
breadthFirstSearch(head);
printf("\nsinglNodeTests start here: \n");
print_ascii_tree(singleNodeTree);
inOrderTraversal(singleNodeTree);
printf("\n remove() 1 from tree\n");
if(removeFromTree(singleNodeTree, 1) == NULL) {
printf("Node Not Found, nothing removed\n");
}
printf("Depth of the singleNodeTree = %d\n", getTreeDepth(singleNodeTree, 0));
printf("\n remove() 100 from tree\n");
singleNodeTree = removeFromTree(singleNodeTree, 100);
printf("Depth of the singleNodeTree = %d\n", getTreeDepth(singleNodeTree, 0));
return EXIT_SUCCESS;
}
