private async Task<Errorable<Ref>> getRefByName(RefName refName)
{
FileInfo fiTracker = system.getRefPathByRefName(refName);
if (!fiTracker.Exists) return new RefNameDoesNotExistError(refName);
byte[] buf;
int nr = 0;
using (var fs = new FileStream(fiTracker.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, 16384, true))
{
// TODO: implement an async buffered Stream:
buf = new byte[16384];
nr = await fs.ReadAsync(buf, 0, 16384).ConfigureAwait(continueOnCapturedContext: false);
if (nr >= 16384)
{
// My, what a large tag you have!
throw new NotSupportedException();
}
}
// Parse the CommitID:
using (var ms = new MemoryStream(buf, 0, nr, false))
using (var sr = new StreamReader(ms, Encoding.UTF8))
{
string line = sr.ReadLine();
if (line == null) return new RefNameDoesNotExistError(refName);
var ecid = CommitID.TryParse(line);
if (ecid.HasErrors) return ecid.Errors;
return (Ref)new Ref.Builder(refName, ecid.Value);
}
}
public override int GetHashCode()
{
int hashName = Name.GetHashCode(StringComparison.Ordinal);
int hashRef = RefName.GetHashCode(StringComparison.Ordinal);
int hashRes = (Resolution != null) ? Resolution.GetHashCode() : 0;
int hashUnit = (Unit != null) ? Unit.GetHashCode(StringComparison.Ordinal) : 0;
return(hashName ^ hashRef ^ hashRes ^ hashUnit);
}
public async Task <Errorable <Ref> > DeleteRefByName(RefName name)
{
// Grab the ref before we destroy it, just in case:
var rf = await db.ExecuteSingleQueryAsync(new QueryRef(name));
// Destroy it:
await db.ExecuteNonQueryAsync(new DestroyRefByName(name));
// Return the old ref data that was destroyed:
return(rf);
}
private void deleteRef(RefName name)
{
lock (FileSystem.SystemLock)
{
FileInfo fi = system.getRefPathByRefName(name);
if (fi.Exists)
{
fi.Delete();
}
}
}
public async Task <Errorable <Ref> > DeleteRefByName(RefName name)
{
var erf = await getRefByName(name).ConfigureAwait(continueOnCapturedContext: false);
if (erf.HasErrors)
{
return(erf.Errors);
}
deleteRef(name);
return(erf.Value);
}
public async Task<Errorable<Tuple<Ref, CommitTree>>> GetCommitTreeByRefName(RefName refName, int depth = 10)
{
// TODO: implement a single query to handle this
var erf = await rfrepo.GetRefByName(refName);
if (erf.HasErrors) return erf.Errors;
Ref rf = erf.Value;
var ecmtr = await db.ExecuteListQueryAsync(new QueryCommitsRecursively(rf.CommitID, depth));
if (ecmtr.HasErrors) return ecmtr.Errors;
CommitTree cmtr = ecmtr.Value;
return new Tuple<Ref, CommitTree>(rf, cmtr);
}
internal FileInfo getRefPathByRefName(RefName refName)
{
if (refName == null)
{
throw new ArgumentNullException("refName");
}
DirectoryInfo refDir = getRefsDirectory();
string[] parts = new string[1] {
refDir.FullName
}.Concat(refName.Parts).ToArray(refName.Parts.Count + 1);
string path = System.IO.Path.Combine(parts);
return(new FileInfo(path));
}
private async Task <Errorable <Ref> > getRefByName(RefName refName)
{
FileInfo fiTracker = system.getRefPathByRefName(refName);
if (!fiTracker.Exists)
{
return(new RefNameDoesNotExistError(refName));
}
byte[] buf;
int nr = 0;
using (var fs = new FileStream(fiTracker.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, 16384, true))
{
// TODO: implement an async buffered Stream:
buf = new byte[16384];
nr = await fs.ReadAsync(buf, 0, 16384).ConfigureAwait(continueOnCapturedContext: false);
if (nr >= 16384)
{
// My, what a large tag you have!
throw new NotSupportedException();
}
}
// Parse the CommitID:
using (var ms = new MemoryStream(buf, 0, nr, false))
using (var sr = new StreamReader(ms, Encoding.UTF8))
{
string line = sr.ReadLine();
if (line == null)
{
return(new RefNameDoesNotExistError(refName));
}
var ecid = CommitID.TryParse(line);
if (ecid.HasErrors)
{
return(ecid.Errors);
}
return((Ref) new Ref.Builder(refName, ecid.Value));
}
}
public override int GetHashCode()
{
int hashCode = 17; // we *know* we are using this in a dictionary, so pre-compute this
hashCode = hashCode * 23 + Id.GetHashCode();
hashCode = hashCode * 23 + (Fid == null ? 0 : Fid.GetHashCode());
hashCode = hashCode * 23 + (EnableDate == null ? 0 : EnableDate.GetHashCode());
hashCode = hashCode * 23 + (DisableDate == null ? 0 : DisableDate.GetHashCode());
hashCode = hashCode * 23 + Dr.GetHashCode();
hashCode = hashCode * 23 + Ts.GetHashCode();
hashCode = hashCode * 23 + (CreateBy == null ? 0 : CreateBy.GetHashCode());
hashCode = hashCode * 23 + (CreateDate == null ? 0 : CreateDate.GetHashCode());
hashCode = hashCode * 23 + (CreateName == null ? 0 : CreateName.GetHashCode());
hashCode = hashCode * 23 + (UpdateBy == null ? 0 : UpdateBy.GetHashCode());
hashCode = hashCode * 23 + (UpdateDate == null ? 0 : UpdateDate.GetHashCode());
hashCode = hashCode * 23 + (UpdateName == null ? 0 : UpdateName.GetHashCode());
hashCode = hashCode * 23 + (TableName == null ? 0 : TableName.GetHashCode());
hashCode = hashCode * 23 + (ColName == null ? 0 : ColName.GetHashCode());
hashCode = hashCode * 23 + (ColComment == null ? 0 : ColComment.GetHashCode());
hashCode = hashCode * 23 + (ColDefault == null ? 0 : ColDefault.GetHashCode());
hashCode = hashCode * 23 + (ColType == null ? 0 : ColType.GetHashCode());
hashCode = hashCode * 23 + ColProperty.GetHashCode();
hashCode = hashCode * 23 + ColLength.GetHashCode();
hashCode = hashCode * 23 + DisplayWidth.GetHashCode();
hashCode = hashCode * 23 + ColOrder.GetHashCode();
hashCode = hashCode * 23 + ColPrecision.GetHashCode();
hashCode = hashCode * 23 + NullAble.GetHashCode();
hashCode = hashCode * 23 + ShowAble.GetHashCode();
hashCode = hashCode * 23 + IsDefaultCol.GetHashCode();
hashCode = hashCode * 23 + (CtrlType == null ? 0 : CtrlType.GetHashCode());
hashCode = hashCode * 23 + (RefTable == null ? 0 : RefTable.GetHashCode());
hashCode = hashCode * 23 + (RefID == null ? 0 : RefID.GetHashCode());
hashCode = hashCode * 23 + (RefCode == null ? 0 : RefCode.GetHashCode());
hashCode = hashCode * 23 + (RefName == null ? 0 : RefName.GetHashCode());
hashCode = hashCode * 23 + (RefCondition == null ? 0 : RefCondition.GetHashCode());
hashCode = hashCode * 23 + (RefCols == null ? 0 : RefCols.GetHashCode());
hashCode = hashCode * 23 + (RefType == null ? 0 : RefType.GetHashCode());
hashCode = hashCode * 23 + (MainTable == null ? 0 : RefType.GetHashCode());
hashCode = hashCode * 23 + (MainTableCol == null ? 0 : MainTableCol.GetHashCode());
hashCode = hashCode * 23 + (CalculationExpr == null ? 0 : CalculationExpr.GetHashCode());
return(hashCode);
}
public async Task <Errorable <Tuple <Ref, Commit> > > GetCommitByRefName(RefName refName)
{
var erf = await rfrepo.GetRefByName(refName).ConfigureAwait(continueOnCapturedContext: false);
if (erf.HasErrors)
{
return(erf.Errors);
}
Ref rf = erf.Value;
var ecm = await getCommit(rf.CommitID).ConfigureAwait(continueOnCapturedContext: false);
if (ecm.HasErrors)
{
return(ecm.Errors);
}
Commit cm = ecm.Value;
return(new Tuple <Ref, Commit>(rf, cm));
}
protected override void Init()
{
base.Init();
_isTypeOfs = new List <bool>();
if (RefName != null)
{
var typeNames = RefName.Split(_delimiter);
foreach (var typeName in typeNames)
{
if (EntityTypeMapping.UsesIsTypeOf(typeName))
{
_isTypeOfs.Add(true);
}
else
{
_isTypeOfs.Add(false);
}
}
}
}
protected override List <NormalizedName> GetRefNameAsNormalizedNames()
{
var normalizedNamesList = new List <NormalizedName>();
if (RefName != null)
{
var newRefNames = RefName.Split(_delimiter);
foreach (var newRefName in newRefNames)
{
if (_nameNormalizer == null)
{
var symbol = new Symbol(newRefName);
normalizedNamesList.Add(new NormalizedName(symbol, null, null, newRefName));
}
else
{
normalizedNamesList.Add(_nameNormalizer(Parent as EFElement, newRefName));
}
}
}
return(normalizedNamesList);
}
public QueryRef(RefName name)
{
this._name = name;
}
public QueryCommitByRefName(RefName refName)
{
this._refName = refName;
}
private void deleteRef(RefName name)
{
lock (FileSystem.SystemLock)
{
FileInfo fi = system.getRefPathByRefName(name);
if (fi.Exists) fi.Delete();
}
}
public async Task <Errorable <Tuple <Ref, CommitTree> > > GetCommitTreeByRefName(RefName refName, int depth = 10)
{
// TODO: implement a single query to handle this
var erf = await rfrepo.GetRefByName(refName);
if (erf.HasErrors)
{
return(erf.Errors);
}
Ref rf = erf.Value;
var ecmtr = await db.ExecuteListQueryAsync(new QueryCommitsRecursively(rf.CommitID, depth));
if (ecmtr.HasErrors)
{
return(ecmtr.Errors);
}
CommitTree cmtr = ecmtr.Value;
return(new Tuple <Ref, CommitTree>(rf, cmtr));
}
public Task<Errorable<Tuple<Ref, Commit>>> GetCommitByRefName(RefName refName)
{
return db.ExecuteSingleQueryAsync(new QueryCommitByRefName(refName));
}
public RefNameDoesNotExistError(RefName refName) : base("A ref with ref name '{0}' does not exist", refName) { }
public RefNameDoesNotExistError(RefName refName) : base("A ref with ref name '{0}' does not exist", refName)
{
}
public Builder(
RefName pName
,CommitID pCommitID
)
{
this.Name = pName;
this.CommitID = pCommitID;
}
public async Task <Errorable <Tuple <Ref, CommitTree> > > GetCommitTreeByRefName(RefName refName, int depth = 10)
{
var erf = await rfrepo.GetRefByName(refName).ConfigureAwait(continueOnCapturedContext: false);
if (erf.HasErrors)
{
return(erf.Errors);
}
Ref rf = erf.Value;
var eall = await getCommitsRecursively(rf.CommitID, 1, depth).ConfigureAwait(continueOnCapturedContext: false);
if (eall.HasErrors)
{
return(eall.Errors);
}
var all = eall.Value;
// Return them (all[0] is the root):
return(new Tuple <Ref, CommitTree>(
rf,
new CommitTree(all[0].ID, new ImmutableContainer <CommitID, ICommit>(cm => cm.ID, all))
));
}
private void UpdateRefNameUsingReplacement(string toBeReplaced, string replacement, RefNameReplacementPart partToBeReplaced)
{
Debug.Assert(
!string.IsNullOrEmpty(toBeReplaced),
GetType().FullName + ".UpdateRefNameUsingReplacement(): toBeReplaced must not null or empty");
Debug.Assert(
!string.IsNullOrEmpty(replacement),
GetType().FullName + ".UpdateRefNameUsingReplacement(): replacement must not null or empty");
if (string.IsNullOrEmpty(toBeReplaced) ||
string.IsNullOrEmpty(replacement))
{
return;
}
var refNameAsNormalizedNames = GetRefNameAsNormalizedNames();
if (1 != refNameAsNormalizedNames.Count)
{
Debug.Fail(
GetType().FullName
+ ".UpdateRefNameUsingReplacement(): expecting only 1 symbol from GetRefNameAsNormalizedNames(). Received "
+ refNameAsNormalizedNames.Count);
return;
}
// replace toBeReplaced with replacement if present in the correct part
var refNameAsNameRef = refNameAsNormalizedNames[0];
var madeReplacement = false;
string replacementRefName;
if (RefNameReplacementPart.NamespacePart == partToBeReplaced)
{
if (refNameAsNameRef.ConstructBindingStringWithReplacedNamespace(
toBeReplaced, replacement, out replacementRefName))
{
madeReplacement = true;
}
}
else if (RefNameReplacementPart.AliasPart == partToBeReplaced)
{
if (refNameAsNameRef.ConstructBindingStringWithReplacedAlias(
toBeReplaced, replacement, out replacementRefName))
{
madeReplacement = true;
}
}
else
{
if (refNameAsNameRef.ConstructBindingStringWithReplacedNamePart(
toBeReplaced, replacement, out replacementRefName))
{
madeReplacement = true;
}
}
// if any replacement was made above then unbind the Binding and
// replace the underlying attribute value
if (madeReplacement)
{
Debug.Assert(
replacementRefName != RefName,
"UpdateRefNameNamespaceOrAlias() is about to replace the following RefName with an identical value " + RefName);
Unbind();
// For most scenarios, RefName should be equal to refNameAsNameRef.ToBindingString()
// But in FunctionImport's Return, the values are as follow:
// RefName : "Collection([Old Fully-qualifed EntityType/ComplexType])"
// refNameasNameRef.ToBindingString(): [Old Fully-qualifed EntityType/ComplexType]
// replacementRefName: [New Fully-qualifed EntityType/ComplexType]
if (String.Compare(RefName, refNameAsNameRef.ToBindingString(), StringComparison.CurrentCulture) != 0)
{
replacementRefName = RefName.Replace(refNameAsNameRef.ToBindingString(), replacementRefName);
}
SetXAttributeValue(replacementRefName);
}
else
{
Debug.Assert(
replacementRefName == RefName,
"UpdateRefNameNamespaceOrAlias() for RefName, " + RefName
+ ", is about to ignore the following replacement string which is different " + replacementRefName);
}
}
public async Task<Errorable<Tuple<Ref, CommitTree>>> GetCommitTreeByRefName(RefName refName, int depth = 10)
{
var erf = await rfrepo.GetRefByName(refName).ConfigureAwait(continueOnCapturedContext: false);
if (erf.HasErrors) return erf.Errors;
Ref rf = erf.Value;
var eall = await getCommitsRecursively(rf.CommitID, 1, depth).ConfigureAwait(continueOnCapturedContext: false);
if (eall.HasErrors) return eall.Errors;
var all = eall.Value;
// Return them (all[0] is the root):
return new Tuple<Ref, CommitTree>(
rf,
new CommitTree(all[0].ID, new ImmutableContainer<CommitID, ICommit>(cm => cm.ID, all))
);
}
public async Task<Errorable<Tuple<Ref, Commit>>> GetCommitByRefName(RefName refName)
{
var erf = await rfrepo.GetRefByName(refName).ConfigureAwait(continueOnCapturedContext: false);
if (erf.HasErrors) return erf.Errors;
Ref rf = erf.Value;
var ecm = await getCommit(rf.CommitID).ConfigureAwait(continueOnCapturedContext: false);
if (ecm.HasErrors) return ecm.Errors;
Commit cm = ecm.Value;
return new Tuple<Ref, Commit>(rf, cm);
}
public Task <Errorable <Ref> > GetRefByName(RefName name)
{
return(db.ExecuteSingleQueryAsync(new QueryRef(name)));
}
public Task<Errorable<Ref>> GetRefByName(RefName name)
{
return getRefByName(name);
}
public Task <Errorable <Ref> > GetRefByName(RefName name)
{
return(getRefByName(name));
}
public async Task<Errorable<Ref>> DeleteRefByName(RefName name)
{
var erf = await getRefByName(name).ConfigureAwait(continueOnCapturedContext: false);
if (erf.HasErrors) return erf.Errors;
deleteRef(name);
return erf.Value;
}
public Task <Errorable <Tuple <Ref, Commit> > > GetCommitByRefName(RefName refName)
{
return(db.ExecuteSingleQueryAsync(new QueryCommitByRefName(refName)));
}
public DestroyRefByName(RefName refName)
{
this._refName = refName;
}
/// <summary>
/// 哈希表
/// </summary>
/// <returns></returns>
public override int GetHashCode()
{
return(RefName.GetHashCode() * 13 + RovName.GetHashCode() * 5);
}
internal FileInfo getRefPathByRefName(RefName refName)
{
if (refName == null) throw new ArgumentNullException("refName");
DirectoryInfo refDir = getRefsDirectory();
string[] parts = new string[1] { refDir.FullName }.Concat(refName.Parts).ToArray(refName.Parts.Count + 1);
string path = System.IO.Path.Combine(parts);
return new FileInfo(path);
}
