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);
}
