void IRKE::traverse_path(KmerCounter &kcounter, Kmer_Occurence_Pair seed_kmer, Kmer_visitor &visitor,
Kmer_visitor &place_holder, float MIN_CONNECTIVITY_RATIO, unsigned int depth)
{
if (IRKE_COMMON::MONITOR >= 3) {
cerr << "traverse_path, depth: " << depth << ", kmer: " << kcounter.get_kmer_string(seed_kmer.first) << endl;
}
// check to see if visited already
if (visitor.exists(seed_kmer.first)) {
// already visited
if (IRKE_COMMON::MONITOR >= 3) {
cout << "\talready visited " << kcounter.get_kmer_string(seed_kmer.first) << endl;
}
return;
}
// check if at the end of the max recursion, and if so, don't visit it but set a placeholder.
if (depth > MAX_RECURSION) {
place_holder.add(seed_kmer.first);
return;
}
visitor.add(seed_kmer.first);
// try each of the forward paths from the kmer:
vector<Kmer_Occurence_Pair> forward_candidates = kcounter.get_forward_kmer_candidates(seed_kmer.first);
for (unsigned int i = 0; i < forward_candidates.size(); i++) {
Kmer_Occurence_Pair kmer = forward_candidates[i];
if (kmer.second && exceeds_min_connectivity(kcounter, seed_kmer, kmer, MIN_CONNECTIVITY_RATIO)) {
traverse_path(kcounter, kmer, visitor, place_holder, MIN_CONNECTIVITY_RATIO, depth + 1);
}
}
// try each of the reverse paths from the kmer:
vector<Kmer_Occurence_Pair> reverse_candidates = kcounter.get_reverse_kmer_candidates(seed_kmer.first);
for (unsigned int i = 0; i < reverse_candidates.size(); i++) {
Kmer_Occurence_Pair kmer = reverse_candidates[i];
if (kmer.second && exceeds_min_connectivity(kcounter, seed_kmer, kmer, MIN_CONNECTIVITY_RATIO)) {
traverse_path(kcounter, kmer, visitor, place_holder, MIN_CONNECTIVITY_RATIO, depth + 1);
}
}
return;
}
int main(int argc, char **argv) {
char ch;
int i;
int is_usage = 0;
int pid = 0;
const int INF = 0x3fffffff;
while((ch = getopt(argc, argv, "p:r:t:dlhi:c:f:e:o:")) != -1) {
switch(ch) {
case 'p': pid = atoi(optarg); break;
case 't': opt.path = strdup(optarg); break;
case 'i': opt.interval = atoi(optarg); break;
case 'c': opt.count = atoi(optarg); break;
case 'h': is_usage = 1; break;
case 'd': opt.is_detail = 1; break;
case 'l': opt.just_list_file = 1; break;
case 'r': opt.regular = strdup(optarg); break;
case 'f': opt.log_file = strdup(optarg); break;
case 'e': opt.log_level = atoi(optarg); break;
case 'o': opt.output_file = strdup(optarg); break;
}
}
if(is_usage || ( !pid && opt.path == NULL )) {
usage();
}
else if ( pid && opt.path != NULL) {
usage();
}
if(opt.count <= 0 && opt.interval <= 0) {
opt.count = 1;
} else if(opt.count <= 0 && opt.interval > 0) {
opt.count = INF;
} else if(opt.count > 0 && opt.interval <= 0) {
opt.interval = 1;
}
if(opt.log_level <= 0 ) {
opt.log_level = INFO;
}
for (i=0; i<opt.count; ++i){
if ( i ) {
sleep(opt.interval);
}
pid ? traverse_porcess(pid) : traverse_path(opt.path, 1);
}
free(opt.regular);
free(opt.log_file);
free(opt.output_file);
free(opt.path);
return 0;
}
int main()
{
struct tree_node *root;
int i = 1;
root = create_node();
traverse_path(root,traverse);
destroy_tree(root,destroy);
}
static void resolve(const struct traverse_info *info, struct name_entry *branch1, struct name_entry *result)
{
struct merge_list *orig, *final;
const char *path;
/* If it's already branch1, don't bother showing it */
if (!branch1)
return;
path = traverse_path(info, result);
orig = create_entry(2, branch1->mode, branch1->sha1, path);
final = create_entry(0, result->mode, result->sha1, path);
static void resolve(const struct traverse_info *info, struct name_entry *ours, struct name_entry *result)
{
struct merge_list *orig, *final;
const char *path;
/* If it's already ours, don't bother showing it */
if (!ours)
return;
path = traverse_path(info, result);
orig = create_entry(2, ours->mode, &ours->oid, path);
final = create_entry(0, result->mode, &result->oid, path);
int main()
{
struct tree_node *root;
struct tree_node *left, *right;
int i = 1,j=2,k=3;
root = create_tree_node(&i);
left = create_tree_node(&j);
right = create_tree_node(&k);
TREE_ADD(root, left, left);
TREE_ADD(root, right, right);
traverse_path(root,traverse);
destroy_tree(root,NULL);
}
/**
* Helper function. Get folder or file at start of path.
*/
int get_inode_from_path(struct file_system* lfs, const char *path,
struct inode* inode) {
int res = 0;
int found;
char* curr_path;
struct inode* node;
char* file_name;
printf("get_inode_from_path: path = %s\n", path);
if (!inode) {
inode = malloc(INODE_SIZE);
}
if (!inode) {
return -ENOMEM;
}
//printf("1\n");
if (strcmp(path, "/") == 0) {
res = get_root_inode(lfs, inode);
} else {
//printf("2\n");
file_name = malloc(FILE_NAME_LENGTH_MAX);
if (!file_name) {
res = -ENOMEM;
} else {
printf("3\n");
res = get_filename(path, file_name);
if (!res) {
//printf("get_inode_..: path = %s\n", path);
//printf("get_inode_from path: file_name = %s\n", file_name);
node = malloc(INODE_SIZE);
if (!node) {
res = -ENOMEM;
} else {
printf("4\n");
res = get_root_inode(lfs, node);
if (!res) {
printf("5\n");
curr_path = malloc(FILE_NAME_LENGTH_MAX * INODES_PR_LOG);
if (!curr_path) {
res = -ENOMEM;
} else {
printf("6\n");
found = 0;
memcpy(curr_path, path, strlen(path));
printf("7\n");
res = get_root_inode(lfs, node);
printf("get_inode_from_path: root inode has %d children\n",
node->number_of_children);
while (!res && !found) {
if (strcmp(node->file_name, file_name) == 0) {
found = 1;
} else {
printf("curr_path = %s, path = %s\n", curr_path, path);
res = traverse_path(lfs, curr_path, node, node, curr_path);
if (res == -ENOENT) {
printf("get_inode_from_path: no node with path: %s\n",
path);
}
}
}
if (found) {
inode = node;
res = 0;
} else {
res = -ENOENT;
}
free(curr_path);
}
}
free(node);
}
}
free(file_name);
}
}
//printf("get_inode_from_path: returns %d, inode number was: %d\n", res, node->inode_number);
return res;
}
int lfs_mkdir(const char *path, mode_t mode) {
int res = 0;
struct inode* node;
struct inode* parent;
char* name;
printf("%s\n", "lfs_mkdir");
node = malloc(INODE_SIZE);
if (!node) {
res = -ENOMEM;
} else {
if (get_inode_from_path(log_system, path, node) == 0) {
free(node);
printf("mkdir: dir exists\n");
return -EEXIST;
}
name = malloc(FILE_NAME_LENGTH_MAX);
if (!name) {
res = -ENOMEM;
} else {
//printf("mkdir: 1\n");
res = get_filename(path, name);
if (!res) {
//printf("mkdir: 2\n");
parent = malloc(INODE_SIZE);
if (!parent) {
res = -ENOMEM;
} else {
//printf("mkdir: 3\n");
res = get_root_inode(log_system, parent);
if (!res) {
//printf("mkdir: 4\n");
char* temp = malloc(strlen(path));
if (!temp) {
res = -ENOMEM;
} else {
//printf("mkdir: 5\n");
strcpy(temp, path);
while ((strcmp(temp, name) != 0) && (strcmp(temp + 1, name) != 0)
&& !res) {
//printf("mkdir: temp now = %s\n", temp);
res = traverse_path(log_system, temp, parent, node, temp);
if (!res) {
parent = node;
}
}
if (!res) {
printf("mkdir: 6\n");
printf("mkdir: parent is %s\n", parent->file_name);
node->inode_number = log_system->number_of_inodes
+ INODE_NUMBERS_MIN;
node->is_dir = 1;
memcpy(node->file_name, name, strlen(name));
node->number_of_blocks = 0;
//printf("mkdir: child is %s\n", node->file_name);
node->number_of_children = 0;
node->file_size = strlen(name);
memset(node->block_placements, 0, BLOCKS_PR_INODE);
memset(node->blocks_changed, 0, BLOCKS_PR_INODE);
//printf("mkdir: 9\n");
res = add_child_to_dir(log_system, parent, node);
//printf("mkdir: parent has %d children\n", parent->number_of_children);
}
free(temp);
}
}
}
}
free(name);
}
}
//printf("mkdir: returning %d\n", res);
return res;
}
