Beispiel #1
0
        public void UnicleNameTest()
        {
            var t = new NamedList <NamedElement>();

            var el = new NamedElement();

            el.Rename("dsa");

            var el2 = new NamedElement();

            el2.Rename("dsa");

            t.Add(el);

            try
            {
                t.Add(el);
            }
            catch (InvalidOperationException)
            {
                try
                {
                    t[0] = el2;
                }
                catch (InvalidOperationException)
                {
                    return;
                }
            }

            throw new Exception("Exception has not throwed by NamedList");
        }
Beispiel #2
0
        public FacetData(INamedList responseHeader)
        {
            if (responseHeader.IsNullOrEmpty()) return;
            Queries = responseHeader.GetOrDefault<INamedList>("facet_queries");

            var fieldsList = responseHeader.GetOrDefault<INamedList>("facet_fields");
            if (fieldsList != null)
            {
                Fields=new NamedList();
                for (int i = 0; i < fieldsList.Count; i++)
                {
                    var innerList = fieldsList.GetOrDefault<IList>(i);
                    if (innerList == null) continue;
                    var list = new NamedList();
                    for (int j = 0; j < innerList.Count; j = j + 2)
                    {
                        var valKey = innerList[j] as string;
                        if (valKey != null)
                            list.Add(valKey, innerList[j + 1]);
                    }

                    Fields.Add(fieldsList.GetKey(i), list);
                }
            }

            //Fields = responseHeader.GetOrDefault<INamedList>("facet_fields");
            Dates = responseHeader.GetOrDefault<INamedList>("facet_dates");
            Ranges = responseHeader.GetOrDefault<INamedList>("facet_ranges");
        }
Beispiel #3
0
        public void _Sequence_ReadWrite()
        {
            var list = new NamedList <object>();

            for (int i = 0; i < Round; i++)
            {
                list.Add(i.ToString(), i);
            }
            for (int i = 0; i < Round; i++)
            {
                Assert.True(i == (int)list[i.ToString()]);
            }
        }
Beispiel #4
0
        public NamedList ReadNamedList(FastInputStream dis)
        {
            int       sz = ReadSize(dis);
            NamedList nl = new NamedList();

            for (int i = 0; i < sz; i++)
            {
                String name = (String)ReadVal(dis);
                Object val  = ReadVal(dis);
                nl.Add(name, val);
            }
            return(nl);
        }
Beispiel #5
0
        public virtual void Test()
        {
            NamedList original = new NamedList("foo");

            original.Add("bar");
            A().Provider().StoreNew(original);
            A().Provider().Commit();
            ReplicateAll(A().Provider(), B().Provider());
            NamedList replicated = (NamedList)B().Provider().GetStoredObjects(typeof(NamedList
                                                                                     )).GetEnumerator().Current;

            Assert.AreEqual(original.Name(), replicated.Name());
            CollectionAssert.AreEqual(original, replicated);
        }
Beispiel #6
0
        public void BasicTest()
        {
            var list = new NamedList <NamedElement>();

            var el = new NamedElement();

            list.Add(el);

            var el2 = new NamedElement();

            el2.Rename("asd");
            list.Add(el2);

            //Test

            //Get by indexer
            Assert.AreEqual(el, list[null], $"el:{el}, list[null]:{list[null]}");
            Assert.AreEqual(el2, list["asd"], $"el2:{el2}, list[\"asd\"]:{list["asd"]}");

            //Get by method
            Assert.AreEqual(el, list.GetElementByName(null), $"el:{el}, " +
                            $"list.GetElementByName(null){list.GetElementByName(null)}");

            Assert.AreEqual(el2, list.GetElementByName("asd"), $"el2:{el2}, " +
                            $"list.GetElementByName(\"asd\"){list.GetElementByName("asd")}");

            //Set
            var el3 = new NamedElement();

            el3.Rename("qwe");
            list[null] = el3;

            Assert.IsTrue(!list.Contains(el));
            Assert.AreEqual(el3, list["qwe"], $"el3:{el3}, list[\"qwe\"]:{list["qwe"]}");
            Assert.AreEqual(el2, list["asd"], $"el2:{el2}, list[\"asd\"]:{list["asd"]}");
        }
Beispiel #7
0
        public FacetData(INamedList responseHeader)
        {
            if (responseHeader.IsNullOrEmpty())
            {
                return;
            }
            Queries = responseHeader.GetOrDefault <INamedList>("facet_queries");

            var fieldsList = responseHeader.GetOrDefault <INamedList>("facet_fields");

            if (fieldsList != null)
            {
                Fields = new NamedList();
                for (int i = 0; i < fieldsList.Count; i++)
                {
                    var innerList = fieldsList.GetOrDefault <IList>(i);
                    if (innerList == null)
                    {
                        continue;
                    }
                    var list = new NamedList();
                    for (int j = 0; j < innerList.Count; j = j + 2)
                    {
                        var valKey = innerList[j] as string;
                        if (valKey != null)
                        {
                            list.Add(valKey, innerList[j + 1]);
                        }
                    }

                    Fields.Add(fieldsList.GetKey(i), list);
                }
            }

            //Fields = responseHeader.GetOrDefault<INamedList>("facet_fields");
            Dates  = responseHeader.GetOrDefault <INamedList>("facet_dates");
            Ranges = responseHeader.GetOrDefault <INamedList>("facet_ranges");
        }
Beispiel #8
0
 public NamedList ReadNamedList(FastInputStream dis)
 {
     int sz = ReadSize(dis);
     NamedList nl = new NamedList();
     for (int i = 0; i < sz; i++)
     {
         String name = (String)ReadVal(dis);
         Object val = ReadVal(dis);
         nl.Add(name, val);
     }
     return nl;
 }
Beispiel #9
0
        static void Main(string[] args)
        {
            LongOpt[] opts = new[] {
                new LongOpt("help", Argument.No, null, 'h'),
                new LongOpt("padding", Argument.Required, null, 'p'),
                new LongOpt("startpal", Argument.Required, null, 's'),
                new LongOpt("nullfirst", Argument.No, null, 'n'),
                new LongOpt("twoplayer", Argument.No, null, '2'),
                new LongOpt("format", Argument.Required, null, 'f'),
                new LongOpt("game", Argument.Required, null, 'g'),
                new LongOpt("artcmp", Argument.Required, null, 'c'),
                new LongOpt("lowplane", Argument.Required, null, 0),
                new LongOpt("highplane", Argument.Required, null, 0),
                new LongOpt("palette", Argument.Required, null, 0),
                new LongOpt("center", Argument.Required, null, 0),
                new LongOpt("artfile", Argument.Required, null, 0),
                new LongOpt("mapfile", Argument.Required, null, 0),
                new LongOpt("dplcfile", Argument.Required, null, 0),
                new LongOpt("palfile", Argument.Required, null, 0)
            };
            if (args.Length == 0)
            {
                args = new string[] { "-h" }
            }
            ;
            Getopt          getopt        = new Getopt("SpritePlotter.NET", args, Getopt.digest(opts), opts);
            int             padding       = 2;
            byte            startpal      = 0;
            bool            nullfirst     = false;
            bool            twoplayer     = false;
            MappingsFormat  mapfmt        = MappingsFormat.Binary;
            EngineVersion   mapgame       = EngineVersion.Invalid;
            bool            s3kp          = false;
            CompressionType artcmp        = CompressionType.Uncompressed;
            Bitmap          lowplanefile  = null;
            Bitmap          highplanefile = null;

            Color[] palette    = null;
            Bitmap  centerfile = null;
            string  artfile    = null;
            string  mapfile    = null;
            string  dplcfile   = null;
            string  palfile    = null;
            int     opt        = getopt.getopt();

            while (opt != -1)
            {
                switch (opt)
                {
                case 'h':
                    Console.Write(Properties.Resources.HelpText);
                    return;

                case 'p':
                    padding = int.Parse(getopt.Optarg);
                    break;

                case 's':
                    startpal = byte.Parse(getopt.Optarg);
                    break;

                case 'n':
                    nullfirst = true;
                    break;

                case '2':
                    twoplayer = true;
                    break;

                case 'f':
                    mapfmt = (MappingsFormat)Enum.Parse(typeof(MappingsFormat), getopt.Optarg, true);
                    break;

                case 'g':
                    if (getopt.Optarg.Equals("s3kp", StringComparison.OrdinalIgnoreCase))
                    {
                        mapgame = EngineVersion.S3K;
                        s3kp    = true;
                    }
                    else
                    {
                        mapgame = (EngineVersion)Enum.Parse(typeof(EngineVersion), getopt.Optarg, true);
                    }
                    break;

                case 'c':
                    artcmp = (CompressionType)Enum.Parse(typeof(CompressionType), getopt.Optarg, true);
                    break;

                case 0:
                    switch (opts[getopt.Longind].Name)
                    {
                    case "lowplane":
                        lowplanefile = new Bitmap(getopt.Optarg);
                        if (palette == null && (lowplanefile.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed)
                        {
                            palette = lowplanefile.Palette.Entries;
                        }
                        break;

                    case "highplane":
                        highplanefile = new Bitmap(getopt.Optarg);
                        if (palette == null && (highplanefile.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed)
                        {
                            palette = highplanefile.Palette.Entries;
                        }
                        break;

                    case "palette":
                        switch (System.IO.Path.GetExtension(getopt.Optarg))
                        {
                        case ".bin":
                            palette = SonLVLColor.Load(getopt.Optarg, EngineVersion.S2).Select(a => a.RGBColor).ToArray();
                            break;

                        case ".bmp":
                        case ".png":
                        case ".jpg":
                        case ".gif":
                            using (Bitmap bmp = new Bitmap(getopt.Optarg))
                            {
                                if ((bmp.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed)
                                {
                                    palette = bmp.Palette.Entries;
                                }
                                else
                                {
                                    List <Color> pal = new List <Color>();
                                    for (int y = 0; y < bmp.Height; y += 8)
                                    {
                                        for (int x = 0; x < bmp.Width; x += 8)
                                        {
                                            pal.Add(bmp.GetPixel(x, y));
                                        }
                                    }
                                    palette = pal.ToArray();
                                }
                            }
                            break;
                        }
                        break;

                    case "center":
                        centerfile = new Bitmap(getopt.Optarg);
                        break;

                    case "artfile":
                        artfile = getopt.Optarg;
                        break;

                    case "mapfile":
                        mapfile = getopt.Optarg;
                        break;

                    case "dplcfile":
                        dplcfile = getopt.Optarg;
                        break;

                    case "palfile":
                        palfile = getopt.Optarg;
                        break;
                    }
                    break;
                }
                opt = getopt.getopt();
            }
            if (mapgame == EngineVersion.Invalid)
            {
                Console.Error.WriteLine("No game specified.");
                return;
            }
            if (lowplanefile == null && highplanefile == null)
            {
                Console.Error.WriteLine("No image file specified.");
                return;
            }
            if (palette == null)
            {
                Console.Error.WriteLine("No palette specified, and image(s) did not contain palette.");
                return;
            }
            if (artfile == null)
            {
                Console.Error.WriteLine("No output art file specified.");
                return;
            }
            if (mapfile == null)
            {
                Console.Error.WriteLine("No output mappings file specified.");
                return;
            }
            if (palette.Length > 64)
            {
                palette = palette.Take(64).ToArray();                 // lazy
            }
            BitmapBits lowplane = null, highplane = null, combinedplanes = null;

            if (lowplanefile != null)
            {
                if ((lowplanefile.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed)
                {
                    lowplane = new BitmapBits(lowplanefile);
                }
                else
                {
                    using (Bitmap bmp = lowplanefile.To32bpp())
                        lowplane = LoadBitmap32BppArgb(bmp, palette);
                }
                lowplanefile.Dispose();
                if (highplanefile == null)
                {
                    combinedplanes = lowplane;
                }
            }
            if (highplanefile != null)
            {
                if ((highplanefile.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed)
                {
                    highplane = new BitmapBits(highplanefile);
                }
                else
                {
                    using (Bitmap bmp = highplanefile.To32bpp())
                        highplane = LoadBitmap32BppArgb(bmp, palette);
                }
                highplanefile.Dispose();
                if (lowplanefile == null)
                {
                    combinedplanes = highplane;
                }
            }
            if (combinedplanes == null)
            {
                combinedplanes = new BitmapBits(Math.Max(lowplane.Width, highplane.Width), Math.Max(lowplane.Height, highplane.Height));
                combinedplanes.DrawBitmap(lowplane, 0, 0);
                combinedplanes.DrawBitmapComposited(highplane, 0, 0);
            }
            List <Point> centers = null;

            if (centerfile != null)
            {
                centers = new List <Point>();
                BitmapBits cntr;
                if ((centerfile.PixelFormat & PixelFormat.Indexed) == PixelFormat.Indexed)
                {
                    cntr = new BitmapBits(centerfile);
                }
                else
                {
                    using (Bitmap bmp = centerfile.To32bpp())
                        cntr = LoadBitmap32BppArgb(bmp, Color.Black, Color.White);
                }
                centerfile.Dispose();
                for (int y = 0; y < cntr.Height; y++)
                {
                    for (int x = 0; x < cntr.Width; x++)
                    {
                        if (cntr[x, y] != 0)
                        {
                            centers.Add(new Point(x, y));
                        }
                    }
                }
            }
            List <Rectangle> sprites = new List <Rectangle>();

            for (int y = 0; y < combinedplanes.Height; y++)
            {
                for (int x = 0; x < combinedplanes.Width; x++)
                {
                    if (combinedplanes[x, y] % 16 != 0)
                    {
                        Rectangle newrect = new Rectangle(x - padding, y - padding, (padding * 2) + 1, (padding * 2) + 1);
                        for (int i = 0; i < sprites.Count; i++)
                        {
                            if (newrect.IntersectsWith(sprites[i]))
                            {
                                newrect = Rectangle.Union(newrect, sprites[i]);
                                sprites.RemoveAt(i);
                                i = -1;
                            }
                        }
                        sprites.Add(newrect);
                    }
                }
            }
            List <Rectangle> rows = new List <Rectangle>();

            for (int i = 0; i < sprites.Count; i++)
            {
                Rectangle rect = sprites[i];
                rect.Inflate(-padding, -padding);
                sprites[i] = rect;
                if (rows.Count > 0 && sprites[i].IntersectsWith(rows[rows.Count - 1]))
                {
                    rows[rows.Count - 1] = Rectangle.Union(sprites[i], rows[rows.Count - 1]);
                }
                else
                {
                    rows.Add(new Rectangle(0, sprites[i].Y, combinedplanes.Width, sprites[i].Height));
                }
            }
            List <Rectangle> newsprites = new List <Rectangle>(sprites.Count);

            foreach (Rectangle rect in rows)
            {
                newsprites.AddRange(sprites.Where(a => a.IntersectsWith(rect)).OrderBy(a => a.X));
            }
            sprites = newsprites;
            List <byte[]>             tiles = new List <byte[]>();
            NamedList <MappingsFrame> map   = new NamedList <MappingsFrame>("Map_" + Path.GetFileNameWithoutExtension(mapfile), sprites.Count);
            NamedList <DPLCFrame>     dplc  = null;

            if (dplcfile != null)
            {
                dplc = new NamedList <DPLCFrame>("DPLC_" + Path.GetFileNameWithoutExtension(dplcfile), sprites.Count);
            }
            if (nullfirst)
            {
                map.Add(new MappingsFrame(map.Name + "_Null"));
                if (dplc != null)
                {
                    dplc.Add(new DPLCFrame(dplc.Name + "_Null"));
                }
            }
            for (int i = 0; i < sprites.Count; i++)
            {
                Point center = new Point(sprites[i].Width / 2, sprites[i].Height / 2);
                if (centers != null)
                {
                    foreach (Point item in centers)
                    {
                        if (sprites[i].Contains(item))
                        {
                            center = new Point(item.X - sprites[i].Left, item.Y - sprites[i].Top);
                            break;
                        }
                    }
                }
                MappingsFrame mapframe = new MappingsFrame(map.Name + "_" + i);
                map.Add(mapframe);
                DPLCFrame dplcframe = null;
                if (dplc != null)
                {
                    dplcframe = new DPLCFrame(dplc.Name + "_" + i);
                    dplc.Add(dplcframe);
                }
                if (lowplane != null)
                {
                    SpriteToMap(sprites[i], center, lowplane, tiles, mapframe, dplcframe, startpal, false, twoplayer);
                }
                if (highplane != null)
                {
                    SpriteToMap(sprites[i], center, highplane, tiles, mapframe, dplcframe, startpal, true, twoplayer);
                }
            }
            using (MemoryStream ms = new MemoryStream(tiles.Count * 32))
            {
                using (BinaryWriter bw = new BinaryWriter(ms))
                    foreach (byte[] b in tiles)
                    {
                        bw.Write(b);
                    }
                Compression.Compress(ms.ToArray(), artfile, artcmp);
            }
            if (mapfmt == MappingsFormat.Binary)
            {
                File.WriteAllBytes(mapfile, MappingsFrame.GetBytes(map, mapgame));
                if (dplc != null)
                {
                    File.WriteAllBytes(dplcfile, DPLCFrame.GetBytes(dplc, s3kp ? EngineVersion.S2 : mapgame));
                }
            }
            else
            {
                MappingsFrame.ToASM(mapfile, map, mapgame, mapfmt == MappingsFormat.Macro);
                if (dplc != null)
                {
                    DPLCFrame.ToASM(dplcfile, dplc, mapgame, mapfmt == MappingsFormat.Macro, s3kp);
                }
            }
            if (palfile != null)
            {
                using (FileStream fs = File.Create(palfile))
                    using (BinaryWriter bw = new BinaryWriter(fs))
                        foreach (Color c in palette)
                        {
                            bw.Write(ByteConverter.GetBytes(new SonLVLColor(c).MDColor));
                        }
            }
        }
Beispiel #10
0
        protected INamedList ReadNamedList(JsonReader reader)
        {
            if (reader.TokenType != JsonToken.StartObject)
                throw new ArgumentException("requires StartObject token", "reader");
            var list = new NamedList();
            string propertyName = null;
            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.Date:
                        if (propertyName == null)
                            throw new InvalidOperationException("propertyName is null...");
                        list.Add(propertyName, ((DateTime)reader.Value).ToLocalTime());
                        propertyName = null;
                        break;

                    case JsonToken.Null:
                    case JsonToken.Boolean:
                    case JsonToken.Bytes:
                    case JsonToken.Float:
                    case JsonToken.Integer:
                    case JsonToken.String:
                        if (propertyName == null)
                            throw new InvalidOperationException("propertyName is null...");

                        list.Add(propertyName, reader.Value);
                        propertyName = null;
                        break;

                    case JsonToken.PropertyName:
                        if (propertyName != null)
                            throw new InvalidOperationException("this shouldn't happen ^^");
                        propertyName = reader.Value as string;
                        break;

                    case JsonToken.StartArray:
                        if (propertyName == null)
                            throw new InvalidOperationException("propertyName is null...");
                        list.Add(propertyName, ReadArray(reader));
                        propertyName = null;
                        break;

                    case JsonToken.StartObject:
                        if (propertyName == null)
                            throw new InvalidOperationException("propertyName is null...");
                        object value;
                        //Workaround because JSON doesn't know the exact type, so it would treat everything as NamedList, which differs from other formats
                        switch (propertyName)
                        {
                            //used for GET Requests
                            case "doc":
                                value = new SolrDocument(ReadNamedList(reader));
                                break;
                            //used for Logging Requests
                            case "history":
                            //used for Select Requests
                            case "response":
                                value = ReadSolrDocumentList(reader);
                                break;
                            default:
                                value = ReadNamedList(reader);
                                break;
                        }
                        list.Add(propertyName,value);
                        propertyName = null;
                        break;

                    case JsonToken.EndArray:
                    case JsonToken.EndObject:
                        if (propertyName != null)
                            throw new InvalidOperationException("this shouldn't happen ^^, again...");
                        return list;

                    case JsonToken.None:
                    case JsonToken.Comment:
                    case JsonToken.Raw:
                    case JsonToken.Undefined:
                        continue;
                    case JsonToken.StartConstructor:
                    case JsonToken.EndConstructor:
                    default:
                        throw new NotSupportedException("Json Constructor not supported!");
                }
            }
            throw new InvalidOperationException("Some shit hit the fan! - eh i mean, this won't happen, i hope :P");
        }
Beispiel #11
0
        protected SolrUpdateList PrepareContent()
        {
            INamedList deleteList = null;
            INamedList addList    = null;
            INamedList commitList = null;

            if (!_deleteIds.IsNullOrEmpty())
            {
                deleteList = new NamedList();
                foreach (var deleteId in _deleteIds)
                {
                    deleteList.Add("id", deleteId);
                }
            }

            if (!_deleteQueries.IsNullOrEmpty())
            {
                if (deleteList == null)
                {
                    deleteList = new NamedList();
                }
                foreach (var deleteQuery in _deleteQueries)
                {
                    deleteList.Add("query", deleteQuery);
                }
            }

            if (!_documents.IsNullOrEmpty())
            {
                addList = new NamedList();
                if (_overwrite.HasValue)
                {
                    addList.Add("overwrite", _overwrite.Value);
                }
                if (_commitWithin.HasValue)
                {
                    addList.Add("commitWithin", _commitWithin.Value);
                }
                addList.Add("doc", new List <SolrInputDocument>(_documents));
            }
            if (_CommitOptimizeOptions.HasValue)
            {
                commitList = new NamedList();
                var innerCommitList = new NamedList();
                var options         = _CommitOptimizeOptions.Value;
                if (options.waitSearcher.HasValue)
                {
                    innerCommitList.Add("waitSearcher", options.waitSearcher.Value);
                }
                if (options.softCommit.HasValue)
                {
                    innerCommitList.Add("softCommit", options.softCommit.Value);
                }
                if (_CommitOptimizeOptions.Value.Optimize)
                {
                    if (options.maxSegments.HasValue)
                    {
                        innerCommitList.Add("maxSegments", options.maxSegments.Value);
                    }
                    commitList.Add("optimize", innerCommitList);
                }
                else
                {
                    if (options.expungeDeletes.HasValue)
                    {
                        innerCommitList.Add("expungeDeletes", options.expungeDeletes.Value);
                    }
                    commitList.Add("commit", innerCommitList);
                }
            }
            _changed = false;
            return(new SolrUpdateList(addList, deleteList, commitList));
        }
Beispiel #12
0
 public SimpleQueryBuilder(string query)
 {
     QueryParameters = new NamedList<string>();
     QueryParameters.Add("q",query);
 }
Beispiel #13
0
 public SimpleQueryBuilder(string query)
 {
     QueryParameters = new NamedList <string>();
     QueryParameters.Add("q", query);
 }
Beispiel #14
0
        protected INamedList ReadNamedList(JsonReader reader)
        {
            if (reader.TokenType != JsonToken.StartObject)
            {
                throw new ArgumentException("requires StartObject token", "reader");
            }
            var    list         = new NamedList();
            string propertyName = null;

            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                case JsonToken.Date:
                    if (propertyName == null)
                    {
                        throw new InvalidOperationException("propertyName is null...");
                    }
                    list.Add(propertyName, ((DateTime)reader.Value).ToLocalTime());
                    propertyName = null;
                    break;

                case JsonToken.Null:
                case JsonToken.Boolean:
                case JsonToken.Bytes:
                case JsonToken.Float:
                case JsonToken.Integer:
                case JsonToken.String:
                    if (propertyName == null)
                    {
                        throw new InvalidOperationException("propertyName is null...");
                    }

                    list.Add(propertyName, reader.Value);
                    propertyName = null;
                    break;

                case JsonToken.PropertyName:
                    if (propertyName != null)
                    {
                        throw new InvalidOperationException("this shouldn't happen ^^");
                    }
                    propertyName = reader.Value as string;
                    break;

                case JsonToken.StartArray:
                    if (propertyName == null)
                    {
                        throw new InvalidOperationException("propertyName is null...");
                    }
                    list.Add(propertyName, ReadArray(reader));
                    propertyName = null;
                    break;

                case JsonToken.StartObject:
                    if (propertyName == null)
                    {
                        throw new InvalidOperationException("propertyName is null...");
                    }
                    object value;
                    //Workaround because JSON doesn't know the exact type, so it would treat everything as NamedList, which differs from other formats
                    switch (propertyName)
                    {
                    //used for GET Requests
                    case "doc":
                        value = new SolrDocument(ReadNamedList(reader));
                        break;

                    //used for Logging Requests
                    case "history":
                    //used for Select Requests
                    case "response":
                        value = ReadSolrDocumentList(reader);
                        break;

                    default:
                        value = ReadNamedList(reader);
                        break;
                    }
                    list.Add(propertyName, value);
                    propertyName = null;
                    break;

                case JsonToken.EndArray:
                case JsonToken.EndObject:
                    if (propertyName != null)
                    {
                        throw new InvalidOperationException("this shouldn't happen ^^, again...");
                    }
                    return(list);

                case JsonToken.None:
                case JsonToken.Comment:
                case JsonToken.Raw:
                case JsonToken.Undefined:
                    continue;

                case JsonToken.StartConstructor:
                case JsonToken.EndConstructor:
                default:
                    throw new NotSupportedException("Json Constructor not supported!");
                }
            }
            throw new InvalidOperationException("Some shit hit the fan! - eh i mean, this won't happen, i hope :P");
        }
Beispiel #15
0
 // --------------------------------------------------------------------
 /// <summary>
 ///
 /// </summary>
 /// <param name="Child"></param>
 // --------------------------------------------------------------------
 public virtual void Add(Instance Child)
 {
     Children.Add(Child);
 }