static int
tree_compare_entry(const struct line *line1, const struct line *line2)
{
if (line1->type != line2->type)
return line1->type == LINE_DIRECTORY ? -1 : 1;
return strcmp(tree_path(line1), tree_path(line2));
}
int main(int argc, char** argv)
{
if (argc != 3)
{
printf("Usage: ./read tree file\n");
return 0;
}
std::string tree_path(argv[1]);
std::string filename(argv[2]);
// read file from storage
printf("reading data from storage\n");
megatree::ByteVec data;
boost::shared_ptr<megatree::Storage> mystorage = megatree::openStorage(tree_path);
mystorage->get(filename, data);
// write bytevec into file
printf("writing data to file\n");
boost::iostreams::mapped_file_params params;
params.path = filename;
params.mode = std::ios_base::out;
params.offset = 0;
params.new_file_size = data.size();
boost::iostreams::mapped_file file(params);
memcpy(file.data(), (void*)&data[0], data.size());
file.close();
return 0;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
printf("Usage: ./write tree file\n");
return 0;
}
std::string tree_path(argv[1]);
std::string filename(argv[2]);
// safety
if (filename != "metadata.ini" && filename != "views.ini" )
{
printf("For now write is restricted to metadata.ini\n");
return 0;
}
// read file into bytevec
boost::iostreams::mapped_file file(filename);
megatree::ByteVec data(file.size());
memcpy((void*)&data[0], file.const_data(), file.size());
file.close();
// write file to storage
printf("Opening storage for writing\n");
boost::shared_ptr<megatree::Storage> mystorage = megatree::openStorage(tree_path);
printf("Opened storage for writing\n");
mystorage->put(filename, data);
printf("Wrote file from disk to hbase\n");
return 0;
}
static void
tree_select(struct view *view, struct line *line)
{
struct tree_entry *entry = line->data;
if (line->type == LINE_HEADER) {
string_format(view->ref, "Files in /%s", view->env->directory);
return;
}
if (line->type == LINE_DIRECTORY && tree_path_is_parent(entry->name)) {
string_copy(view->ref, "Open parent directory");
view->env->blob[0] = 0;
return;
}
if (line->type == LINE_FILE) {
string_copy_rev(view->env->blob, entry->id);
string_format(view->env->file, "%s%s", view->env->directory, tree_path(line));
}
string_copy_rev(view->ref, entry->id);
}
static enum request
tree_request(struct view *view, enum request request, struct line *line)
{
enum open_flags flags;
struct tree_entry *entry = line->data;
switch (request) {
case REQ_VIEW_BLAME:
if (line->type != LINE_FILE) {
report("Blame only supported for files");
return REQ_NONE;
}
string_copy(view->env->ref, view->vid);
return request;
case REQ_EDIT:
if (line->type != LINE_FILE) {
report("Edit only supported for files");
} else if (!is_head_commit(view->vid)) {
open_blob_editor(entry->id, entry->name, 0);
} else {
open_editor(view->env->file, 0);
}
return REQ_NONE;
case REQ_PARENT:
case REQ_BACK:
if (!*view->env->directory) {
/* quit view if at top of tree */
return REQ_VIEW_CLOSE;
}
/* fake 'cd ..' */
pop_tree_stack_entry(&view->pos);
reload_view(view);
break;
case REQ_ENTER:
break;
default:
return request;
}
/* Cleanup the stack if the tree view is at a different tree. */
if (!*view->env->directory)
reset_view_history(&tree_view_history);
switch (line->type) {
case LINE_DIRECTORY:
/* Depending on whether it is a subdirectory or parent link
* mangle the path buffer. */
if (tree_path_is_parent(entry->name) && *view->env->directory) {
pop_tree_stack_entry(&view->pos);
} else {
const char *basename = tree_path(line);
push_tree_stack_entry(view, basename, &view->pos);
}
/* Trees and subtrees share the same ID, so they are not not
* unique like blobs. */
reload_view(view);
break;
case LINE_FILE:
flags = view_is_displayed(view) ? OPEN_SPLIT : OPEN_DEFAULT;
open_blob_view(view, flags);
break;
default:
return REQ_NONE;
}
return REQ_NONE;
}
bool
edit_cursor_rep::cursor_move_sub (SI& x0, SI& y0, SI& d0, SI dx, SI dy) {
path sp= find_innermost_scroll (eb, tp);
searching_forwards= dx == 1 || dy == -1;
int i,d;
path ref_p= tree_path (sp, x0, y0, d0);
if (ref_p != tp) {
tp= ref_p;
return true;
}
// cout << "ref_p = " << ref_p << "\n";
if (ref_p == tree_path (sp, x0, y0, d0+ dx*DELTA)) {
for (i=1; i<DELTA; i=i<<1)
if (ref_p != tree_path (sp, x0+ dx*i, y0+ dy*i, d0+ dx*DELTA))
break;
if (i>=DELTA) return false;
for (d=i>>2; d>=1; d=d>>1)
if (ref_p != tree_path (sp, x0+ dx*(i-d), y0+ dy*(i-d), d0+ dx*DELTA))
i-=d;
x0 += dx*i;
y0 += dy*i;
}
// cout << "path = " << tree_path (sp, x0, y0, d0) << "\n";
if (dx!=0) {
if (ref_p == tree_path (sp, x0, y0, d0)) {
for (i=1; i<DELTA; i=i<<1)
if (ref_p != tree_path (sp, x0, y0, d0+ dx*i)) break;
if (i>=DELTA)
FAILED ("inconsistent cursor handling");
for (d=i>>2; d>=1; d=d>>1)
if (ref_p != tree_path (sp, x0, y0, d0+ dx*(i-d))) i-=d;
d0 += dx*i;
}
else {
for (i=1; i<DELTA; i=i<<1)
if (ref_p == tree_path (sp, x0, y0, d0- dx*i)) break;
if (i<DELTA) {
for (d=i>>2; d>=1; d=d>>1)
if (ref_p == tree_path (sp, x0, y0, d0- dx*(i-d))) i-=d;
i--;
d0 -= dx*i;
}
else { // exceptional case
ref_p= tree_path (sp, x0, y0, d0- dx*DELTA);
for (i=1; i<DELTA; i=i<<1)
if (ref_p == tree_path (sp, x0, y0, d0- dx*i)) break;
for (d=i>>2; d>=1; d=d>>1)
if (ref_p == tree_path (sp, x0, y0, d0- dx*(i-d))) i-=d;
d0 -= dx*i;
}
}
