// <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);
 }
Пример #2
0
 // <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);
        }
Пример #13
0
 /// <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);
        }