void BinaryHeap::copy_recursive(BinaryNode* subRoot){ add(subRoot->data); if(subRoot->hasLeftChild()){ copy_recursive(subRoot->leftChild); } if(subRoot->hasRightChild()){ copy_recursive(subRoot->rightChild); } }
typedef map<Node *, Node *> node2node Node * copy_recursive(Node * cur, node2node & node_map) { if ( cur == NULL ) return NULL; node2node::iterator i = node_map.find(cur); if ( i != node_map.end() ) return i->second(); Node * pnode = new Node; node_map[cur] = pnode; pnode->left = copy_recursive(cur->left, node_map); pnode->right = copy_recursive(cur->right, node_map); return pnode; }
void Tree::copy_recursive(Node *parent, const Node *orig) { for (Node *node = orig->get_child(); node; node = node->get_sibling()) { Node *child = insert(parent, node); if (child) copy_recursive(child, node); } }
void BinaryHeap::copy(const BinaryHeap* otherHeap){ BinaryNode* currentNode = otherHeap->root; clear(); if(!otherHeap->isEmpty()){ copy_recursive(currentNode); } }
int Tree::promote(int new_root) { for (Node *n = root[active]->get_child(); n; n = n->get_sibling()) { if (n->get_move() == new_root) { root[1-active]->copy_values(n); copy_recursive(root[1-active], n); clear_active(); active = 1-active; return active; } } clear(); return active; }
int copy_recursive(const char *src, const char *dst) { struct stat s; DIR *dir; struct dirent *d; int ret; ret = stat(src, &s); if (ret) return ret; if (!S_ISDIR(s.st_mode)) return copy_file(src, dst, 0); ret = make_directory(dst); if (ret) return ret; dir = opendir(src); if (!dir) return -EIO; while ((d = readdir(dir))) { char *from, *to; if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) continue; from = basprintf("%s/%s", src, d->d_name); to = basprintf("%s/%s", dst, d->d_name); ret = copy_recursive(from, to); if (ret) break; free(from); free(to); } closedir(dir); return ret; }
int main(int argc, char** argv) { parse_input(argc, argv); if (is_directory(src) && is_directory(dest)) { //set file creation mask umask(S_IWGRP | S_IWOTH); strcat(dest, get_basename(src)); //create new target starting directory if (!(mkdir(dest, S_IRWXU | S_IRWXG | S_IRWXO))) { printf("Created:\n%s\n\n", dest); } else { perror("MKDIR"); exit(EXIT_FAILURE); } copy_recursive(); } else { printf("somebody wasnt"); } return (EXIT_FAILURE); }
int emit_java(zcmgen_t *zcm) { GHashTable *type_table = g_hash_table_new(g_str_hash, g_str_equal); g_hash_table_insert(type_table, "byte", prim("byte", "# = ins.readByte();", "outs.writeByte(#);")); g_hash_table_insert(type_table, "int8_t", prim("byte", "# = ins.readByte();", "outs.writeByte(#);")); g_hash_table_insert(type_table, "int16_t", prim("short", "# = ins.readShort();", "outs.writeShort(#);")); g_hash_table_insert(type_table, "int32_t", prim("int", "# = ins.readInt();", "outs.writeInt(#);")); g_hash_table_insert(type_table, "int64_t", prim("long", "# = ins.readLong();", "outs.writeLong(#);")); g_hash_table_insert(type_table, "string", prim("String", "__strbuf = new char[ins.readInt()-1]; for (int _i = 0; _i < __strbuf.length; _i++) __strbuf[_i] = (char) (ins.readByte()&0xff); ins.readByte(); # = new String(__strbuf);", "__strbuf = new char[#.length()]; #.getChars(0, #.length(), __strbuf, 0); outs.writeInt(__strbuf.length+1); for (int _i = 0; _i < __strbuf.length; _i++) outs.write(__strbuf[_i]); outs.writeByte(0);")); // g_hash_table_insert(type_table, "string", prim("String", // "__strbuf = new byte[ins.readInt()-1]; ins.readFully(__strbuf); ins.readByte(); # = new String(__strbuf, \"UTF-8\");", // "__strbuf = #.getBytes(\"UTF-8\"); outs.writeInt(__strbuf.length+1); outs.write(__strbuf, 0, __strbuf.length); outs.writeByte(0);")); g_hash_table_insert(type_table, "boolean", prim("boolean", "# = ins.readByte()!=0;", "outs.writeByte( # ? 1 : 0);")); g_hash_table_insert(type_table, "float", prim("float", "# = ins.readFloat();", "outs.writeFloat(#);")); g_hash_table_insert(type_table, "double", prim("double", "# = ins.readDouble();", "outs.writeDouble(#);")); ////////////////////////////////////////////////////////////// // ENUMS for (unsigned int en = 0; en < g_ptr_array_size(zcm->enums); en++) { zcm_enum_t *le = (zcm_enum_t *) g_ptr_array_index(zcm->enums, en); const char *classname = make_fqn(zcm, le->enumname->lctypename); char *path = g_strdup_printf("%s%s%s.java", getopt_get_string(zcm->gopt, "jpath"), strlen(getopt_get_string(zcm->gopt, "jpath")) > 0 ? G_DIR_SEPARATOR_S : "", dots_to_slashes(classname)); if (!zcm_needs_generation(zcm, le->zcmfile, path)) continue; if (getopt_get_bool(zcm->gopt, "jmkdir")) make_dirs_for_file(path); FILE *f = fopen(path, "w"); if (f==NULL) return -1; if (strlen(le->enumname->package) > 0) emit(0, "package %s;", le->enumname->package); else emit(0, "package %s;", getopt_get_string(zcm->gopt, "jdefaultpkg")); emit(0, " "); emit(0, "import java.io.*;"); emit(0, "import java.util.*;"); emit(0, " "); emit(0, "public final class %s %s", le->enumname->shortname, getopt_get_string(zcm->gopt, "jdecl")); emit(0, "{"); emit(1, "public int value;"); emit(0, " "); for (unsigned int v = 0; v < g_ptr_array_size(le->values); v++) { zcm_enum_value_t *lev = (zcm_enum_value_t *) g_ptr_array_index(le->values, v); emit(1, "public static final int %-16s = %i;", lev->valuename, lev->value); } emit(0," "); emit(1,"public %s(int value) { this.value = value; }", le->enumname->shortname); emit(0," "); emit(1,"public int getValue() { return value; }"); emit(0," "); emit(1,"public void _encodeRecursive(DataOutput outs) throws IOException"); emit(1,"{"); emit(2,"outs.writeInt(this.value);"); emit(1,"}"); emit(0," "); emit(1,"public void encode(DataOutput outs) throws IOException"); emit(1,"{"); emit(2,"outs.writeLong(ZCM_FINGERPRINT);"); emit(2,"_encodeRecursive(outs);"); emit(1,"}"); emit(0," "); emit(1,"public static %s _decodeRecursiveFactory(DataInput ins) throws IOException", make_fqn(zcm, le->enumname->lctypename)); emit(1,"{"); emit(2,"%s o = new %s(0);", make_fqn(zcm, le->enumname->lctypename), make_fqn(zcm, le->enumname->lctypename)); emit(2,"o._decodeRecursive(ins);"); emit(2,"return o;"); emit(1,"}"); emit(0," "); emit(1,"public void _decodeRecursive(DataInput ins) throws IOException"); emit(1,"{"); emit(2,"this.value = ins.readInt();"); emit(1,"}"); emit(0," "); emit(1,"public %s(DataInput ins) throws IOException", le->enumname->shortname); emit(1,"{"); emit(2,"long hash = ins.readLong();"); emit(2,"if (hash != ZCM_FINGERPRINT)"); emit(3, "throw new IOException(\"ZCM Decode error: bad fingerprint\");"); emit(2,"_decodeRecursive(ins);"); emit(1,"}"); emit(0," "); emit(1,"public %s copy()", classname); emit(1,"{"); emit(2,"return new %s(this.value);", classname); emit(1,"}"); emit(0," "); emit(1,"public static final long _hashRecursive(ArrayList<Class<?>> clss)"); emit(1,"{"); emit(2,"return ZCM_FINGERPRINT;"); emit(1,"}"); emit(0," "); emit(1, "public static final long ZCM_FINGERPRINT = 0x%016"PRIx64"L;", le->hash); emit(0, "}"); fclose(f); } for (unsigned int st = 0; st < g_ptr_array_size(zcm->structs); st++) { zcm_struct_t *lr = (zcm_struct_t *) g_ptr_array_index(zcm->structs, st); const char *classname = make_fqn(zcm, lr->structname->lctypename); char *path = g_strdup_printf("%s%s%s.java", getopt_get_string(zcm->gopt, "jpath"), strlen(getopt_get_string(zcm->gopt, "jpath")) > 0 ? G_DIR_SEPARATOR_S : "", dots_to_slashes(classname)); if (!zcm_needs_generation(zcm, lr->zcmfile, path)) continue; if (getopt_get_bool(zcm->gopt, "jmkdir")) make_dirs_for_file(path); FILE *f = fopen(path, "w"); if (f==NULL) return -1; emit(0, "/* ZCM type definition class file\n" " * This file was automatically generated by zcm-gen\n" " * DO NOT MODIFY BY HAND!!!!\n" " */\n"); if (strlen(lr->structname->package) > 0) emit(0, "package %s;", lr->structname->package); else emit(0, "package %s;", getopt_get_string(zcm->gopt, "jdefaultpkg")); emit(0, " "); emit(0, "import java.io.*;"); if (0) { // Determine if we even need the java.nio.* package. int usenio = 0; for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); if (pinfo!=NULL && !strcmp(pinfo->storage, "float")) { usenio = 1; break; } } if (usenio) emit(0, "import java.nio.*;"); } emit(0, "import java.util.*;"); emit(0, "import zcm.zcm.*;"); emit(0, " "); emit(0, "public final class %s %s", lr->structname->shortname, getopt_get_string(zcm->gopt, "jdecl")); emit(0, "{"); for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); emit_start(1, "public "); if (pinfo==NULL) { emit_continue("%s", make_fqn(zcm, lm->type->lctypename)); } else { emit_continue("%s", pinfo->storage); } emit_continue(" %s", lm->membername); for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions); i++) emit_continue("[]"); emit_end(";"); } emit(0," "); // public constructor emit(1,"public %s()", lr->structname->shortname); emit(1,"{"); // pre-allocate any fixed-size arrays. for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); if (g_ptr_array_size(lm->dimensions)==0 || !zcm_is_constant_size_array(lm)) continue; emit_start(2, "%s = new ", lm->membername); if (pinfo != NULL) emit_continue("%s", pinfo->storage); else emit_continue("%s", make_fqn(zcm, lm->type->lctypename)); for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions); i++) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, i); emit_continue("[%s]", dim->size); } emit_end(";"); } emit(1,"}"); emit(0," "); emit(1, "public static final long ZCM_FINGERPRINT;"); emit(1, "public static final long ZCM_FINGERPRINT_BASE = 0x%016"PRIx64"L;", lr->hash); emit(0," "); ////////////////////////////////////////////////////////////// // CONSTANTS for (unsigned int cn = 0; cn < g_ptr_array_size(lr->constants); cn++) { zcm_constant_t *lc = (zcm_constant_t *) g_ptr_array_index(lr->constants, cn); assert(zcm_is_legal_const_type(lc->lctypename)); if (!strcmp(lc->lctypename, "int8_t")) { emit(1, "public static final byte %s = (byte) %s;", lc->membername, lc->val_str); } else if (!strcmp(lc->lctypename, "int16_t")) { emit(1, "public static final short %s = (short) %s;", lc->membername, lc->val_str); } else if (!strcmp(lc->lctypename, "int32_t")) { emit(1, "public static final int %s = %s;", lc->membername, lc->val_str); } else if (!strcmp(lc->lctypename, "int64_t")) { emit(1, "public static final long %s = %sL;", lc->membername, lc->val_str); } else if (!strcmp(lc->lctypename, "float")) { emit(1, "public static final float %s = %sf;", lc->membername, lc->val_str); } else if (!strcmp(lc->lctypename, "double")) { emit(1, "public static final double %s = %s;", lc->membername, lc->val_str); } else { assert(0); } } if (g_ptr_array_size(lr->constants) > 0) emit(0, ""); ///////////////// compute fingerprint ////////////////// emit(1, "static {"); emit(2, "ZCM_FINGERPRINT = _hashRecursive(new ArrayList<Class<?>>());"); emit(1, "}"); emit(0, " "); emit(1, "public static long _hashRecursive(ArrayList<Class<?>> classes)"); emit(1, "{"); emit(2, "if (classes.contains(%s.class))", make_fqn(zcm, lr->structname->lctypename)); emit(3, "return 0L;"); emit(0, " "); emit(2, "classes.add(%s.class);", make_fqn(zcm, lr->structname->lctypename)); emit(2, "long hash = ZCM_FINGERPRINT_BASE"); for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); if (pinfo) continue; emit(3, " + %s._hashRecursive(classes)", make_fqn(zcm, lm->type->lctypename)); } emit(3,";"); emit(2, "classes.remove(classes.size() - 1);"); emit(2, "return (hash<<1) + ((hash>>63)&1);"); emit(1, "}"); emit(0, " "); ///////////////// encode ////////////////// emit(1,"public void encode(DataOutput outs) throws IOException"); emit(1,"{"); emit(2,"outs.writeLong(ZCM_FINGERPRINT);"); emit(2,"_encodeRecursive(outs);"); emit(1,"}"); emit(0," "); emit(1,"public void _encodeRecursive(DataOutput outs) throws IOException"); emit(1,"{"); if(struct_has_string_member(lr)) emit(2, "char[] __strbuf = null;"); char accessor[1024]; for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); make_accessor(lm, "this", accessor); encode_recursive(zcm, lm, f, pinfo, accessor, 0); emit(0," "); } emit(1,"}"); emit(0," "); ///////////////// decode ////////////////// // decoding constructors emit(1, "public %s(byte[] data) throws IOException", lr->structname->shortname); emit(1, "{"); emit(2, "this(new ZCMDataInputStream(data));"); emit(1, "}"); emit(0, " "); emit(1,"public %s(DataInput ins) throws IOException", lr->structname->shortname); emit(1,"{"); emit(2,"if (ins.readLong() != ZCM_FINGERPRINT)"); emit(3, "throw new IOException(\"ZCM Decode error: bad fingerprint\");"); emit(0," "); emit(2,"_decodeRecursive(ins);"); emit(1,"}"); emit(0," "); emit(1,"public static %s _decodeRecursiveFactory(DataInput ins) throws IOException", make_fqn(zcm, lr->structname->lctypename)); emit(1,"{"); emit(2,"%s o = new %s();", make_fqn(zcm, lr->structname->lctypename), make_fqn(zcm, lr->structname->lctypename)); emit(2,"o._decodeRecursive(ins);"); emit(2,"return o;"); emit(1,"}"); emit(0," "); emit(1,"public void _decodeRecursive(DataInput ins) throws IOException"); emit(1,"{"); if(struct_has_string_member(lr)) emit(2, "char[] __strbuf = null;"); for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); make_accessor(lm, "this", accessor); // allocate an array if necessary if (g_ptr_array_size(lm->dimensions) > 0) { emit_start(2, "this.%s = new ", lm->membername); if (pinfo != NULL) emit_continue("%s", pinfo->storage); else emit_continue("%s", make_fqn(zcm, lm->type->lctypename)); for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions); i++) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, i); emit_continue("[(int) %s]", dim->size); } emit_end(";"); } decode_recursive(zcm, lm, f, pinfo, accessor, 0); emit(0," "); } emit(1,"}"); emit(0," "); ///////////////// copy ////////////////// emit(1,"public %s copy()", classname); emit(1,"{"); emit(2,"%s outobj = new %s();", classname, classname); for (unsigned int member = 0; member < g_ptr_array_size(lr->members); member++) { zcm_member_t *lm = (zcm_member_t *) g_ptr_array_index(lr->members, member); primitive_info_t *pinfo = (primitive_info_t*) g_hash_table_lookup(type_table, lm->type->lctypename); make_accessor(lm, "", accessor); // allocate an array if necessary if (g_ptr_array_size(lm->dimensions) > 0) { emit_start(2, "outobj.%s = new ", lm->membername); if (pinfo != NULL) emit_continue("%s", pinfo->storage); else emit_continue("%s", make_fqn(zcm, lm->type->lctypename)); for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions); i++) { zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, i); emit_continue("[(int) %s]", dim->size); } emit_end(";"); } copy_recursive(zcm, lm, f, pinfo, accessor, 0); emit(0," "); } emit(2,"return outobj;"); emit(1,"}"); emit(0," "); //////// emit(0, "}\n"); fclose(f); } /* XXX deallocate our storage. unfinished since memory leaks are non-critical for zcm-gen. hashtable_iterator_t *hit = hashtable_iterator_create(type_table); hashtable_entry_t *entry; while ((entry = hashtable_iterator_next(hit)) != NULL) { free((char*) entry->value); } hashtable_iterator_destroy(hit); hashtable_destroy(type_table); */ return 0; }
void copy_recursive(zcmgen_t *zcm, zcm_member_t *lm, FILE *f, primitive_info_t *pinfo, char *accessor, int depth) { // base case: primitive array if (depth+1 == g_ptr_array_size(lm->dimensions) && pinfo != NULL) { char accessor_array[1024]; make_accessor_array(lm, "", accessor_array); // one method works for all primitive types, yay! zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); if (dim->mode == ZCM_VAR) { emit(2+depth, "if (this.%s > 0)", dim->size); emit_start(3+depth, "System.arraycopy(this.%s, 0, outobj.%s, 0, %s%s);", accessor_array, accessor_array, dim_size_prefix(dim->size), dim->size); } else { emit_start(2+depth, "System.arraycopy(this.%s, 0, outobj.%s, 0, %s%s);", accessor_array, accessor_array, dim_size_prefix(dim->size), dim->size); } return; } // base case: generic if (depth == g_ptr_array_size(lm->dimensions)) { if (pinfo != NULL) { emit_start(2+g_ptr_array_size(lm->dimensions), "outobj.%s", lm->membername); for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions); i++) { emit_continue("[%c]", 'a'+i); } emit_continue(" = this.%s", lm->membername); for (unsigned int i = 0; i < g_ptr_array_size(lm->dimensions); i++) { emit_continue("[%c]", 'a'+i); } emit_end(";"); } else { emit(2+depth, "outobj.%s = this.%s.copy();", accessor, accessor); } return; } zcm_dimension_t *dim = (zcm_dimension_t*) g_ptr_array_index(lm->dimensions, depth); emit(2+depth, "for (int %c = 0; %c < %s%s; %c++) {", 'a'+depth, 'a'+depth, dim_size_prefix(dim->size), dim->size, 'a'+depth); copy_recursive(zcm, lm, f, pinfo, accessor, depth+1); emit(2+depth, "}"); }
Node * copy_struct(Node * root) { node2node node_map; return copy_recursive(root, node_map); }