internal virtual void setDataBlockID(FsID value) { List <FsID> dbID = new List <FsID>(1); dbID.Add(value); setField(SqlFs.FSBLOCK.fsChild, dbID); }
/// <summary> /// Add an empty dir /// </summary> /// <returns> the newly created dir </returns> private SqlDir __addDir(string dirName) { if ((dirName = checkInvalidChars(dirName)) == null) { SqlFsErrCode.CurrentError = FsErr.InvalidChars; return(null); } if (__isAlreadyExist(dirName)) { SqlFsErrCode.CurrentError = FsErr.NameAlreadyExists; return(null); } FsID newID = SqlDir.addDir(db, dirName, this.ID); if (newID.compare(SqlFsConst.INVALIDID) <= 0) { SqlFsErrCode.CurrentError = FsErr.NoNewIDForNewFsNode; return(null); } if (!updateChildList(SqlFsConst.FSOP.ADD, newID, FsID.toFsID(0))) { // delete entry just created SqlFs.deleteEntryByID(db, SqlFs.DBNAMES.FsBlock.ToString(), SqlFs.FSBLOCK.fsID.ToString(), newID); return(null); } return(SqlDir.getDir(db, fsLocker, newID)); }
/// <summary> /// Get data from data block table /// </summary> /// @param [in] dataBlockID -- the data block ID /// </param> /// <returns> true if OK </returns> /// <returns> false if failed </returns> private bool __getData(SQLiteDatabase db, FsID dataBlockID) { string @where = SqlStr.genWhere(new SqlStr.SqlSimpCond(IFileData.IDCOL, "=", dataBlockID)); Cursor c = null; try { c = db.query(IFileData.DTABLENAME.ToString(), null, @where, null, null, null, null); if (c.moveToFirst()) { __getData(c); } } catch (Exception e) { Log.d("IFileData.__getData", e.Message); return(false); } finally { if (c != null) { c.close(); } } return(true); }
/// <summary> /// Add a new entry for file. File must be saved so as to be /// appeared under its parent directory. /// </summary> private SqlFile __addFile(string fileName) { if ((fileName = checkInvalidChars(fileName)) == null) { SqlFsErrCode.CurrentError = FsErr.InvalidChars; return(null); } if (__isAlreadyExist(fileName)) { SqlFsErrCode.CurrentError = FsErr.NameAlreadyExists; return(null); } FsID newID = SqlFile.addFile(db, fileName, this.ID); if (newID.compare(SqlFsConst.INVALIDID) <= 0) { SqlFsErrCode.CurrentError = FsErr.NoNewIDForNewFsNode; return(null); } if (!updateChildList(SqlFsConst.FSOP.ADD, newID, FsID.toFsID(0))) { // delete entry just created SqlFs.deleteEntryByID(db, SqlFs.DBNAMES.FsBlock.ToString(), SqlFs.FSBLOCK.fsID.ToString(), newID); return(null); } SqlFile f = SqlFile.getFile(db, fsLocker, newID); f.setDataBlockID(SqlFsConst.NOFILEDATAID); return(f); }
/// <summary> /// Get the last (autoIncrement) rowID after a 'INSERT' /// </summary> internal static FsID getLastInsertID(SQLiteDatabase db) { // retrieve the ID of the new entry FsID newID = SqlFsConst.INVALIDID; string sql = "SELECT last_insert_rowid() as [id]"; Cursor c = null; try { c = db.rawQuery(sql, null); if (c.moveToFirst()) { newID = SqlFsFunc.getID(c, 0); } } catch (Exception e) { SqlFsLog.debug(e); SqlFsErrCode.CurrentError = FsErr.GetLastInsertIDError; } finally { SqlFsFunc.close(c); } return(newID); }
/// <summary> /// Save data to data block table /// </summary> private bool __saveFileData(IFileData fileData) { bool isOK = false; do { FsID dataBlockID = this.getDataBlockID(); if (dataBlockID.compare(SqlFsConst.INVALIDID) == 0) // new file without data will be -1 { SqlFsErrCode.CurrentError = FsErr.DataBlockIDNotValid; break; } FsID newDataBlockID = fileData.saveData(db, dataBlockID); if (newDataBlockID.compare(SqlFsConst.INVALIDID) <= 0) { SqlFsErrCode.CurrentError = FsErr.SaveFileDataErr; break; } // update file size this.setField(FSBLOCK.fsFileSize, fileData.DataSizeInByte); // update itself (data block table) so that last mod time can be updated this.setDataBlockID(newDataBlockID); isOK = true; } while (false); return(isOK); }
/// <summary> /// Use a function to get ID since length of ID may be changed in future /// </summary> internal static FsID getID(Cursor cur, int index) { if (FsID.LongID) { return(FsID.toFsID(cur.getLong(index))); } return(FsID.toFsID(cur.getInt(index))); }
/// <summary> /// Move itself to a destination dir /// </summary> private bool __move(SqlDir destDir) { do { if (this.ID.Equals(SqlFsConst.ROOTDIRID)) // can't move root { SqlFsErrCode.CurrentError = FsErr.CannotMoveRoot; break; } if (this.ID.Equals(destDir.ID)) // can't move to itself { SqlFsErrCode.CurrentError = FsErr.CannotMoveToSelf; break; } if (this.Dir && destDir.isAncestor((SqlDir)this)) // if it is a DIR, can't move to its subdir { SqlFsErrCode.CurrentError = FsErr.CannotMoveToSubdir; break; } if (destDir.isAlreadyExist(this.Name)) // can't move if there is one with the same name { SqlFsErrCode.CurrentError = FsErr.NameAlreadyExists; break; } // unlink itself from parent SqlDir parent = this.Parent; if (parent == null) { SqlFsErrCode.CurrentError = FsErr.NoParent; break; } if (!parent.updateChildList(SqlFsConst.FSOP.DEL, this.ID, FsID.toFsID(0))) { break; } // update parent ID if (!setField(SqlFs.FSBLOCK.fsParent, destDir.ID)) { break; } // add itself to dest dir if (!destDir.updateChildList(SqlFsConst.FSOP.ADD, this.ID, FsID.toFsID(0))) { break; } return(true); } while (false); return(false); }
/// <summary> /// Called by SqlFile.GetFileData /// </summary> internal virtual bool getData(SQLiteDatabase db, FsID dataBlockID) { if (!__getData(db, dataBlockID)) { SqlFsErrCode.CurrentError = FsErr.GetFileDataErr; return(false); } return(true); }
/// <summary> /// Update the INT child list to db /// </summary> /// @param [in] fsOp -- ADD, REPLACE or DEL </param> /// @param [in] id1 -- id to be added or replaced or deleted </param> /// @param [in] id2 -- for REPLACE only (the new ID) </param> internal virtual bool updateChildList(SqlFsConst.FSOP fsOp, FsID id1, FsID id2) { List <FsID> childList = (List <FsID>)getField(SqlFs.FSBLOCK.fsChild); bool isMod = false; switch (fsOp) { case com.sss.sqlfs.SqlFsConst.FSOP.ADD: if (childList == null) { childList = new List <FsID>(1); // make a new one if empty } if (childList.IndexOf(id1) < 0) // add only if it is not already there { childList.Add(id1); isMod = true; } break; case com.sss.sqlfs.SqlFsConst.FSOP.REPLACE: if (childList == null) { break; } int index = childList.IndexOf(id1); if (index >= 0) { childList[index] = id2; isMod = true; } break; case com.sss.sqlfs.SqlFsConst.FSOP.DEL: if (childList == null) { break; } if (childList.Remove(id1)) { isMod = true; } break; } if (isMod) { return(setField(SqlFs.FSBLOCK.fsChild, childList)); } SqlFsErrCode.CurrentError = FsErr.ChildListNotUpdated; return(false); }
/// <summary> /// delete all dirs and files recursively /// </summary> private bool __delete() { bool isOK = false; do { // delete itself from parent if (!this.ID.Equals(SqlFsConst.ROOTDIRID)) // root has no parent { SqlDir parent = this.Parent; if (parent == null) { SqlFsErrCode.CurrentError = FsErr.NoParent; break; } if (!parent.updateChildList(SqlFsConst.FSOP.DEL, this.ID, FsID.toFsID(0))) { break; } } // delete underlying subdirs and files List <SqlFsNode> childList = this.ChildList; if (childList != null) { // delete children one by one foreach (SqlFsNode fsNode in childList) { fsNode.delete(); } } // delete itself if (this.ID.Equals(SqlFsConst.ROOTDIRID)) { // for root, just clear all children this.setField(SqlFs.FSBLOCK.fsChild, null); } else { if (!SqlFs.deleteEntryByID(db, SqlFs.DBNAMES.FsBlock.ToString(), SqlFs.FSBLOCK.fsID.ToString(), this.ID)) { SqlFsErrCode.CurrentError = FsErr.CannotDeleteFsEntry; break; } } isOK = true; } while (false); return(isOK); }
/// <summary> /// Retrieve data from data block table /// </summary> private bool __getFileData(IFileData fileData) { FsID dataBlockID = this.getDataBlockID(); if (dataBlockID.compare(SqlFsConst.INVALIDID) <= 0) { SqlFsErrCode.CurrentError = FsErr.DataBlockIDNotValid; return(false); } return(fileData.getData(db, dataBlockID)); }
private bool __delete() { bool isOK = false; do { // delete itself from parent SqlDir parent = this.Parent; if (parent == null) { SqlFsErrCode.CurrentError = FsErr.NoParent; break; } if (!parent.updateChildList(SqlFsConst.FSOP.DEL, this.ID, FsID.toFsID(0))) { break; } // delete entry in data block table FsID dataBlockID = this.getDataBlockID(); if (dataBlockID.compare(SqlFsConst.INVALIDID) <= 0) { //SqlFsLog.debug("+++ dataBlockID = " + dataBlockID.getVal()); SqlFsErrCode.CurrentError = FsErr.DataBlockIDNotValid; break; } if (!SqlFs.deleteEntryByID(db, IFileData.DTABLENAME, IFileData.IDCOL, dataBlockID)) { SqlFsErrCode.CurrentError = FsErr.CannotDeleteDataBlockEntry; break; } // delete its own entry if (!SqlFs.deleteEntryByID(db, SqlFs.DBNAMES.FsBlock.ToString(), SqlFs.FSBLOCK.fsID.ToString(), this.ID)) { SqlFsErrCode.CurrentError = FsErr.CannotDeleteFsEntry; break; } isOK = true; } while (false); return(isOK); }
/// /// <summary> /// Save data to data block table /// </summary> /// @param [in] dataBlockID -- the data block ID if exist. Pass 0 if not exist /// </param> /// <returns> dataBlockID if OK </returns> /// <returns> 0 if failed </returns> private FsID __saveData(SQLiteDatabase db, FsID dataBlockID) { ContentValues contValues = __saveData(); try { if (dataBlockID.compare(SqlFsConst.INVALIDID) <= 0) { // save new data if (db.insert(IFileData.DTABLENAME.ToString(), null, contValues) < 0) { dataBlockID = SqlFsConst.INVALIDID; } else { dataBlockID = getLastInsertID(db); } } else { // update data string @where = SqlStr.genWhere(new SqlStr.SqlSimpCond(IFileData.IDCOL, "=", dataBlockID)); if (db.update(IFileData.DTABLENAME.ToString(), contValues, @where, null) == 0) { dataBlockID = SqlFsConst.INVALIDID; } } } catch (Exception e) { Log.d("IFileData.__saveData", e.Message); dataBlockID = SqlFsConst.INVALIDID; } return(dataBlockID); }
internal static SqlDir getDir(SQLiteDatabase db, SqlFsLocker fsLocker, Cursor c) { FsID id = SqlFsFunc.getID(c, SqlFs.FSBLOCK.fsID.ordinal()); return(SqlDir.getDir(db, fsLocker, id)); }
internal static SqlDir getDir(SQLiteDatabase db, SqlFsLocker fsLocker, FsID id) { SqlDir d = new SqlDir(db, fsLocker, id); return(d); }
/// <summary> /// Create a new entry in FsBlock /// </summary> /// <returns> new ID for the inserted node </returns> internal static FsID addFsNode(SQLiteDatabase db, SqlFsConst.FSTYPE type, string dirName, FsID parentID) { long curTime = SqlFsFunc.calToFileTime(new DateTime()); List <object> colsAndValues = new List <object>(10); colsAndValues.Add(SqlFs.FSBLOCK.fsCreateTime.ToString()); colsAndValues.Add(curTime); colsAndValues.Add(SqlFs.FSBLOCK.fsLastModTime.ToString()); colsAndValues.Add(curTime); colsAndValues.Add(SqlFs.FSBLOCK.fsFileSize.ToString()); colsAndValues.Add(0); colsAndValues.Add(SqlFs.FSBLOCK.fsType.ToString()); colsAndValues.Add(type.v()); colsAndValues.Add(SqlFs.FSBLOCK.fsName.ToString()); colsAndValues.Add(dirName); colsAndValues.Add(SqlFs.FSBLOCK.fsParent.ToString()); colsAndValues.Add(parentID); ContentValues contValues = SqlStr.genContentValues(colsAndValues); try { db.insert(SqlFs.DBNAMES.FsBlock.ToString(), null, contValues); } catch (Exception e) { SqlFsLog.debug(e); SqlFsErrCode.CurrentError = FsErr.AddFsNodeError; return(SqlFsConst.INVALIDID); } // retrieve the ID of the new entry return(SqlFs.getLastInsertID(db)); }
/// <summary> /// Create an empty dir /// </summary> /// <returns> new ID for the inserted dir </returns> internal static FsID addDir(SQLiteDatabase db, string dirName, FsID parentID) { return(SqlFsNode.addFsNode(db, SqlFsConst.FSTYPE.DIR, dirName, parentID)); }
public virtual bool Equals(FsID value) { return(_fsID.Equals(value._fsID)); }
public virtual int compare(FsID value) { return(_fsID.compare(value._fsID)); }
internal virtual SqlFsNode getFsNodeByID(FsID id) { return(SqlFs.getFsNodeByID(db, fsLocker, id)); }
private SqlDir(SQLiteDatabase db, SqlFsLocker fsLocker, FsID id) : base(db, fsLocker, id) { }
/// <summary> /// Create an empty file /// </summary> /// <returns> new ID for the inserted dir </returns> internal static FsID addFile(SQLiteDatabase db, string fileName, FsID parentID) { return(SqlFsNode.addFsNode(db, SqlFsConst.FSTYPE.FILE, fileName, parentID)); }
internal static SqlFile getFile(SQLiteDatabase db, SqlFsLocker fsLocker, FsID id) { SqlFile f = new SqlFile(db, fsLocker, id); return(f); }
/// <summary> /// Called by SqlFile.SaveFileData /// </summary> internal virtual FsID saveData(SQLiteDatabase db, FsID dataBlockID) { return(__saveData(db, dataBlockID)); }
public FsID32(FsID outerInstance, int id) { this.outerInstance = outerInstance; this.id = id; }
//////////////////////////FS operations /////////////////////////////////// /// @param [in] id -- get entry using ID directly </param> internal static SqlFsNode getFsNodeByID(SQLiteDatabase db, SqlFsLocker fsLocker, FsID id) { SqlFsNode fsNode = null; string @where = SqlStr.genWhere(new SqlStr.SqlSimpCond(SqlFs.FSBLOCK.fsID.ToString(), "=", id)); Cursor c = null; try { c = db.query(SqlFs.DBNAMES.FsBlock.ToString(), new string[] { SqlFs.FSBLOCK.fsID.ToString(), SqlFs.FSBLOCK.fsType.ToString() }, @where, null, null, null, null); if (c.moveToFirst()) { fsNode = SqlFsNode.getFsNode(db, fsLocker, c); } } catch (Exception e) { SqlFsLog.debug(e); SqlFsErrCode.CurrentError = FsErr.GetFieldError; } finally { SqlFsFunc.close(c); } return(fsNode); }
protected internal SqlFsNode(SQLiteDatabase db, SqlFsLocker fsLocker, FsID id) { this.db = db; this.fsLocker = fsLocker; this.id = id; }
public FsID64(FsID outerInstance, long id) { this.outerInstance = outerInstance; this.id = id; }
/// <summary> /// Delete entry in a table using ID /// </summary> /// @param [in] tableName -- table name </param> /// @param [in] idColName -- ID column name </param> /// @param [in] id -- the actual ID </param> internal static bool deleteEntryByID(SQLiteDatabase db, string tableName, string idColName, FsID id) { string @where = SqlStr.genWhere(new SqlStr.SqlSimpCond(idColName, "=", id)); bool isOK = false; try { if (db.delete(tableName, @where, null) > 0) { isOK = true; } } catch (Exception e) { SqlFsLog.debug(e); SqlFsErrCode.CurrentError = FsErr.DeleteFsEntryError; } return(isOK); }