// <summary>This method is applicable only to objects represnting types and
// checks if this type is the same or subtype of specified type</summary>
/// <param name="superType">version history representing object type</param>
/// <param name="kind">search kind</param>
/// <param name="timestamp">timestamp used to locate version</param>
/// <returns>true if this type is the same or is subtype of specified type</returns>
public bool IsSubTypeOf(VersionHistory superType, SearchKind kind, DateTime timestamp)
{
if (vh == superType)
{
return(true);
}
foreach (VersionHistory subtype in this[Symbols.Subtype])
{
if (kind == SearchKind.AllVersions)
{
foreach (Thing type in subtype.versions)
{
if (type.IsSubTypeOf(superType, kind, timestamp))
{
return(true);
}
}
}
else
{
Thing type = subtype.GetVersion(kind, timestamp);
if (type != null && type.IsSubTypeOf(superType, kind, timestamp))
{
return(true);
}
}
}
return(false);
}
// <summary>This method is applicable only to objects represnting types and
// checks if this type is the same or subtype of specified type</summary>
/// <param name="superType">version history representing object type</param>
/// <param name="kind">search kind</param>
/// <param name="timestamp">timestamp used to locate version</param>
/// <returns>true if this type is the same or is subtype of specified type</returns>
public bool IsSubTypeOf(VersionHistory superType, SearchKind kind, DateTime timestamp)
{
if (vh == superType)
{
return true;
}
foreach (VersionHistory subtype in this[Symbols.Subtype])
{
if (kind == SearchKind.AllVersions)
{
foreach (Thing type in subtype.versions)
{
if (type.IsSubTypeOf(superType, kind, timestamp))
{
return true;
}
}
}
else
{
Thing type = subtype.GetVersion(kind, timestamp);
if (type != null && type.IsSubTypeOf(superType, kind, timestamp))
{
return true;
}
}
}
return false;
}
/// <summary>Get verion history by URI and timestamp</summary>
/// <param name="uri">object URI</param>
/// <param name="kind">search kind, should be object SearchKind.LatestVersion, SearchKind.LatestBefore or
/// SearchKind.OldestAfter</param>
/// <param name="timestamp">timestamp used to locate version</param>
/// <returns>version of the object or null if no such version is found</returns>
public Thing GetVersion(string uri, SearchKind kind, DateTime timestamp)
{
VersionHistory vh = (VersionHistory)root.prefixUriIndex[uri];
if (vh != null)
{
return(vh.GetVersion(kind, timestamp));
}
return(null);
}
public SearchResult(DatabaseRoot root, VersionHistory type, string uri, NameVal[] patterns, SearchKind kind, DateTime timestamp, IEnumerator iterator)
{
this.root = root;
this.type = type;
this.uri = uri;
this.patterns = patterns;
this.kind = kind;
this.timestamp = timestamp;
this.iterator = iterator;
}
private void CreateMetaType()
{
VersionHistory vh = CreateVersionHistory(Symbols.Metatype, null);
vh.type = vh;
Thing metatype = CreateObject(null, vh, new NameVal[0]);
metatype.type = metatype;
root.metatype = vh;
}
private VersionHistory CreateVersionHistory(String uri, VersionHistory type)
{
VersionHistory vh = new VersionHistory();
vh.uri = uri;
vh.type = type;
vh.versions = db.CreateLink();
root.prefixUriIndex.Put(uri, vh);
root.suffixUriIndex.Put(ReverseString(uri), vh);
return(vh);
}
private NameVal CreateProperty(string name, string val)
{
if (name.Equals(XmlSymbols.Subtype))
{
VersionHistory vh = store.GetObject(val);
if (vh == null)
{
throw new XmlException("Object with URI '" + val + "' is not found");
}
return(new NameVal(name, vh));
}
else
{
return(new NameVal(name, ConvertValue(val)));
}
}
/// <summary>Create bew object. If version history with this URI is not exists, it is created first.
/// Then new object version is created and appended to this version history.
/// </summary>
/// <param name="uri">object URI</param>
/// <param name="type">URI of object type</param>
/// <param name="props">object properties</param>
/// <returns>created object version</returns>
public Thing CreateObject(string uri, string type, NameVal[] props)
{
VersionHistory vh = (VersionHistory)root.prefixUriIndex[uri];
if (vh == null)
{
VersionHistory typeVh = null;
typeVh = GetObject(type);
if (typeVh == null)
{
typeVh = CreateVersionHistory(type, root.metatype);
CreateObject(root.metatype.Latest, typeVh, new NameVal[0]);
}
vh = CreateVersionHistory(uri, typeVh);
}
else
{
root.latest.Remove(vh.Latest);
}
return(CreateObject(vh.type.Latest, vh, props));
}
private bool FollowReference(NameVal prop, VersionHistory vh)
{
if (vh != null)
{
if (kind == SearchKind.AllVersions)
{
foreach (Thing v in vh.versions)
{
if (MatchProperty(prop, v))
{
return(true);
}
}
}
else
{
Thing thing = vh.GetVersion(kind, timestamp);
return(thing != null && MatchProperty(prop, thing));
}
}
return(false);
}
static void DumpObject(Thing thing, TextWriter writer, int indent, SearchKind kind, DateTime timestamp, int depth)
{
WriteTab(writer, indent);
string typeName = GetQualifiedName(thing.type.vh.uri, writer);
writer.WriteLine(" rdf:about=\"" + thing.vh.uri + "\" vr:timestamp=\"" + thing.timestamp + "\">");
foreach (PropVal pv in thing.props)
{
object val = pv.val;
if (val is VersionHistory)
{
VersionHistory ptr = (VersionHistory)val;
if (kind != SearchKind.AllVersions)
{
if (depth > 0 || ptr.uri.StartsWith(thing.vh.uri))
{
Thing t = ptr.GetVersion(kind, timestamp);
if (t != null)
{
DumpObject(t, writer, indent + 1, kind, timestamp, depth - 1);
continue;
}
}
}
WriteTab(writer, indent + 1);
GetQualifiedName(pv.def.name, writer);
writer.WriteLine(" rdf:resource=\"" + ptr.uri + "\"/>");
}
else
{
WriteTab(writer, indent + 1);
string propName = GetQualifiedName(pv.def.name, writer);
writer.WriteLine(">" + val + "</" + propName + ">");
}
}
WriteTab(writer, indent);
writer.WriteLine("</" + typeName + ">");
}
private VersionHistory CreateVersionHistory(String uri, VersionHistory type)
{
VersionHistory vh = new VersionHistory();
vh.uri = uri;
vh.type = type;
vh.versions = db.CreateLink();
root.prefixUriIndex.Put(uri, vh);
root.suffixUriIndex.Put(ReverseString(uri), vh);
return vh;
}
private Thing CreateObject(Thing type, VersionHistory vh, NameVal[] props)
{
Thing thing = new Thing();
thing.vh = vh;
thing.type = type;
thing.timestamp = DateTime.Now;
thing.props = new PropVal[props.Length];
for (int i = 0; i < props.Length; i++)
{
NameVal prop = props[i];
PropDef def = (PropDef)root.propDefIndex[prop.name];
if (def == null)
{
def = new PropDef();
def.name = prop.name;
root.propDefIndex.Put(def);
}
object val = prop.val;
PropVal pv = new PropVal(def, val);
Key key = new Key(new object[] { def, val });
if (val is string)
{
root.strPropIndex.Put(key, thing);
foreach (string keyword in ((string)val).ToLower().Split(keywordSeparators))
{
if (keyword.Length > 0 && !keywordStopList.ContainsKey(keyword))
{
root.inverseIndex.Put(keyword, thing);
}
}
}
else if (val is double)
{
root.numPropIndex.Put(key, thing);
}
else if (val is DateTime)
{
root.timePropIndex.Put(key, thing);
}
else if (val is VersionHistory || val == null)
{
root.refPropIndex.Put(key, thing);
if (prop.name == Symbols.Rectangle)
{
PropVal[] coord = ((VersionHistory)val).Latest.props;
RectangleR2 r = new RectangleR2((double)coord[0].val,
(double)coord[1].val,
(double)coord[2].val,
(double)coord[3].val);
root.spatialIndex.Put(r, thing);
}
else if (prop.name == Symbols.Point)
{
PropVal[] coord = ((VersionHistory)val).Latest.props;
double x = (double)coord[0].val;
double y = (double)coord[1].val;
RectangleR2 r = new RectangleR2(x, y, x, y);
root.spatialIndex.Put(r, thing);
}
}
else
{
throw new InvalidOperationException("Invalid propery value type " + prop.val.GetType());
}
thing.props[i] = pv;
}
thing.Modify();
vh.versions.Add(thing);
root.timeIndex.Put(thing);
root.latest.Add(thing);
return(thing);
}
/// <summary>Check if object belongs to the partiular type</summary>
/// <param name="superType">version history representing object type</param>
/// <param name="kind">search kind</param>
/// <param name="timestamp">timestamp used to locate version</param>
/// <returns>true if type of the object is the same or is subtype of specified type</returns>
public bool IsInstanceOf(VersionHistory superType, SearchKind kind, DateTime timestamp)
{
return type.IsSubTypeOf(superType, kind, timestamp);
}
/// <summary>Get latest verion of object with specified URI</summary>
/// <param name="uri">object URI</param>
/// <returns>latest version of object or null if no such object is found</returns>
public Thing GetLatestVersion(string uri)
{
VersionHistory vh = (VersionHistory)root.prefixUriIndex[uri];
return((vh != null) ? vh.Latest : null);
}
/// <summary>Check if object belongs to the partiular type</summary>
/// <param name="superType">version history representing object type</param>
/// <param name="kind">search kind</param>
/// <param name="timestamp">timestamp used to locate version</param>
/// <returns>true if type of the object is the same or is subtype of specified type</returns>
public bool IsInstanceOf(VersionHistory superType, SearchKind kind, DateTime timestamp)
{
return(type.IsSubTypeOf(superType, kind, timestamp));
}
private bool FollowReference(NameVal prop, VersionHistory vh)
{
if (vh != null)
{
if (kind == SearchKind.AllVersions)
{
foreach (Thing v in vh.versions)
{
if (MatchProperty(prop, v))
{
return true;
}
}
}
else
{
Thing thing = vh.GetVersion(kind, timestamp);
return thing != null && MatchProperty(prop, thing);
}
}
return false;
}
public SearchResult(DatabaseRoot root, VersionHistory type, string uri, NameVal[] patterns, SearchKind kind, DateTime timestamp, IEnumerator iterator)
{
this.root = root;
this.type = type;
this.uri = uri;
this.patterns = patterns;
this.kind = kind;
this.timestamp = timestamp;
this.iterator = iterator;
}
private IEnumerable SearchReferenceProperty(VersionHistory type, string uri, NameVal[] patterns, SearchKind kind, DateTime timestamp, NameVal prop, bool compound, PropDef def, ArrayList refs)
{
refs.Add(def);
NameVal[] restOfPatterns = compound ? patterns : SubArray(patterns);
object val = prop.val;
switch (prop.name)
{
case Symbols.Timestamp:
if (val is Range)
{
Range range = (Range)val;
if (range.from is DateTime)
{
Key fromKey = new Key((DateTime)range.from, range.fromInclusive);
Key tillKey = new Key((DateTime)range.till, range.tillInclusive);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timeIndex.GetEnumerator(fromKey, tillKey), kind, timestamp));
}
}
else if (val is DateTime)
{
Key key = new Key((DateTime)val);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timeIndex.GetEnumerator(key, key), kind, timestamp));
}
return new object[0]; // empty selection
case Symbols.Rectangle:
if (val is NameVal[])
{
NameVal[] coord = (NameVal[])val;
if (coord.Length == 4)
{
RectangleR2 r = new RectangleR2((double)coord[0].val,
(double)coord[1].val,
(double)coord[2].val,
(double)coord[3].val);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.spatialIndex.Overlaps(r).GetEnumerator(), kind, timestamp));
}
}
break;
case Symbols.Point:
if (val is NameVal[])
{
NameVal[] coord = (NameVal[])val;
if (coord.Length == 2)
{
double x = (double)coord[0].val;
double y = (double)coord[1].val;
RectangleR2 r = new RectangleR2(x, y, x, y);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.spatialIndex.Overlaps(r).GetEnumerator(), kind, timestamp));
}
}
break;
case Symbols.Keyword:
if (val is string)
{
ArrayList keywords = new ArrayList();
foreach (string keyword in ((string)val).ToLower().Split(keywordSeparators))
{
if (keyword.Length > 0 && !keywordStopList.ContainsKey(keyword))
{
keywords.Add(keyword);
}
}
IEnumerator[] occurences = new IEnumerator[keywords.Count];
for (int i = 0; i < occurences.Length; i++)
{
Key key = new Key((string)keywords[i]);
occurences[i] = root.inverseIndex.GetEnumerator(key, key);
}
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
db.Merge(occurences), kind, timestamp));
}
break;
}
def = (PropDef)root.propDefIndex[prop.name];
if (def == null)
{
return new object[0]; // empty selection
}
if (val is Range)
{
Range range = (Range)val;
if (range.from is double)
{
Key fromKey = new Key(new object[]{def, range.from}, range.fromInclusive);
Key tillKey = new Key(new object[]{def, range.till}, range.tillInclusive);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.numPropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp));
}
else if (range.from is DateTime)
{
Key fromKey = new Key(new object[]{def, range.from}, range.fromInclusive);
Key tillKey = new Key(new object[]{def, range.till}, range.tillInclusive);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timePropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp));
}
else
{
Key fromKey = new Key(new object[]{def, range.from}, range.fromInclusive);
Key tillKey = new Key(new object[]{def, range.till}, range.tillInclusive);
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.strPropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp));
}
}
if (val is string)
{
string str = (string)prop.val;
int wc = str.IndexOf('*');
if (wc < 0)
{
Key key = new Key(new object[]{def, str});
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.strPropIndex.GetEnumerator(key, key), kind, timestamp));
}
else if (wc > 0)
{
string prefix = str.Substring(0, wc);
Key fromKey = new Key(new object[]{def, prefix});
Key tillKey = new Key(new object[]{def, prefix + Char.MaxValue}, false);
return new SearchResult(root, type, uri, wc == str.Length-1 ? restOfPatterns : patterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.strPropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp));
}
}
else if (val is double)
{
Key key = new Key(new object[]{def, val});
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.numPropIndex.GetEnumerator(key, key), kind, timestamp));
}
else if (val is DateTime)
{
Key key = new Key(new object[]{def, (DateTime)val});
return new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timePropIndex.GetEnumerator(key, key), kind, timestamp));
}
else if (val is NameVal)
{
return SearchReferenceProperty(type, uri, patterns, kind, timestamp, (NameVal)val, compound, def, refs);
}
else if (val is NameVal[])
{
NameVal[] props = (NameVal[])val;
if (props.Length > 0)
{
return SearchReferenceProperty(type, uri, patterns, kind, timestamp, props[0], true, def, refs);
}
}
return null;
}
private Thing CreateObject(Thing type, VersionHistory vh, NameVal[] props)
{
Thing thing = new Thing();
thing.vh = vh;
thing.type = type;
thing.timestamp = DateTime.Now;
thing.props = new PropVal[props.Length];
for (int i = 0; i < props.Length; i++)
{
NameVal prop = props[i];
PropDef def = (PropDef)root.propDefIndex[prop.name];
if (def == null)
{
def = new PropDef();
def.name = prop.name;
root.propDefIndex.Put(def);
}
object val = prop.val;
PropVal pv = new PropVal(def, val);
Key key = new Key(new object[]{def, val});
if (val is string)
{
root.strPropIndex.Put(key, thing);
foreach (string keyword in ((string)val).ToLower().Split(keywordSeparators))
{
if (keyword.Length > 0 && !keywordStopList.ContainsKey(keyword))
{
root.inverseIndex.Put(keyword, thing);
}
}
}
else if (val is double)
{
root.numPropIndex.Put(key, thing);
}
else if (val is DateTime)
{
root.timePropIndex.Put(key, thing);
}
else if (val is VersionHistory || val == null)
{
root.refPropIndex.Put(key, thing);
if (prop.name == Symbols.Rectangle)
{
PropVal[] coord = ((VersionHistory)val).Latest.props;
RectangleR2 r = new RectangleR2((double)coord[0].val,
(double)coord[1].val,
(double)coord[2].val,
(double)coord[3].val);
root.spatialIndex.Put(r, thing);
}
else if (prop.name == Symbols.Point)
{
PropVal[] coord = ((VersionHistory)val).Latest.props;
double x = (double)coord[0].val;
double y = (double)coord[1].val;
RectangleR2 r = new RectangleR2(x, y, x, y);
root.spatialIndex.Put(r, thing);
}
}
else
{
throw new InvalidOperationException("Invalid propery value type " + prop.val.GetType());
}
thing.props[i] = pv;
}
thing.Modify();
vh.versions.Add(thing);
root.timeIndex.Put(thing);
root.latest.Add(thing);
return thing;
}
/// <summary>Get iterator through object matching specified search parameters</summary>
/// <param name="type">String representing type of the object (direct or indirect - IsInstanceOf
/// method will be used to check if object belongs to the specified type). It may be null,
/// in this case type criteria is skipped.</param>
/// <param name="uri">Object URI pattern. It may be null, in this case URI is not inspected.</param>
/// <param name="patterns">array of name:value pairs specifying search condition for object properties</param>
/// <param name="kind">search kind used to select inspected versions</param>
/// <param name="timestamp">timestamp used to select versions, if kind is SearchKind.LatestVersion
/// or SearchKind.AllVersions this parameter is ignored</param>
/// <returns>Enumerator through object meet search criteria.</returns>
public IEnumerable Search(string type, string uri, NameVal[] patterns, SearchKind kind, DateTime timestamp)
{
VersionHistory typeVh = null;
root.SharedLock();
try
{
if (type != null)
{
typeVh = GetObject(type);
if (typeVh == null)
{
return(new object[0]); // empty selection
}
}
if (uri != null)
{
int wc = uri.IndexOf('*');
if (wc < 0)
{
return(new SearchResult(root, typeVh, null, patterns, kind, timestamp, root.prefixUriIndex.GetEnumerator(uri, uri)));
}
else if (wc > 0)
{
String prefix = uri.Substring(0, wc);
return(new SearchResult(root, typeVh, uri, patterns, kind, timestamp, root.prefixUriIndex.GetEnumerator(prefix)));
}
else if ((wc = uri.LastIndexOf('*')) < uri.Length - 1)
{
String suffix = ReverseString(uri.Substring(wc + 1, uri.Length - wc - 1));
return(new SearchResult(root, typeVh, uri, patterns, kind, timestamp, root.suffixUriIndex.GetEnumerator(suffix)));
}
}
if (patterns.Length > 0)
{
NameVal prop = patterns[0];
object val = prop.val;
NameVal[] restOfPatterns = SubArray(patterns);
switch (prop.name)
{
case Symbols.Timestamp:
if (val is Range)
{
Range range = (Range)val;
if (range.from is DateTime)
{
Key fromKey = new Key((DateTime)range.from, range.fromInclusive);
Key tillKey = new Key((DateTime)range.till, range.tillInclusive);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.timeIndex.GetEnumerator(fromKey, tillKey)));
}
}
else if (val is DateTime)
{
Key key = new Key((DateTime)val);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.timeIndex.GetEnumerator(key, key)));
}
return(new object[0]); // empty selection
case Symbols.Rectangle:
if (val is NameVal[])
{
NameVal[] coord = (NameVal[])val;
if (coord.Length == 4)
{
RectangleR2 r = new RectangleR2((double)coord[0].val,
(double)coord[1].val,
(double)coord[2].val,
(double)coord[3].val);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.spatialIndex.Overlaps(r).GetEnumerator()));
}
}
break;
case Symbols.Point:
if (val is NameVal[])
{
NameVal[] coord = (NameVal[])val;
if (coord.Length == 2)
{
double x = (double)coord[0].val;
double y = (double)coord[1].val;
RectangleR2 r = new RectangleR2(x, y, x, y);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.spatialIndex.Overlaps(r).GetEnumerator()));
}
}
break;
case Symbols.Keyword:
if (val is string)
{
ArrayList keywords = new ArrayList();
foreach (string keyword in ((string)val).ToLower().Split(keywordSeparators))
{
if (keyword.Length > 0 && !keywordStopList.ContainsKey(keyword))
{
keywords.Add(keyword);
}
}
IEnumerator[] occurences = new IEnumerator[keywords.Count];
for (int i = 0; i < occurences.Length; i++)
{
Key key = new Key((string)keywords[i]);
occurences[i] = root.inverseIndex.GetEnumerator(key, key);
}
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp, db.Merge(occurences)));
}
break;
}
PropDef def = (PropDef)root.propDefIndex[prop.name];
if (def == null)
{
return(new object[0]); // empty selection
}
if (val is Range)
{
Range range = (Range)val;
if (range.from is double)
{
Key fromKey = new Key(new object[] { def, range.from }, range.fromInclusive);
Key tillKey = new Key(new object[] { def, range.till }, range.tillInclusive);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.numPropIndex.GetEnumerator(fromKey, tillKey)));
}
else if (range.from is DateTime)
{
Key fromKey = new Key(new object[] { def, range.from }, range.fromInclusive);
Key tillKey = new Key(new object[] { def, range.till }, range.tillInclusive);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.timePropIndex.GetEnumerator(fromKey, tillKey)));
}
else
{
Key fromKey = new Key(new object[] { def, range.from }, range.fromInclusive);
Key tillKey = new Key(new object[] { def, range.till }, range.tillInclusive);
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.strPropIndex.GetEnumerator(fromKey, tillKey)));
}
}
else if (val is string)
{
string str = (string)val;
int wc = str.IndexOf('*');
if (wc < 0)
{
Key key = new Key(new object[] { def, str });
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.strPropIndex.GetEnumerator(key, key)));
}
else if (wc > 0)
{
string prefix = str.Substring(0, wc);
Key fromKey = new Key(new object[] { def, prefix });
Key tillKey = new Key(new object[] { def, prefix + Char.MaxValue }, false);
return(new SearchResult(root, typeVh, uri, wc == str.Length - 1 ? restOfPatterns : patterns, kind, timestamp,
root.strPropIndex.GetEnumerator(fromKey, tillKey)));
}
}
else if (val is double)
{
Key key = new Key(new object[] { def, val });
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.numPropIndex.GetEnumerator(key, key)));
}
else if (val is DateTime)
{
Key key = new Key(new object[] { def, val });
return(new SearchResult(root, typeVh, uri, restOfPatterns, kind, timestamp,
root.timePropIndex.GetEnumerator(key, key)));
}
else if (val is NameVal)
{
IEnumerable iterator = SearchReferenceProperty(typeVh, uri, patterns, kind, timestamp, (NameVal)val, false, def, new ArrayList());
if (iterator != null)
{
return(iterator);
}
}
else if (val is NameVal[])
{
NameVal[] props = (NameVal[])val;
if (props.Length > 0)
{
IEnumerable iterator = SearchReferenceProperty(typeVh, uri, patterns, kind, timestamp, props[0], props.Length > 1, def, new ArrayList());
if (iterator != null)
{
return(iterator);
}
}
}
}
if (kind == SearchKind.LatestVersion)
{
return(new SearchResult(root, typeVh, uri, patterns, kind, timestamp, root.latest.GetEnumerator()));
}
return(new SearchResult(root, typeVh, uri, patterns, kind, timestamp, root.timeIndex.GetEnumerator()));
}
finally
{
root.Unlock();
}
}
private IEnumerable SearchReferenceProperty(VersionHistory type, string uri, NameVal[] patterns, SearchKind kind, DateTime timestamp, NameVal prop, bool compound, PropDef def, ArrayList refs)
{
refs.Add(def);
NameVal[] restOfPatterns = compound ? patterns : SubArray(patterns);
object val = prop.val;
switch (prop.name)
{
case Symbols.Timestamp:
if (val is Range)
{
Range range = (Range)val;
if (range.from is DateTime)
{
Key fromKey = new Key((DateTime)range.from, range.fromInclusive);
Key tillKey = new Key((DateTime)range.till, range.tillInclusive);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timeIndex.GetEnumerator(fromKey, tillKey), kind, timestamp)));
}
}
else if (val is DateTime)
{
Key key = new Key((DateTime)val);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timeIndex.GetEnumerator(key, key), kind, timestamp)));
}
return(new object[0]); // empty selection
case Symbols.Rectangle:
if (val is NameVal[])
{
NameVal[] coord = (NameVal[])val;
if (coord.Length == 4)
{
RectangleR2 r = new RectangleR2((double)coord[0].val,
(double)coord[1].val,
(double)coord[2].val,
(double)coord[3].val);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.spatialIndex.Overlaps(r).GetEnumerator(), kind, timestamp)));
}
}
break;
case Symbols.Point:
if (val is NameVal[])
{
NameVal[] coord = (NameVal[])val;
if (coord.Length == 2)
{
double x = (double)coord[0].val;
double y = (double)coord[1].val;
RectangleR2 r = new RectangleR2(x, y, x, y);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.spatialIndex.Overlaps(r).GetEnumerator(), kind, timestamp)));
}
}
break;
case Symbols.Keyword:
if (val is string)
{
ArrayList keywords = new ArrayList();
foreach (string keyword in ((string)val).ToLower().Split(keywordSeparators))
{
if (keyword.Length > 0 && !keywordStopList.ContainsKey(keyword))
{
keywords.Add(keyword);
}
}
IEnumerator[] occurences = new IEnumerator[keywords.Count];
for (int i = 0; i < occurences.Length; i++)
{
Key key = new Key((string)keywords[i]);
occurences[i] = root.inverseIndex.GetEnumerator(key, key);
}
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
db.Merge(occurences), kind, timestamp)));
}
break;
}
def = (PropDef)root.propDefIndex[prop.name];
if (def == null)
{
return(new object[0]); // empty selection
}
if (val is Range)
{
Range range = (Range)val;
if (range.from is double)
{
Key fromKey = new Key(new object[] { def, range.from }, range.fromInclusive);
Key tillKey = new Key(new object[] { def, range.till }, range.tillInclusive);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.numPropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp)));
}
else if (range.from is DateTime)
{
Key fromKey = new Key(new object[] { def, range.from }, range.fromInclusive);
Key tillKey = new Key(new object[] { def, range.till }, range.tillInclusive);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timePropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp)));
}
else
{
Key fromKey = new Key(new object[] { def, range.from }, range.fromInclusive);
Key tillKey = new Key(new object[] { def, range.till }, range.tillInclusive);
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.strPropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp)));
}
}
if (val is string)
{
string str = (string)prop.val;
int wc = str.IndexOf('*');
if (wc < 0)
{
Key key = new Key(new object[] { def, str });
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.strPropIndex.GetEnumerator(key, key), kind, timestamp)));
}
else if (wc > 0)
{
string prefix = str.Substring(0, wc);
Key fromKey = new Key(new object[] { def, prefix });
Key tillKey = new Key(new object[] { def, prefix + Char.MaxValue }, false);
return(new SearchResult(root, type, uri, wc == str.Length - 1 ? restOfPatterns : patterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.strPropIndex.GetEnumerator(fromKey, tillKey), kind, timestamp)));
}
}
else if (val is double)
{
Key key = new Key(new object[] { def, val });
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.numPropIndex.GetEnumerator(key, key), kind, timestamp)));
}
else if (val is DateTime)
{
Key key = new Key(new object[] { def, (DateTime)val });
return(new SearchResult(root, type, uri, restOfPatterns, kind, timestamp,
new ReferenceIterator(root, (PropDef[])refs.ToArray(typeof(PropDef)),
root.timePropIndex.GetEnumerator(key, key), kind, timestamp)));
}
else if (val is NameVal)
{
return(SearchReferenceProperty(type, uri, patterns, kind, timestamp, (NameVal)val, compound, def, refs));
}
else if (val is NameVal[])
{
NameVal[] props = (NameVal[])val;
if (props.Length > 0)
{
return(SearchReferenceProperty(type, uri, patterns, kind, timestamp, props[0], true, def, refs));
}
}
return(null);
}