0001: /*
0002: * JFolder, Copyright 2001-2006 Gary Steinmetz
0003: *
0004: * Distributable under LGPL license.
0005: * See terms of license at gnu.org.
0006: */
0007:
0008: package org.jfolder.dms.model.v1;
0009:
0010: //base classes
0011: import java.io.ByteArrayInputStream;
0012: import java.io.IOException;
0013: import java.io.InputStream;
0014: import java.io.PrintWriter;
0015: import java.io.StringWriter;
0016: import java.util.ArrayList;
0017: import java.util.HashMap;
0018: import java.util.HashSet;
0019: import java.util.Iterator;
0020: import java.util.StringTokenizer;
0021:
0022: //project specific classes
0023: import org.jfolder.common.UnexpectedSystemException;
0024: import org.jfolder.common.entity.InitializeSystemEntityTagContext;
0025: import org.jfolder.common.entity.SystemEntity;
0026: import org.jfolder.common.entity.SystemEntityUpdates;
0027: import org.jfolder.common.entity.SystemEntityUpdatesContext;
0028: import org.jfolder.common.files.BaseVirtualFileSystemHolder;
0029: import org.jfolder.common.files.VirtualFileSystemDirectory;
0030: import org.jfolder.common.files.VirtualFileSystemFile;
0031: import org.jfolder.common.tagging.AppraiseConceptTagContext;
0032: import org.jfolder.common.tagging.ConceptTag;
0033: import org.jfolder.common.tagging.ConceptTagCharacteristic;
0034: import org.jfolder.common.tagging.ConceptTagCharacteristicHolder;
0035: import org.jfolder.common.tagging.ConceptTagConstraint;
0036: import org.jfolder.common.tagging.ConceptTagConstraintHolder;
0037: import org.jfolder.common.tagging.ConceptTagPreferences;
0038: import org.jfolder.common.tagging.DynamicConceptTagConstraintContext;
0039: import org.jfolder.common.tagging.InitializeConceptTagContext;
0040: import org.jfolder.common.tagging.StaticConceptTagConstraintContext;
0041: import org.jfolder.common.tagging.StudioConceptTagInstanceInfoContext;
0042: import org.jfolder.common.tagging.StudioConceptTagTypeInfoContext;
0043: import org.jfolder.common.utils.misc.MiscHelper;
0044: import org.jfolder.dms.model.DocumentFileSystemDirectory;
0045: import org.jfolder.dms.model.DocumentFileSystemFile;
0046: import org.jfolder.dms.model.DocumentFileSystemFileUpdates;
0047:
0048: //other classes
0049:
0050: public abstract class DocumentFileSystemHolderTag extends
0051: BaseVirtualFileSystemHolder {
0052:
0053: //local-files details
0054: private final static String LOCAL_FILES_CTCON = "local-files";
0055: private final static String LOCAL_FILES_TITLE = "Local Files";
0056: private final static String LOCAL_FILES_SHORT_DESCRIPTION = "Local Files";
0057:
0058: //deleted-local-files details
0059: private final static String DELETED_LOCAL_FILES_CTCON = "deleted-local-files";
0060: private final static String DELETED_LOCAL_FILES_TITLE = "Deleted Local Files";
0061: private final static String DELETED_LOCAL_FILES_SHORT_DESCRIPTION = "Deleted Local Files";
0062:
0063: //local-directories details
0064: private final static String LOCAL_DIRECTORIES_CTCON = "local-directories";
0065: private final static String LOCAL_DIRECTORIES_TITLE = "Local Directories";
0066: private final static String LOCAL_DIRECTORIES_SHORT_DESCRIPTION = "Local Directories";
0067:
0068: //deleted-local-directories details
0069: private final static String DELETED_LOCAL_DIRECTORIES_CTCON = "deleted-local-directories";
0070: private final static String DELETED_LOCAL_DIRECTORIES_TITLE = "Deleted Local Directories";
0071: private final static String DELETED_LOCAL_DIRECTORIES_SHORT_DESCRIPTION = "Deleted Local Directories";
0072:
0073: //
0074: private ConceptTagCharacteristic localFilesCtchar = null;
0075: private ConceptTagCharacteristic deletedLocalFilesCtchar = null;
0076: //
0077: private HashMap originalLocalFiles = null;
0078: private HashMap originalDeletedLocalFiles = null;
0079: //
0080: private ConceptTagCharacteristic localDirectoriesCtchar = null;
0081: private ConceptTagCharacteristic deletedLocalDirectoriesCtchar = null;
0082: //
0083: private HashMap originalLocalDirectories = null;
0084: private HashMap originalDeletedLocalDirectories = null;
0085:
0086: protected DocumentFileSystemHolderTag() {
0087: }
0088:
0089: private Boolean displayState = null;
0090:
0091: private void printIfSpecificOld() {
0092: //
0093: if (this .displayState == null
0094: || !this .displayState.booleanValue()) {
0095: this .displayState = new Boolean(
0096: this .originalLocalFiles != null
0097: && this .originalLocalFiles
0098: .toString()
0099: .startsWith(
0100: "{WEBPAGE3=, WEBPAGE9=, WEBPAGE5=, WEBPAGE7=, WEBPAGE11"));
0101: }
0102: //
0103: if (this instanceof DocumentFileSystemDirectoryTag) {
0104: DocumentFileSystemDirectoryTag localDfsdt = ((DocumentFileSystemDirectoryTag) this );
0105: if (this .displayState.booleanValue()) {
0106: //
0107: MiscHelper
0108: .println("DocFileSysHolTag Images Found Before");
0109: MiscHelper.println(" this.originalLocalFiles = "
0110: + this .originalLocalFiles);
0111: MiscHelper
0112: .println(" this.originalDeletedLocalFiles = "
0113: + this .originalDeletedLocalFiles);
0114: MiscHelper.println(" this.originalLocalDirectories = "
0115: + this .originalLocalDirectories);
0116: MiscHelper
0117: .println(" this.originalDeletedLocalDirectories = "
0118: + this .originalDeletedLocalDirectories);
0119: }
0120: }
0121: }
0122:
0123: //
0124: private void loadOriginalState() {
0125: //
0126: //
0127: //final String NOZZA = ("nozza.txt").toUpperCase();
0128: //if (isFilePresent(NOZZA)) {
0129: // VirtualSystemFile currVsf = getFile(NOZZA);
0130: // byte currCon[] = currVsf.getContent();
0131: // VirtualSystemFile origVsf =
0132: // ((VirtualSystemFile)this.originalLocalFiles.get(NOZZA));
0133: // if (origVsf != null) {
0134: // byte origCon[] = origVsf.getContent();
0135: // MiscHelper.println("DocSysHolTag orgC.l = " + origCon.length);
0136: // MiscHelper.println("DocSysHolTag orgC.l = " + currCon.length);
0137: // if (currCon[0] != origCon[0]) {
0138: // MiscHelper.println("DocSysHolTag found mismatch");
0139: // throw new UnexpectedSystemException(
0140: // "DocSysHolTag currCon = '" + currCon[0]
0141: // + "', origCon = '" + origCon[0] + "'");
0142: // }
0143: // else if (origVsf != currVsf) {
0144: // throw new UnexpectedSystemException("Not Equal");
0145: // }
0146: // else if (origCon[0] == 'b') {
0147: // throw new UnexpectedSystemException("'b' Found");
0148: // }
0149: // //else if () {
0150: // //}
0151: // }
0152: // //MiscHelper.println("DocSysHolTag currDsf = " + currCon[0]);
0153: // //MiscHelper.println("DocSysHolTag origDsf = " + origCon[0]);
0154: // //MiscHelper.println("DocSysHolTag currDsf = "
0155: // // + ((char)currCon[0]));
0156: // //MiscHelper.println("DocSysHolTag origDsf = "
0157: // // + ((char)origCon[0]));
0158: // //MiscHelper.println("DocSysHolTag about to look at nozza.txt");
0159: //}
0160: //if (localDfsdt.isNameAvailable()
0161: // && localDfsdt.getName().equals("Images")) {
0162: //printIfSpecific();
0163: //
0164: this .originalLocalFiles = getLocalFilesAsHashMap();
0165: this .originalDeletedLocalFiles = getDeletedLocalFilesAsHashMap();
0166: //
0167: this .originalLocalDirectories = getLocalDirectoriesAsHashMap();
0168: this .originalDeletedLocalDirectories = getDeletedLocalDirectoriesAsHashMap();
0169: //
0170: //printIfSpecific();
0171: //
0172: }
0173:
0174: protected void inheritOriginalStateFrom(
0175: DocumentFileSystemHolderTag inDfsht) {
0176: //
0177: //printIfSpecific();
0178: //
0179: this .originalLocalFiles = ((HashMap) inDfsht.originalLocalFiles
0180: .clone());
0181: this .originalDeletedLocalFiles = ((HashMap) inDfsht.originalDeletedLocalFiles
0182: .clone());
0183: //
0184: this .originalLocalDirectories = ((HashMap) inDfsht.originalLocalDirectories
0185: .clone());
0186: this .originalDeletedLocalDirectories = ((HashMap) inDfsht.originalDeletedLocalDirectories
0187: .clone());
0188: //
0189: //
0190: //
0191: ArrayList sourceActiveSubDirs = inDfsht.getLocalDirectories();
0192: ArrayList destActiveSubDirs = this .getLocalDirectories();
0193: commonInherit(sourceActiveSubDirs, destActiveSubDirs);
0194: //
0195: ArrayList sourceDeletedSubDirs = inDfsht.getDeleteDirectories();
0196: ArrayList destDeletedSubDirs = this .getDeleteDirectories();
0197: commonInherit(sourceDeletedSubDirs, destDeletedSubDirs);
0198: //
0199: //printIfSpecific();
0200: //
0201: }
0202:
0203: private final static void commonInherit(ArrayList inSource,
0204: ArrayList inDest) {
0205: //
0206: if (inSource.size() == inDest.size()) {
0207: //
0208: for (int i = 0; i < inSource.size(); i++) {
0209: //
0210: DocumentFileSystemDirectoryTag nextSourceDfsdt = (DocumentFileSystemDirectoryTag) inSource
0211: .get(i);
0212: DocumentFileSystemDirectoryTag nextDestDfsdt = (DocumentFileSystemDirectoryTag) inDest
0213: .get(i);
0214: //
0215: if (nextSourceDfsdt.getName().equals(
0216: nextDestDfsdt.getName())) {
0217: nextDestDfsdt
0218: .inheritOriginalStateFrom(nextSourceDfsdt);
0219: } else {
0220: throw UnexpectedSystemException.unknownState();
0221: }
0222: }
0223: } else {
0224: //
0225: throw UnexpectedSystemException.unknownState();
0226: }
0227: }
0228:
0229: //
0230: protected HashMap getLocalFilesAsHashMap() {
0231: //ConceptTagPreferences ctp = this.localFilesCtchar.getPreferences();
0232: //MiscHelper.writeMessage(
0233: // this, ctp.getRootHolder().getXMLRepresentation());
0234: return getFilesAsHashMap(this .localFilesCtchar);
0235: }
0236:
0237: //
0238: protected HashMap getDeletedLocalFilesAsHashMap() {
0239: return getFilesAsHashMap(this .deletedLocalFilesCtchar);
0240: }
0241:
0242: //
0243: private HashMap getFilesAsHashMap(ConceptTagCharacteristic inCtchar) {
0244:
0245: HashMap outValue = new HashMap();
0246:
0247: for (int i = 0; i < inCtchar.getValueLength(); i++) {
0248: ConceptTag nextCt = inCtchar.getValueAsConceptTag(i, null);
0249: ConceptTagCharacteristicHolder nextCtcharh = inCtchar
0250: .getValueAsHolder(i, null);
0251: //MiscHelper.println("DocSysHolTag,getFAHM ("
0252: // + nextCtcharh.getHandleAsArrayList() + ") = " + i);
0253: DocumentFileSystemFileTag nextFile = (DocumentFileSystemFileTag) nextCt;
0254: outValue.put(nextFile.getName().toUpperCase(), nextFile);
0255: }
0256:
0257: //MiscHelper.println("DocSysHolTag,getFAHM size = " + outValue.size());
0258:
0259: return outValue;
0260: }
0261:
0262: //
0263: private void deleteFile(String inName,
0264: ConceptTagCharacteristic inCtchar) {
0265: for (int i = 0; i < inCtchar.getValueLength(); i++) {
0266: ConceptTag nextCt = inCtchar.getValueAsConceptTag(i, null);
0267: DocumentFileSystemFileTag nextFile = (DocumentFileSystemFileTag) nextCt;
0268: if (inName.toUpperCase().equals(
0269: nextFile.getName().toUpperCase())) {
0270: inCtchar.removeValueWithLocalFiles(i);
0271: break;
0272: }
0273: }
0274: }
0275:
0276: //
0277: private DocumentFileSystemFileTag createFile(String inName,
0278: byte inContent[], ConceptTagCharacteristic inCtchar) {
0279: //
0280: return DocumentFileSystemFileTag.newInstance(inCtchar, inCtchar
0281: .getValueLength(), inName, inContent);
0282: }
0283:
0284: //
0285: //
0286: //
0287: //
0288: //
0289: protected HashMap getLocalDirectoriesAsHashMap() {
0290: return getDirectoriesAsHashMap(this .localDirectoriesCtchar);
0291: }
0292:
0293: //
0294: protected HashMap getDeletedLocalDirectoriesAsHashMap() {
0295: return getDirectoriesAsHashMap(this .deletedLocalDirectoriesCtchar);
0296: }
0297:
0298: //
0299: private HashMap getDirectoriesAsHashMap(
0300: ConceptTagCharacteristic inCtchar) {
0301:
0302: HashMap outValue = new HashMap();
0303:
0304: for (int i = 0; i < inCtchar.getValueLength(); i++) {
0305: ConceptTag nextCt = inCtchar.getValueAsConceptTag(i, null);
0306: DocumentFileSystemDirectoryTag nextDirectory = (DocumentFileSystemDirectoryTag) nextCt;
0307: outValue.put(nextDirectory.getName().toUpperCase(),
0308: nextDirectory);
0309: }
0310:
0311: return outValue;
0312: }
0313:
0314: //
0315: private boolean isDirectoryPresent(String inName,
0316: ConceptTagCharacteristic inCtchar) {
0317: //
0318: return (getDirectoryIndex(inName, inCtchar) != -1);
0319: }
0320:
0321: private int getDirectoryIndex(String inName,
0322: ConceptTagCharacteristic inCtchar) {
0323: //
0324:
0325: int outValue = -1;
0326:
0327: for (int i = 0; i < inCtchar.getValueLength(); i++) {
0328: ConceptTag nextCt = inCtchar.getValueAsConceptTag(i, null);
0329: DocumentFileSystemDirectoryTag nextDir = (DocumentFileSystemDirectoryTag) nextCt;
0330: if (inName.toUpperCase().equals(
0331: nextDir.getName().toUpperCase())) {
0332: outValue = i;
0333: break;
0334: }
0335: }
0336:
0337: return outValue;
0338: }
0339:
0340: //private void deleteDirectory(
0341: // String inName, ConceptTagCharacteristic inCtchar) {
0342: // for (int i = 0; i < inCtchar.getValueLength(); i++) {
0343: // ConceptTag nextCt = inCtchar.getValueAsConceptTag(i, null);
0344: // DocumentFileSystemDirectoryTag nextDir =
0345: // (DocumentFileSystemDirectoryTag)nextCt;
0346: // if (inName.toUpperCase().equals(
0347: // nextDir.getName().toUpperCase())) {
0348: // inCtchar.removeValueWithLocalFiles(i);
0349: // break;
0350: // }
0351: // }
0352: //}
0353: //
0354: private DocumentFileSystemDirectoryTag createDirectory(
0355: String inName, ConceptTagCharacteristic inCtchar) {
0356: //
0357: return DocumentFileSystemDirectoryTag.newInstance(inCtchar,
0358: inCtchar.getValueLength(), inName);
0359: }
0360:
0361: //
0362: //
0363: //
0364: //
0365: //
0366: //
0367: protected VirtualFileSystemFile createLocalFile(String inName,
0368: byte inContent[]) {
0369: //
0370: DocumentFileSystemFileTag outValue = null;
0371:
0372: HashMap lf = getDeletedLocalFilesAsHashMap();
0373: if (lf.containsKey(inName.toUpperCase())) {
0374: deleteFile(inName, this .deletedLocalFilesCtchar);
0375: }
0376:
0377: outValue = DocumentFileSystemFileTag.newInstance(
0378: this .localFilesCtchar, this .localFilesCtchar
0379: .getValueLength(), inName, inContent);
0380:
0381: return outValue;
0382: }
0383:
0384: protected VirtualFileSystemFile updateLocalFile(String inName,
0385: byte inContent[]) {
0386: //
0387: VirtualFileSystemFile outValue = null;
0388:
0389: deleteLocalFile(inName);
0390: outValue = createLocalFile(inName, inContent);
0391:
0392: return outValue;
0393: }
0394:
0395: protected void deleteLocalFile(String inName) {
0396:
0397: //MiscHelper.println("DocSysHolTag,delLocFil before");
0398: //MiscHelper.println("DocSysHolTag,delLocFil currDelFiles = "
0399: // + getDeletedLocalFilesAsHashMap());
0400: //MiscHelper.println("DocSysHolTag,delLocFil origLocFiles = "
0401: // + this.originalLocalFiles);
0402: deleteFile(inName, this .localFilesCtchar);
0403: DocumentFileSystemFileTag.newInstance(
0404: this .deletedLocalFilesCtchar,
0405: this .deletedLocalFilesCtchar.getValueLength(), inName,
0406: null);
0407: //MiscHelper.println("DocSysHolTag,delLocFil currDelFiles = "
0408: // + getDeletedLocalFilesAsHashMap());
0409: //MiscHelper.println("DocSysHolTag,delLocFil origLocFiles = "
0410: // + this.originalLocalFiles);
0411: //MiscHelper.println("DocSysHolTag,delLocFil after");
0412: }
0413:
0414: //
0415: protected VirtualFileSystemDirectory createLocalDirectory(
0416: String inName) {
0417: //
0418: DocumentFileSystemDirectoryTag outValue = null;
0419:
0420: //
0421: if (isDirectoryPresent(inName,
0422: this .deletedLocalDirectoriesCtchar)) {
0423: int index = getDirectoryIndex(inName,
0424: this .deletedLocalDirectoriesCtchar);
0425: //
0426: ConceptTagCharacteristicHolder sourceCtcharh = this .deletedLocalDirectoriesCtchar
0427: .getValueAsHolder(index, null);
0428: DocumentFileSystemDirectoryTag sourDfsdt = ((DocumentFileSystemDirectoryTag) sourceCtcharh
0429: .getConceptTag());
0430: //
0431: DocumentFileSystemDirectoryTag destDfsdt = new DocumentFileSystemDirectoryTag();
0432: ConceptTagCharacteristicHolder destCtcharh = this .localDirectoriesCtchar
0433: .addValue(this .localDirectoriesCtchar
0434: .getValueLength(), destDfsdt, true);
0435: //
0436: sourceCtcharh.copyTo(destCtcharh);
0437: //
0438: //
0439: InitializeSystemEntityTagContext isetc = new InitializeSystemEntityTagContext(
0440: destCtcharh);
0441: //
0442: destDfsdt.initialize(isetc);
0443: destDfsdt.inheritOriginalStateFrom(sourDfsdt);
0444: //
0445: //
0446: destDfsdt.setName(inName);
0447: //
0448: this .deletedLocalDirectoriesCtchar
0449: .removeValueWithLocalFiles(index);
0450: //
0451: outValue = destDfsdt;
0452: } else {
0453: outValue = DocumentFileSystemDirectoryTag.newInstance(
0454: this .localDirectoriesCtchar,
0455: this .localDirectoriesCtchar.getValueLength(),
0456: inName);
0457: }
0458:
0459: //HashMap ld = getDeletedLocalDirectoriesAsHashMap();
0460: //if (ld.containsKey(inName.toUpperCase())) {
0461: // deleteDirectory(inName, this.deletedLocalDirectoriesCtchar);
0462: //}
0463:
0464: return outValue;
0465: }
0466:
0467: protected void deleteLocalDirectory(String inName) {
0468:
0469: int index = getDirectoryIndex(inName,
0470: this .localDirectoriesCtchar);
0471: //
0472: ConceptTagCharacteristicHolder sourceCtcharh = this .localDirectoriesCtchar
0473: .getValueAsHolder(index, null);
0474: DocumentFileSystemDirectoryTag sourDfsdt = ((DocumentFileSystemDirectoryTag) sourceCtcharh
0475: .getConceptTag());
0476: //
0477: //
0478: DocumentFileSystemDirectoryTag destDfsdt = new DocumentFileSystemDirectoryTag();
0479: ConceptTagCharacteristicHolder destCtcharh = this .deletedLocalDirectoriesCtchar
0480: .addValue(this .deletedLocalDirectoriesCtchar
0481: .getValueLength(), destDfsdt, true);
0482: //
0483: sourceCtcharh.copyTo(destCtcharh);
0484: //
0485: //
0486: InitializeSystemEntityTagContext isetc = new InitializeSystemEntityTagContext(
0487: destCtcharh);
0488: //
0489: destDfsdt.initialize(isetc);
0490: destDfsdt.inheritOriginalStateFrom(sourDfsdt);
0491: //
0492: this .localDirectoriesCtchar.removeValueWithLocalFiles(index);
0493: }
0494:
0495: //
0496: public void registerDeletedDirectory(String inName) {
0497: DocumentFileSystemDirectoryTag.newInstance(
0498: this .deletedLocalDirectoriesCtchar,
0499: this .deletedLocalDirectoriesCtchar.getValueLength(),
0500: inName);
0501: loadOriginalState();
0502: }
0503:
0504: public void registerDirectory(String inName) {
0505: DocumentFileSystemDirectoryTag.newInstance(
0506: this .localDirectoriesCtchar,
0507: this .localDirectoriesCtchar.getValueLength(), inName);
0508: loadOriginalState();
0509: }
0510:
0511: //
0512: public void registerDeletedFile(String inName, byte inContent[]) {
0513: DocumentFileSystemFileTag.newInstance(
0514: this .deletedLocalFilesCtchar,
0515: this .deletedLocalFilesCtchar.getValueLength(), inName,
0516: inContent);
0517: loadOriginalState();
0518: }
0519:
0520: public void registerFile(String inName, byte inContent[]) {
0521: DocumentFileSystemFileTag.newInstance(this .localFilesCtchar,
0522: this .localFilesCtchar.getValueLength(), inName,
0523: inContent);
0524: loadOriginalState();
0525: }
0526:
0527: //
0528: public abstract ConceptTagConstraint[] initializeConstraints(
0529: ConceptTagConstraintHolder inCtconh);
0530:
0531: public abstract void initializeCharacteristics(
0532: ConceptTagConstraint inCtcon[]);
0533:
0534: //
0535: public void initialize(InitializeConceptTagContext inIctc) {
0536:
0537: //
0538: ConceptTagConstraintHolder rootCtconh = ConceptTagConstraintHolder
0539: .newInstance(inIctc);
0540:
0541: //constrain "local-files"
0542: ConceptTagConstraint localFilesCtcon = ConceptTagConstraint
0543: .newInstance(LOCAL_FILES_CTCON, rootCtconh);
0544: localFilesCtcon.setTitle(LOCAL_FILES_TITLE);
0545: localFilesCtcon
0546: .setShortDescription(LOCAL_FILES_SHORT_DESCRIPTION);
0547: //
0548: DynamicConceptTagConstraintContext localFilesDctcc = DynamicConceptTagConstraintContext
0549: .newInstance(localFilesCtcon);
0550:
0551: //constrain "deleted-local-files"
0552: ConceptTagConstraint deletedLocalFilesCtcon = ConceptTagConstraint
0553: .newInstance(DELETED_LOCAL_FILES_CTCON, rootCtconh);
0554: deletedLocalFilesCtcon.setTitle(DELETED_LOCAL_FILES_TITLE);
0555: deletedLocalFilesCtcon
0556: .setShortDescription(DELETED_LOCAL_FILES_SHORT_DESCRIPTION);
0557: //
0558: DynamicConceptTagConstraintContext deletedLocalFilesDctcc = DynamicConceptTagConstraintContext
0559: .newInstance(deletedLocalFilesCtcon);
0560:
0561: //constrain "local-directories"
0562: ConceptTagConstraint localDirectoriesCtcon = ConceptTagConstraint
0563: .newInstance(LOCAL_DIRECTORIES_CTCON, rootCtconh);
0564: localDirectoriesCtcon.setTitle(LOCAL_DIRECTORIES_TITLE);
0565: localDirectoriesCtcon
0566: .setShortDescription(LOCAL_DIRECTORIES_SHORT_DESCRIPTION);
0567: //
0568: DynamicConceptTagConstraintContext localDirectoriesDctcc = DynamicConceptTagConstraintContext
0569: .newInstance(localDirectoriesCtcon);
0570:
0571: //constrain "deleted-local-directories"
0572: ConceptTagConstraint deletedLocalDirectoriesCtcon = ConceptTagConstraint
0573: .newInstance(DELETED_LOCAL_DIRECTORIES_CTCON,
0574: rootCtconh);
0575: deletedLocalDirectoriesCtcon
0576: .setTitle(DELETED_LOCAL_DIRECTORIES_TITLE);
0577: deletedLocalDirectoriesCtcon
0578: .setShortDescription(DELETED_LOCAL_DIRECTORIES_SHORT_DESCRIPTION);
0579: //
0580: DynamicConceptTagConstraintContext deletedLocalDirectoriesDctcc = DynamicConceptTagConstraintContext
0581: .newInstance(deletedLocalDirectoriesCtcon);
0582:
0583: //
0584: ConceptTagConstraint otherCtcon[] = initializeConstraints(rootCtconh);
0585:
0586: //
0587: inIctc.initialize();
0588:
0589: //initialize characteristics
0590: this .localFilesCtchar = localFilesCtcon.getCharacteristic();
0591: this .deletedLocalFilesCtchar = deletedLocalFilesCtcon
0592: .getCharacteristic();
0593: //
0594: this .localDirectoriesCtchar = localDirectoriesCtcon
0595: .getCharacteristic();
0596: this .deletedLocalDirectoriesCtchar = deletedLocalDirectoriesCtcon
0597: .getCharacteristic();
0598:
0599: //
0600: initializeCharacteristics(otherCtcon);
0601:
0602: //
0603: loadOriginalState();
0604: }
0605:
0606: protected void determineUpdates(
0607: DocumentFileSystemRootUpdatesTag inDsrut,
0608: ArrayList inCurrentDir, boolean inAlign) {
0609:
0610: //
0611: //
0612: ArrayList createDirs = getCreateDirectories();
0613: for (int i = 0; i < createDirs.size(); i++) {
0614: //
0615: Object o = createDirs.get(i);
0616: DocumentFileSystemDirectory nextDir = (DocumentFileSystemDirectory) o;
0617: inCurrentDir.add(nextDir.getName());
0618: inDsrut.addCreateDirectory(inCurrentDir, nextDir);
0619: inCurrentDir.remove(inCurrentDir.size() - 1);
0620: }
0621: //
0622: ArrayList deleteDirs = getDeleteDirectories();
0623: for (int i = 0; i < deleteDirs.size(); i++) {
0624: //
0625: DocumentFileSystemDirectory nextDir = (DocumentFileSystemDirectory) deleteDirs
0626: .get(i);
0627: inCurrentDir.add(nextDir.getName());
0628: inDsrut.addDeleteDirectory(inCurrentDir, nextDir);
0629: inCurrentDir.remove(inCurrentDir.size() - 1);
0630: }
0631: //
0632: ArrayList reviveDirs = getReviveDirectories();
0633: for (int i = 0; i < reviveDirs.size(); i++) {
0634: //
0635: DocumentFileSystemDirectory nextDir = (DocumentFileSystemDirectory) reviveDirs
0636: .get(i);
0637: inCurrentDir.add(nextDir.getName());
0638: inDsrut.addReviveDirectory(inCurrentDir, nextDir);
0639: inCurrentDir.remove(inCurrentDir.size() - 1);
0640: }
0641:
0642: //
0643: //
0644: ArrayList createFiles = getCreateFiles();
0645: for (int i = 0; i < createFiles.size(); i++) {
0646: //
0647: DocumentFileSystemFile nextFile = (DocumentFileSystemFile) createFiles
0648: .get(i);
0649: inDsrut.addCreateFile(inCurrentDir, nextFile);
0650: }
0651: //
0652: ArrayList updateFiles = getUpdateFiles();
0653: for (int i = 0; i < updateFiles.size(); i++) {
0654: //
0655: DocumentFileSystemFile nextFile = (DocumentFileSystemFile) updateFiles
0656: .get(i);
0657: inDsrut.addUpdateFile(inCurrentDir, nextFile);
0658: }
0659: //
0660: ArrayList deleteFiles = getDeleteFiles();
0661: for (int i = 0; i < deleteFiles.size(); i++) {
0662: //
0663: DocumentFileSystemFile nextFile = (DocumentFileSystemFile) deleteFiles
0664: .get(i);
0665: inDsrut.addDeleteFile(inCurrentDir, nextFile);
0666: }
0667: //
0668: ArrayList reviveFiles = getReviveFiles();
0669: for (int i = 0; i < reviveFiles.size(); i++) {
0670: //
0671: DocumentFileSystemFile nextFile = (DocumentFileSystemFile) reviveFiles
0672: .get(i);
0673: inDsrut.addReviveFile(inCurrentDir, nextFile);
0674: }
0675:
0676: //
0677: ArrayList localDirectories = getLocalDirectories();
0678: for (int i = 0; i < localDirectories.size(); i++) {
0679: DocumentFileSystemDirectoryTag nextDir = (DocumentFileSystemDirectoryTag) localDirectories
0680: .get(i);
0681: //
0682: inCurrentDir.add(nextDir.getName());
0683: nextDir.determineUpdates(inDsrut, inCurrentDir, inAlign);
0684: inCurrentDir.remove(inCurrentDir.size() - 1);
0685: }
0686: //
0687: //look at local deleted directories
0688: ArrayList deletedLocalDirectories = getSortedComponents(getDirectoriesAsHashMap(this .deletedLocalDirectoriesCtchar));
0689: for (int i = 0; i < deletedLocalDirectories.size(); i++) {
0690: DocumentFileSystemDirectoryTag nextDir = (DocumentFileSystemDirectoryTag) deletedLocalDirectories
0691: .get(i);
0692: //
0693: inCurrentDir.add(nextDir.getName());
0694: nextDir.determineUpdates(inDsrut, inCurrentDir, inAlign);
0695: inCurrentDir.remove(inCurrentDir.size() - 1);
0696: }
0697:
0698: //
0699: if (inAlign) {
0700: loadOriginalState();
0701: }
0702: }
0703:
0704: //
0705: private ArrayList getCreateDirectories() {
0706:
0707: //not in original active set, not in original delete set
0708: ArrayList outValue = null;
0709:
0710: //
0711: HashSet createDirNames = subtractNames(
0712: getLocalDirectoriesAsHashMap(),
0713: this .originalLocalDirectories);
0714: createDirNames.removeAll(this .originalDeletedLocalDirectories
0715: .keySet());
0716:
0717: //
0718: outValue = getEntriesWithNames(getLocalDirectoriesAsHashMap(),
0719: createDirNames);
0720:
0721: return outValue;
0722: }
0723:
0724: private ArrayList getDeleteDirectories() {
0725:
0726: //in original active set
0727: ArrayList outValue = null;
0728:
0729: //
0730: HashSet deleteDirNames = intersectNames(
0731: getDeletedLocalDirectoriesAsHashMap(),
0732: this .originalLocalDirectories);
0733:
0734: //
0735: outValue = getEntriesWithNames(
0736: getDeletedLocalDirectoriesAsHashMap(), deleteDirNames);
0737:
0738: return outValue;
0739: }
0740:
0741: private ArrayList getReviveDirectories() {
0742:
0743: //in original delete set
0744: ArrayList outValue = null;
0745:
0746: //
0747: HashSet reviveDirNames = intersectNames(
0748: getLocalDirectoriesAsHashMap(),
0749: this .originalDeletedLocalDirectories);
0750:
0751: //
0752: outValue = getEntriesWithNames(getLocalDirectoriesAsHashMap(),
0753: reviveDirNames);
0754:
0755: return outValue;
0756: }
0757:
0758: //
0759: //
0760: //
0761: private ArrayList getCreateFiles() {
0762:
0763: //not in original active set, not in original delete set
0764: ArrayList outValue = null;
0765:
0766: //
0767: HashSet createFiles = subtractNames(getLocalFilesAsHashMap(),
0768: this .originalLocalFiles);
0769: createFiles.removeAll(this .originalDeletedLocalFiles.keySet());
0770:
0771: //
0772: outValue = getEntriesWithNames(getLocalFilesAsHashMap(),
0773: createFiles);
0774:
0775: return outValue;
0776: }
0777:
0778: private ArrayList getUpdateFiles() {
0779:
0780: //in original active set
0781: ArrayList outValue = new ArrayList();
0782:
0783: //
0784: //
0785: //final String NOZZA = ("nozza.txt").toUpperCase();
0786: //if (isFilePresent(NOZZA)) {
0787: // VirtualSystemFile currVsf = getFile(NOZZA);
0788: // byte currCon[] = currVsf.getContent();
0789: // VirtualSystemFile origVsf =
0790: // ((VirtualSystemFile)this.originalLocalFiles.get(NOZZA));
0791: // if (origVsf != null) {
0792: // byte origCon[] = origVsf.getContent();
0793: // if (currCon[0] != origCon[0]) {
0794: // MiscHelper.println("DocSysHolTag found mismatch");
0795: // //throw new UnexpectedSystemException(
0796: // // "DocSysHolTag currCon = '" + currCon[0]
0797: // // + "', origCon = '" + origCon[0] + "'");
0798: // }
0799: // //else if (origVsf != currVsf) {
0800: // // throw new UnexpectedSystemException("Not Equal");
0801: // //}
0802: // //else if (origCon[0] == 'b') {
0803: // // throw new UnexpectedSystemException("'b' Found");
0804: // //}
0805: // //else if () {
0806: // //}
0807: // }
0808: // //MiscHelper.println("DocSysHolTag currDsf = " + currCon[0]);
0809: // //MiscHelper.println("DocSysHolTag origDsf = " + origCon[0]);
0810: // //MiscHelper.println("DocSysHolTag currDsf = "
0811: // // + ((char)currCon[0]));
0812: // //MiscHelper.println("DocSysHolTag origDsf = "
0813: // // + ((char)origCon[0]));
0814: // //MiscHelper.println("DocSysHolTag about to look at nozza.txt");
0815: //}
0816: //
0817: //
0818: HashSet currFileNames = new HashSet(getLocalFilesAsHashMap()
0819: .keySet());
0820: HashSet origFileNames = new HashSet(this .originalLocalFiles
0821: .keySet());
0822: //if (currFileNames.contains(("nozza.txt").toUpperCase())) {
0823: // MiscHelper.println("DocSysHolTag about to look at nozza.txt");
0824: //}
0825: //
0826: currFileNames.retainAll(origFileNames);
0827: //HashSet updateFiles = intersectEntries(getLocalFilesAsHashMap(),
0828: // this.originalLocalFiles);
0829:
0830: //
0831:
0832: //
0833: Iterator iter = currFileNames.iterator();
0834: while (iter.hasNext()) {
0835: String nextFileName = (String) iter.next();
0836: DocumentFileSystemFile currDsf = (DocumentFileSystemFile) getLocalFilesAsHashMap()
0837: .get(nextFileName);
0838: DocumentFileSystemFile origDsf = (DocumentFileSystemFile) this .originalLocalFiles
0839: .get(nextFileName);
0840: //if (nextFileName.equalsIgnoreCase(("nozza.txt"))) {
0841: // byte currCon[] = currDsf.getContent();
0842: // byte origCon[] = origDsf.getContent();
0843: // MiscHelper.println("DocSysHolTag currDsf = " + currCon[0]);
0844: // MiscHelper.println("DocSysHolTag origDsf = " + origCon[0]);
0845: // MiscHelper.println("DocSysHolTag currDsf = "
0846: // + ((char)currCon[0]));
0847: // MiscHelper.println("DocSysHolTag origDsf = "
0848: // + ((char)origCon[0]));
0849: // //MiscHelper.println("DocSysHolTag ab to look at nozza.txt");
0850: //}
0851: if (!currDsf.equals(origDsf)) {
0852: outValue.add(currDsf);
0853: }
0854: }
0855:
0856: return outValue;
0857: }
0858:
0859: private ArrayList getDeleteFiles() {
0860:
0861: //in original active set
0862: ArrayList outValue = null;
0863:
0864: //
0865: MiscHelper
0866: .println("DocFileSysHolTag getDeletedLocalFilesAsHashMap() = "
0867: + getDeletedLocalFilesAsHashMap());
0868: MiscHelper
0869: .println("DocFileSysHolTag this.originalLocalFiles = "
0870: + this .originalLocalFiles);
0871: HashSet deleteFileNames = intersectNames(
0872: getDeletedLocalFilesAsHashMap(),
0873: this .originalLocalFiles);
0874: MiscHelper.println("DocFileSysHolTag deleteFileNames = "
0875: + deleteFileNames);
0876:
0877: //
0878: outValue = getEntriesWithNames(getDeletedLocalFilesAsHashMap(),
0879: deleteFileNames);
0880:
0881: return outValue;
0882: }
0883:
0884: private ArrayList getReviveFiles() {
0885:
0886: //in original delete set
0887: ArrayList outValue = null;
0888:
0889: //
0890: HashSet reviveFileNames = intersectNames(
0891: getLocalFilesAsHashMap(),
0892: this .originalDeletedLocalFiles);
0893: //HashSet reviveFiles = intersectEntries(
0894: // getDeletedLocalFilesAsHashMap(),
0895: // this.originalLocalFiles);
0896:
0897: //
0898: outValue = getEntriesWithNames(getLocalFilesAsHashMap(),
0899: reviveFileNames);
0900: //outValue = new ArrayList(reviveFiles);
0901:
0902: return outValue;
0903: }
0904:
0905: //
0906: private final static HashSet subtractNames(HashMap inGroup1,
0907: HashMap inGroup2) {
0908:
0909: HashSet outValue = null;
0910:
0911: HashSet set1 = new HashSet(inGroup1.keySet());
0912: HashSet set2 = new HashSet(inGroup2.keySet());
0913:
0914: set1.removeAll(set2);
0915: outValue = set1;
0916:
0917: return outValue;
0918: }
0919:
0920: private final static HashSet subtractEntries(HashMap inGroup1,
0921: HashMap inGroup2) {
0922:
0923: HashSet outValue = null;
0924:
0925: HashSet set1 = new HashSet(inGroup1.values());
0926: HashSet set2 = new HashSet(inGroup2.values());
0927:
0928: set1.removeAll(set2);
0929: outValue = set1;
0930:
0931: return outValue;
0932: }
0933:
0934: //
0935: private final static HashSet intersectNames(HashMap inGroup1,
0936: HashMap inGroup2) {
0937:
0938: HashSet outValue = null;
0939:
0940: HashSet set1 = new HashSet(inGroup1.keySet());
0941: HashSet set2 = new HashSet(inGroup2.keySet());
0942:
0943: set1.retainAll(set2);
0944: outValue = set1;
0945:
0946: return outValue;
0947: }
0948:
0949: private final static HashSet intersectEntries(HashMap inGroup1,
0950: HashMap inGroup2) {
0951:
0952: HashSet outValue = null;
0953:
0954: HashSet set1 = new HashSet(inGroup1.values());
0955: HashSet set2 = new HashSet(inGroup2.values());
0956:
0957: set1.retainAll(set2);
0958: outValue = set1;
0959:
0960: return outValue;
0961: }
0962:
0963: private final static ArrayList getEntriesWithNames(HashMap inMap,
0964: HashSet inNames) {
0965: //
0966: ArrayList outValue = new ArrayList();
0967:
0968: Iterator iter = inMap.keySet().iterator();
0969: while (iter.hasNext()) {
0970: Object nextName = iter.next();
0971: if (inNames.contains(nextName)) {
0972: outValue.add(inMap.get(nextName));
0973: }
0974: }
0975:
0976: return outValue;
0977: }
0978:
0979: //
0980: public DocumentFileSystemHolderTag getActiveOrDeletedDirectory(
0981: ArrayList inDir, int inIndex) {
0982:
0983: DocumentFileSystemHolderTag outValue = null;
0984:
0985: if (inIndex < inDir.size()) {
0986: String nextDirName = ((String) inDir.get(inIndex))
0987: .toUpperCase();
0988: HashMap localDirs = getLocalDirectoriesAsHashMap();
0989: HashMap deletedLocalDirs = getDeletedLocalDirectoriesAsHashMap();
0990: if (localDirs.containsKey(nextDirName)) {
0991: DocumentFileSystemHolderTag nextDir = (DocumentFileSystemHolderTag) localDirs
0992: .get(nextDirName);
0993: outValue = nextDir.getActiveOrDeletedDirectory(inDir,
0994: inIndex + 1);
0995: } else if (deletedLocalDirs.containsKey(nextDirName)) {
0996: DocumentFileSystemHolderTag nextDir = (DocumentFileSystemHolderTag) deletedLocalDirs
0997: .get(nextDirName);
0998: outValue = nextDir.getActiveOrDeletedDirectory(inDir,
0999: inIndex + 1);
1000: } else {
1001: throw new UnexpectedSystemException("Directory '"
1002: + nextDirName + "' cannot be found");
1003: }
1004: } else {
1005: outValue = this ;
1006: }
1007:
1008: return outValue;
1009: }
1010:
1011: protected boolean isRemovePropogateActive() {
1012: return true;
1013: }
1014:
1015: //
1016: //protected final static String TO_STRING_INDENT = " ";
1017: protected void toString(PrintWriter inPw, boolean inDeleted,
1018: String inCurrDir, boolean inOrig) {
1019: //
1020: //
1021: //
1022: //
1023: //
1024: String paddedCurrentDir = MiscHelper.fixString("", inCurrDir
1025: .length());
1026: //
1027: if (inDeleted) {
1028: inPw.println(inCurrDir + " (Deleted Dir)");
1029: } else {
1030: inPw.println(inCurrDir + " (Current Dir)");
1031: }
1032: //
1033: //
1034: //
1035: //
1036: //
1037: ArrayList deletedLocalFiles = null;
1038: if (!inOrig) {
1039: deletedLocalFiles = getSortedComponents(getFilesAsHashMap(this .deletedLocalFilesCtchar));
1040: } else {
1041: deletedLocalFiles = getSortedComponents(this .originalDeletedLocalFiles);
1042: }
1043: for (int i = 0; i < deletedLocalFiles.size(); i++) {
1044: DocumentFileSystemFileTag nextDfsft = (DocumentFileSystemFileTag) deletedLocalFiles
1045: .get(i);
1046: //
1047: inPw.println(paddedCurrentDir + nextDfsft.getName()
1048: + " (Deleted File)");
1049: //toString(
1050: // inPw, true,
1051: // (inCurrDir + nextDfsdt.getName() + DIRECTORY_SEPARATOR),
1052: // inOrig);
1053: }
1054: //
1055: ArrayList localFiles = null;
1056: if (!inOrig) {
1057: localFiles = getSortedComponents(getFilesAsHashMap(this .localFilesCtchar));
1058: } else {
1059: localFiles = getSortedComponents(this .originalLocalFiles);
1060: }
1061: for (int i = 0; i < localFiles.size(); i++) {
1062: DocumentFileSystemFileTag nextDfsft = (DocumentFileSystemFileTag) localFiles
1063: .get(i);
1064: //
1065: inPw.println(paddedCurrentDir + nextDfsft.getName() + "("
1066: + nextDfsft.getContent().length
1067: + " bytes) (Current File)");
1068: //toString(
1069: // inPw, false,
1070: // (inCurrDir + nextDfsdt.getName() + DIRECTORY_SEPARATOR),
1071: // inOrig);
1072: }
1073: //
1074: //
1075: //
1076: //
1077: //
1078: //
1079: ArrayList deletedLocalDirectories = null;
1080: if (!inOrig) {
1081: deletedLocalDirectories = getSortedComponents(getDirectoriesAsHashMap(this .deletedLocalDirectoriesCtchar));
1082: } else {
1083: deletedLocalDirectories = getSortedComponents(this .originalDeletedLocalDirectories);
1084: }
1085: for (int i = 0; i < deletedLocalDirectories.size(); i++) {
1086: DocumentFileSystemDirectoryTag nextDfsdt = (DocumentFileSystemDirectoryTag) deletedLocalDirectories
1087: .get(i);
1088: //
1089: nextDfsdt.toString(inPw, true, (inCurrDir
1090: + nextDfsdt.getName() + DIRECTORY_SEPARATOR),
1091: inOrig);
1092: }
1093: //
1094: ArrayList localDirectories = null;
1095: if (!inOrig) {
1096: localDirectories = getSortedComponents(getDirectoriesAsHashMap(this .localDirectoriesCtchar));
1097: } else {
1098: localDirectories = getSortedComponents(this .originalLocalDirectories);
1099: }
1100: for (int i = 0; i < localDirectories.size(); i++) {
1101: DocumentFileSystemDirectoryTag nextDfsdt = (DocumentFileSystemDirectoryTag) localDirectories
1102: .get(i);
1103: //
1104: nextDfsdt.toString(inPw, false, (inCurrDir
1105: + nextDfsdt.getName() + DIRECTORY_SEPARATOR),
1106: inOrig);
1107: }
1108: }
1109: }
|