text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Seal
{
    public sealed class Colors
    {
        /// <summary>
        /// Gets a color with an ARGB value of #fff0f8ff.
        /// </summary>
        public static Color AliceBlue { get{ return Color.FromUInt32(0xfff0f8ff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffaebd7.
        /// </summary>
        public static Color AntiqueWhite { get{ return Color.FromUInt32(0xfffaebd7);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00ffff.
        /// </summary>
        public static Color Aqua { get{ return Color.FromUInt32(0xff00ffff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff7fffd4.
        /// </summary>
        public static Color Aquamarine { get{ return Color.FromUInt32(0xff7fffd4);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff0ffff.
        /// </summary>
        public static Color Azure { get{ return Color.FromUInt32(0xfff0ffff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff5f5dc.
        /// </summary>
        public static Color Beige { get{ return Color.FromUInt32(0xfff5f5dc);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffe4c4.
        /// </summary>
        public static Color Bisque { get{ return Color.FromUInt32(0xffffe4c4);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff000000.
        /// </summary>
        public static Color Black { get{ return Color.FromUInt32(0xff000000);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffebcd.
        /// </summary>
        public static Color BlanchedAlmond { get{ return Color.FromUInt32(0xffffebcd);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff0000ff.
        /// </summary>
        public static Color Blue { get{ return Color.FromUInt32(0xff0000ff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff8a2be2.
        /// </summary>
        public static Color BlueViolet { get{ return Color.FromUInt32(0xff8a2be2);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffa52a2a.
        /// </summary>
        public static Color Brown { get{ return Color.FromUInt32(0xffa52a2a);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffdeb887.
        /// </summary>
        public static Color BurlyWood { get{ return Color.FromUInt32(0xffdeb887);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff5f9ea0.
        /// </summary>
        public static Color CadetBlue { get{ return Color.FromUInt32(0xff5f9ea0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff7fff00.
        /// </summary>
        public static Color Chartreuse { get{ return Color.FromUInt32(0xff7fff00);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffd2691e.
        /// </summary>
        public static Color Chocolate { get{ return Color.FromUInt32(0xffd2691e);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff7f50.
        /// </summary>
        public static Color Coral { get{ return Color.FromUInt32(0xffff7f50);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff6495ed.
        /// </summary>
        public static Color CornflowerBlue { get{ return Color.FromUInt32(0xff6495ed);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffff8dc.
        /// </summary>
        public static Color Cornsilk { get{ return Color.FromUInt32(0xfffff8dc);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffdc143c.
        /// </summary>
        public static Color Crimson { get{ return Color.FromUInt32(0xffdc143c);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00ffff.
        /// </summary>
        public static Color Cyan { get{ return Color.FromUInt32(0xff00ffff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00008b.
        /// </summary>
        public static Color DarkBlue { get{ return Color.FromUInt32(0xff00008b);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff008b8b.
        /// </summary>
        public static Color DarkCyan { get{ return Color.FromUInt32(0xff008b8b);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffb8860b.
        /// </summary>
        public static Color DarkGoldenrod { get{ return Color.FromUInt32(0xffb8860b);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffa9a9a9.
        /// </summary>
        public static Color DarkGray { get{ return Color.FromUInt32(0xffa9a9a9);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff006400.
        /// </summary>
        public static Color DarkGreen { get{ return Color.FromUInt32(0xff006400);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffbdb76b.
        /// </summary>
        public static Color DarkKhaki { get{ return Color.FromUInt32(0xffbdb76b);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff8b008b.
        /// </summary>
        public static Color DarkMagenta { get{ return Color.FromUInt32(0xff8b008b);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff556b2f.
        /// </summary>
        public static Color DarkOliveGreen { get{ return Color.FromUInt32(0xff556b2f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff8c00.
        /// </summary>
        public static Color DarkOrange { get{ return Color.FromUInt32(0xffff8c00);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff9932cc.
        /// </summary>
        public static Color DarkOrchid { get{ return Color.FromUInt32(0xff9932cc);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff8b0000.
        /// </summary>
        public static Color DarkRed { get{ return Color.FromUInt32(0xff8b0000);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffe9967a.
        /// </summary>
        public static Color DarkSalmon { get{ return Color.FromUInt32(0xffe9967a);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff8fbc8f.
        /// </summary>
        public static Color DarkSeaGreen { get{ return Color.FromUInt32(0xff8fbc8f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff483d8b.
        /// </summary>
        public static Color DarkSlateBlue { get{ return Color.FromUInt32(0xff483d8b);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff2f4f4f.
        /// </summary>
        public static Color DarkSlateGray { get{ return Color.FromUInt32(0xff2f4f4f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00ced1.
        /// </summary>
        public static Color DarkTurquoise { get{ return Color.FromUInt32(0xff00ced1);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff9400d3.
        /// </summary>
        public static Color DarkViolet { get{ return Color.FromUInt32(0xff9400d3);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff1493.
        /// </summary>
        public static Color DeepPink { get{ return Color.FromUInt32(0xffff1493);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00bfff.
        /// </summary>
        public static Color DeepSkyBlue { get{ return Color.FromUInt32(0xff00bfff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff696969.
        /// </summary>
        public static Color DimGray { get{ return Color.FromUInt32(0xff696969);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff1e90ff.
        /// </summary>
        public static Color DodgerBlue { get{ return Color.FromUInt32(0xff1e90ff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffb22222.
        /// </summary>
        public static Color Firebrick { get{ return Color.FromUInt32(0xffb22222);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffffaf0.
        /// </summary>
        public static Color FloralWhite { get{ return Color.FromUInt32(0xfffffaf0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff228b22.
        /// </summary>
        public static Color ForestGreen { get{ return Color.FromUInt32(0xff228b22);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff00ff.
        /// </summary>
        public static Color Fuchsia { get{ return Color.FromUInt32(0xffff00ff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffdcdcdc.
        /// </summary>
        public static Color Gainsboro { get{ return Color.FromUInt32(0xffdcdcdc);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff8f8ff.
        /// </summary>
        public static Color GhostWhite { get{ return Color.FromUInt32(0xfff8f8ff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffd700.
        /// </summary>
        public static Color Gold { get{ return Color.FromUInt32(0xffffd700);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffdaa520.
        /// </summary>
        public static Color Goldenrod { get{ return Color.FromUInt32(0xffdaa520);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff808080.
        /// </summary>
        public static Color Gray { get{ return Color.FromUInt32(0xff808080);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff008000.
        /// </summary>
        public static Color Green { get{ return Color.FromUInt32(0xff008000);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffadff2f.
        /// </summary>
        public static Color GreenYellow { get{ return Color.FromUInt32(0xffadff2f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff0fff0.
        /// </summary>
        public static Color Honeydew { get{ return Color.FromUInt32(0xfff0fff0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff69b4.
        /// </summary>
        public static Color HotPink { get{ return Color.FromUInt32(0xffff69b4);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffcd5c5c.
        /// </summary>
        public static Color IndianRed { get{ return Color.FromUInt32(0xffcd5c5c);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff4b0082.
        /// </summary>
        public static Color Indigo { get{ return Color.FromUInt32(0xff4b0082);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffffff0.
        /// </summary>
        public static Color Ivory { get{ return Color.FromUInt32(0xfffffff0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff0e68c.
        /// </summary>
        public static Color Khaki { get{ return Color.FromUInt32(0xfff0e68c);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffe6e6fa.
        /// </summary>
        public static Color Lavender { get{ return Color.FromUInt32(0xffe6e6fa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffff0f5.
        /// </summary>
        public static Color LavenderBlush { get{ return Color.FromUInt32(0xfffff0f5);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff7cfc00.
        /// </summary>
        public static Color LawnGreen { get{ return Color.FromUInt32(0xff7cfc00);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffffacd.
        /// </summary>
        public static Color LemonChiffon { get{ return Color.FromUInt32(0xfffffacd);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffadd8e6.
        /// </summary>
        public static Color LightBlue { get{ return Color.FromUInt32(0xffadd8e6);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff08080.
        /// </summary>
        public static Color LightCoral { get{ return Color.FromUInt32(0xfff08080);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffe0ffff.
        /// </summary>
        public static Color LightCyan { get{ return Color.FromUInt32(0xffe0ffff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffafad2.
        /// </summary>
        public static Color LightGoldenrodYellow { get{ return Color.FromUInt32(0xfffafad2);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffd3d3d3.
        /// </summary>
        public static Color LightGray { get{ return Color.FromUInt32(0xffd3d3d3);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff90ee90.
        /// </summary>
        public static Color LightGreen { get{ return Color.FromUInt32(0xff90ee90);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffb6c1.
        /// </summary>
        public static Color LightPink { get{ return Color.FromUInt32(0xffffb6c1);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffa07a.
        /// </summary>
        public static Color LightSalmon { get{ return Color.FromUInt32(0xffffa07a);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff20b2aa.
        /// </summary>
        public static Color LightSeaGreen { get{ return Color.FromUInt32(0xff20b2aa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff87cefa.
        /// </summary>
        public static Color LightSkyBlue { get{ return Color.FromUInt32(0xff87cefa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff778899.
        /// </summary>
        public static Color LightSlateGray { get{ return Color.FromUInt32(0xff778899);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffb0c4de.
        /// </summary>
        public static Color LightSteelBlue { get{ return Color.FromUInt32(0xffb0c4de);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffffe0.
        /// </summary>
        public static Color LightYellow { get{ return Color.FromUInt32(0xffffffe0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00ff00.
        /// </summary>
        public static Color Lime { get{ return Color.FromUInt32(0xff00ff00);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff32cd32.
        /// </summary>
        public static Color LimeGreen { get{ return Color.FromUInt32(0xff32cd32);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffaf0e6.
        /// </summary>
        public static Color Linen { get{ return Color.FromUInt32(0xfffaf0e6);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff00ff.
        /// </summary>
        public static Color Magenta { get{ return Color.FromUInt32(0xffff00ff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff800000.
        /// </summary>
        public static Color Maroon { get{ return Color.FromUInt32(0xff800000);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff66cdaa.
        /// </summary>
        public static Color MediumAquamarine { get{ return Color.FromUInt32(0xff66cdaa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff0000cd.
        /// </summary>
        public static Color MediumBlue { get{ return Color.FromUInt32(0xff0000cd);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffba55d3.
        /// </summary>
        public static Color MediumOrchid { get{ return Color.FromUInt32(0xffba55d3);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff9370db.
        /// </summary>
        public static Color MediumPurple { get{ return Color.FromUInt32(0xff9370db);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff3cb371.
        /// </summary>
        public static Color MediumSeaGreen { get{ return Color.FromUInt32(0xff3cb371);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff7b68ee.
        /// </summary>
        public static Color MediumSlateBlue { get{ return Color.FromUInt32(0xff7b68ee);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00fa9a.
        /// </summary>
        public static Color MediumSpringGreen { get{ return Color.FromUInt32(0xff00fa9a);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff48d1cc.
        /// </summary>
        public static Color MediumTurquoise { get{ return Color.FromUInt32(0xff48d1cc);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffc71585.
        /// </summary>
        public static Color MediumVioletRed { get{ return Color.FromUInt32(0xffc71585);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff191970.
        /// </summary>
        public static Color MidnightBlue { get{ return Color.FromUInt32(0xff191970);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff5fffa.
        /// </summary>
        public static Color MintCream { get{ return Color.FromUInt32(0xfff5fffa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffe4e1.
        /// </summary>
        public static Color MistyRose { get{ return Color.FromUInt32(0xffffe4e1);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffe4b5.
        /// </summary>
        public static Color Moccasin { get{ return Color.FromUInt32(0xffffe4b5);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffdead.
        /// </summary>
        public static Color NavajoWhite { get{ return Color.FromUInt32(0xffffdead);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff000080.
        /// </summary>
        public static Color Navy { get{ return Color.FromUInt32(0xff000080);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffdf5e6.
        /// </summary>
        public static Color OldLace { get{ return Color.FromUInt32(0xfffdf5e6);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff808000.
        /// </summary>
        public static Color Olive { get{ return Color.FromUInt32(0xff808000);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff6b8e23.
        /// </summary>
        public static Color OliveDrab { get{ return Color.FromUInt32(0xff6b8e23);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffa500.
        /// </summary>
        public static Color Orange { get{ return Color.FromUInt32(0xffffa500);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff4500.
        /// </summary>
        public static Color OrangeRed { get{ return Color.FromUInt32(0xffff4500);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffda70d6.
        /// </summary>
        public static Color Orchid { get{ return Color.FromUInt32(0xffda70d6);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffeee8aa.
        /// </summary>
        public static Color PaleGoldenrod { get{ return Color.FromUInt32(0xffeee8aa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff98fb98.
        /// </summary>
        public static Color PaleGreen { get{ return Color.FromUInt32(0xff98fb98);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffafeeee.
        /// </summary>
        public static Color PaleTurquoise { get{ return Color.FromUInt32(0xffafeeee);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffdb7093.
        /// </summary>
        public static Color PaleVioletRed { get{ return Color.FromUInt32(0xffdb7093);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffefd5.
        /// </summary>
        public static Color PapayaWhip { get{ return Color.FromUInt32(0xffffefd5);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffdab9.
        /// </summary>
        public static Color PeachPuff { get{ return Color.FromUInt32(0xffffdab9);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffcd853f.
        /// </summary>
        public static Color Peru { get{ return Color.FromUInt32(0xffcd853f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffc0cb.
        /// </summary>
        public static Color Pink { get{ return Color.FromUInt32(0xffffc0cb);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffdda0dd.
        /// </summary>
        public static Color Plum { get{ return Color.FromUInt32(0xffdda0dd);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffb0e0e6.
        /// </summary>
        public static Color PowderBlue { get{ return Color.FromUInt32(0xffb0e0e6);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff800080.
        /// </summary>
        public static Color Purple { get{ return Color.FromUInt32(0xff800080);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff0000.
        /// </summary>
        public static Color Red { get{ return Color.FromUInt32(0xffff0000);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffbc8f8f.
        /// </summary>
        public static Color RosyBrown { get{ return Color.FromUInt32(0xffbc8f8f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff4169e1.
        /// </summary>
        public static Color RoyalBlue { get{ return Color.FromUInt32(0xff4169e1);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff8b4513.
        /// </summary>
        public static Color SaddleBrown { get{ return Color.FromUInt32(0xff8b4513);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffa8072.
        /// </summary>
        public static Color Salmon { get{ return Color.FromUInt32(0xfffa8072);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff4a460.
        /// </summary>
        public static Color SandyBrown { get{ return Color.FromUInt32(0xfff4a460);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff2e8b57.
        /// </summary>
        public static Color SeaGreen { get{ return Color.FromUInt32(0xff2e8b57);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffff5ee.
        /// </summary>
        public static Color SeaShell { get{ return Color.FromUInt32(0xfffff5ee);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffa0522d.
        /// </summary>
        public static Color Sienna { get{ return Color.FromUInt32(0xffa0522d);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffc0c0c0.
        /// </summary>
        public static Color Silver { get{ return Color.FromUInt32(0xffc0c0c0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff87ceeb.
        /// </summary>
        public static Color SkyBlue { get{ return Color.FromUInt32(0xff87ceeb);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff6a5acd.
        /// </summary>
        public static Color SlateBlue { get{ return Color.FromUInt32(0xff6a5acd);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff708090.
        /// </summary>
        public static Color SlateGray { get{ return Color.FromUInt32(0xff708090);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fffffafa.
        /// </summary>
        public static Color Snow { get{ return Color.FromUInt32(0xfffffafa);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff00ff7f.
        /// </summary>
        public static Color SpringGreen { get{ return Color.FromUInt32(0xff00ff7f);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff4682b4.
        /// </summary>
        public static Color SteelBlue { get{ return Color.FromUInt32(0xff4682b4);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffd2b48c.
        /// </summary>
        public static Color Tan { get{ return Color.FromUInt32(0xffd2b48c);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff008080.
        /// </summary>
        public static Color Teal { get{ return Color.FromUInt32(0xff008080);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffd8bfd8.
        /// </summary>
        public static Color Thistle { get{ return Color.FromUInt32(0xffd8bfd8);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffff6347.
        /// </summary>
        public static Color Tomato { get{ return Color.FromUInt32(0xffff6347);}}

        /// <summary>
        /// Gets a color with an ARGB value of #00ffffff.
        /// </summary>
        public static Color Transparent { get{ return Color.FromUInt32(0x00ffffff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff40e0d0.
        /// </summary>
        public static Color Turquoise { get{ return Color.FromUInt32(0xff40e0d0);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffee82ee.
        /// </summary>
        public static Color Violet { get{ return Color.FromUInt32(0xffee82ee);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff5deb3.
        /// </summary>
        public static Color Wheat { get{ return Color.FromUInt32(0xfff5deb3);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffffff.
        /// </summary>
        public static Color White { get{ return Color.FromUInt32(0xffffffff);}}

        /// <summary>
        /// Gets a color with an ARGB value of #fff5f5f5.
        /// </summary>
        public static Color WhiteSmoke { get{ return Color.FromUInt32(0xfff5f5f5);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ffffff00.
        /// </summary>
        public static Color Yellow { get{ return Color.FromUInt32(0xffffff00);}}

        /// <summary>
        /// Gets a color with an ARGB value of #ff9acd32.
        /// </summary>
        public static Color YellowGreen { get{ return Color.FromUInt32(0xff9acd32);}}
    }
}


text:
"use strict";

window.addEventListener("load", function () {
    var editor = ace.edit("editor");
    var session = editor.getSession();

    var responseEditor = ace.edit("response-editor");
    var responseEditorSession = responseEditor.getSession();

    /**
     * runCode
     * The function that sends the code to the server side and waits for the response.
     *
     * @name runCode
     * @function
     * @param {String} code The code that is passed on the server side via HTTP request.
     * @param {Function} callback The callback function that is called after the response comes.
     * @return {XMLHttpRequest} The XHR that is made.
     */
    function runCode(code, callback) {
        var res = null;
        fetch("/api/run_code", {
            method: "POST",
            headers: {
                "Accept": "application/json",
                "Content-Type": "application/json"
            },
            body: JSON.stringify({
                code: code
            })
        }).then(function (_res) {
            res = _res;
            return _res.text();
        }).then(function (text) {
            if (res.status > 400) {
                callback(text);
            }
            callback(null, text);
        });
    }

    //setup editor
    editor.setTheme("ace/theme/textmate");
    editor.setFontSize(13);
    session.setMode("ace/mode/javascript");

    // response editor
    responseEditor.setTheme("ace/theme/textmate");
    responseEditor.setFontSize(13);
    responseEditorSession.setMode("ace/mode/json");

    // auto-complete
    ace.require("ace/ext/language_tools");
    editor.setOptions({
        enableBasicAutocompletion: true
    });

    editor.commands.on("afterExec", function (e) {
        console.log(e.args);
        if (e.command.name == "insertstring" && e.args === ".") {
            editor.execCommand("startAutocomplete");
        }
    });

    // click handler
    document.querySelectorAll(".run-code-btn")[0].addEventListener("click", function () {
        runCode(editor.getValue(), function (err, data) {
            responseEditor.setValue(err || data, -1);
        });
    });
});

redpajama_set_name: RedPajamaGithub


text:
import CeraonAction from '../CeraonAction';
import CeraonActionType from '../CeraonActionType';
import Review from '../../State/Meal/Review';

export interface CreateReviewAction extends CeraonAction {
  review: Partial<Review>;
}

export function createCreateReviewAction(review: Partial<Review>) : CreateReviewAction {
  return {
    type: CeraonActionType.CreateReview,
    review: review,
  };
}


text:
<?php

namespace Google\Service\Analytics;

class EntityAdWordsLinkEntity extends \Google\Model
{
  protected $webPropertyRefType = WebPropertyRef::class;
  protected $webPropertyRefDataType = '';

  /**
   * @param WebPropertyRef
   */
  public function setWebPropertyRef(WebPropertyRef $webPropertyRef)
  {
    $this->webPropertyRef = $webPropertyRef;
  }
  /**
   * @return WebPropertyRef
   */
  public function getWebPropertyRef()
  {
    return $this->webPropertyRef;
  }
}

// Adding a class alias for backwards compatibility with the previous class name.
class_alias(EntityAdWordsLinkEntity::class, 'Google_Service_Analytics_EntityAdWordsLinkEntity');


text:
<?php

namespace Ibuildings\QaTools\Core\Interviewer;

use Ibuildings\QaTools\Core\Exception\RuntimeException;
use Ibuildings\QaTools\Core\Interviewer\Answer\Answer;
use Ibuildings\QaTools\Core\Interviewer\Question\Question;

final class AutomatedResponseInterviewer implements Interviewer
{
    /** @var Answer[] */
    private $recordedAnswers = [];
    /** @var string[] */
    private $questionsToAnswerToWithDefault = [];

    /**
     * Records an answer that is to be given when a question's text matches the
     * partial question text. The last recorded answer is matched first.
     *
     * @param string $partialQuestionText
     * @param Answer $answer
     * @return void
     */
    public function recordAnswer($partialQuestionText, Answer $answer)
    {
        array_unshift($this->recordedAnswers, [$partialQuestionText, $answer]);
    }

    /**
     * Records that the question's default answer ought to be given when a
     * question's text matches the partial question text.
     *
     * @param string $partialQuestionText
     * @return void
     */
    public function respondWithDefaultAnswerTo($partialQuestionText)
    {
        $this->questionsToAnswerToWithDefault[] = $partialQuestionText;
    }

    public function ask(Question $question)
    {
        foreach ($this->recordedAnswers as list($partialQuestionText, $answer)) {
            if (strpos($question, $partialQuestionText) !== false) {
                return $answer;
            }
        }
        foreach ($this->questionsToAnswerToWithDefault as $partialQuestionText) {
            if (strpos($question, $partialQuestionText) !== false) {
                if (!$question->hasDefaultAnswer()) {
                    throw new RuntimeException(sprintf('No default answer available for question "%s"', $question));
                }
                return $question->getDefaultAnswer();
            }
        }

        throw new RuntimeException(sprintf('No answer recorded for question "%s"', $question));
    }

    public function notice($sentence)
    {
    }

    public function giveDetails($sentence)
    {
    }

    public function success($sentence)
    {
    }

    public function warn($sentence)
    {
    }
}


text:
/* -*- c-basic-offset: 4; indent-tabs-mode: nil -*- */
/* ====================================================================
 * Copyright (c) 1999-2004 Carnegie Mellon University.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * This work was supported in part by funding from the Defense Advanced
 * Research Projects Agency and the National Science Foundation of the
 * United States of America, and the CMU Sphinx Speech Consortium.
 *
 * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND
 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY
 * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ====================================================================
 *
 */
/*
 * s3types.h -- Types specific to s3 decoder.
 *
 * **********************************************
 * CMU ARPA Speech Project
 *
 * Copyright (c) 1999 Carnegie Mellon University.
 * ALL RIGHTS RESERVED.
 * **********************************************
 *
 * HISTORY
 * $Log: s3types.h,v $
 * Revision 1.16  2006/02/22 19:57:57  arthchan2003
 * Merged from branch SPHINX3_5_2_RCI_IRII_BRANCH: Increase the size of MAX_S3CIPID from 127 to 32767.  This will make Chinese Mandarin setup works.
 *
 * Revision 1.15.4.1  2005/10/09 19:53:09  arthchan2003
 * Changed the maximum number of CI PID from 127 to 32767, this will allow us to take care of Chinese syllable, Chinese initial/final and even Cantononese.  It might still cause us problem in Turkish.
 *
 * Revision 1.15  2005/06/21 20:54:44  arthchan2003
 * 1, Added $ keyword. 2, make a small change for compilation purpose.
 *
 * Revision 1.5  2005/06/16 04:59:09  archan
 * Sphinx3 to s3.generic, a gentle-refactored version of Dave's change in senone scale.
 *
 * Revision 1.4  2005/06/15 21:48:56  archan
 * Sphinx3 to s3.generic: Changed noinst_HEADERS to pkginclude_HEADERS.  This make all the headers to be installed.
 *
 * Revision 1.3  2005/03/30 01:22:47  archan
 * Fixed mistakes in last updates. Add
 *
 *
 * 13-May-1999	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University.
 * 		Changed typedef source for s3ssid_t from int32 to s3pid_t.
 * 		Changed s3senid_t from int16 to int32 (to conform with composite senid
 * 		which is int32).
 *
 * 04-May-1999	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University.
 * 		Added senone sequence ID (s3ssid_t).
 *
 * 12-Jul-95	M K Ravishankar (rkm@cs.cmu.edu) at Carnegie Mellon University.
 * 		Started.
 */

#ifndef _S3_S3TYPES_H_
#define _S3_S3TYPES_H_

#include <float.h>
#import "oeassert.h"

#include "prim_type.h"
#include "err.h"
#include "ckd_alloc.h"

/** \file s3types.h
 * \brief Size definition of semantically units. Common for both s3 and s3.X decoder.
 */

#ifdef __cplusplus
extern "C" {
#endif
#if 0
} /* Fool Emacs into not indenting things. */
#endif

/**
 * Size definitions for more semantially meaningful units.
 * Illegal value definitions, limits, and tests for specific types.
 * NOTE: Types will be either int32 or smaller; only smaller ones may be unsigned (i.e.,
 * no type will be uint32).
 */

typedef int16		s3cipid_t;	/** Ci phone id */
#define BAD_S3CIPID	((s3cipid_t) -1)
#define NOT_S3CIPID(p)	((p)<0)
#define IS_S3CIPID(p)	((p)>=0)
#define MAX_S3CIPID	32767

/*#define MAX_S3CIPID	127*/

typedef int32		s3pid_t;	/** Phone id (triphone or ciphone) */
#define BAD_S3PID	((s3pid_t) -1)
#define NOT_S3PID(p)	((p)<0)
#define IS_S3PID(p)	((p)>=0)
#define MAX_S3PID	((int32)0x7ffffffe)

typedef uint16		s3ssid_t;	/** Senone sequence id (triphone or ciphone) */
#define BAD_S3SSID	((s3ssid_t) 0xffff)
#define NOT_S3SSID(p)	((p) == BAD_S3SSID)
#define IS_S3SSID(p)	((p) != BAD_S3SSID)
#define MAX_S3SSID	((s3ssid_t)0xfffe)

typedef int32		s3tmatid_t;	/** Transition matrix id; there can be as many as pids */
#define BAD_S3TMATID	((s3tmatid_t) -1)
#define NOT_S3TMATID(t)	((t)<0)
#define IS_S3TMATID(t)	((t)>=0)
#define MAX_S3TMATID	((int32)0x7ffffffe)

typedef int32		s3wid_t;	/** Dictionary word id */
#define BAD_S3WID	((s3wid_t) -1)
#define NOT_S3WID(w)	((w)<0)
#define IS_S3WID(w)	((w)>=0)
#define MAX_S3WID	((int32)0x7ffffffe)

typedef uint16		s3lmwid_t;	/** LM word id (uint16 for conserving space) */
#define BAD_S3LMWID	((s3lmwid_t) 0xffff)
#define NOT_S3LMWID(w)	((w)==BAD_S3LMWID)
#define IS_S3LMWID(w)	((w)!=BAD_S3LMWID)
#define MAX_S3LMWID	((uint32)0xfffe)
#define BAD_LMCLASSID   (-1)

typedef uint32		s3lmwid32_t;	/** LM word id (uint32 for conserving space) */
#define BAD_S3LMWID32	((s3lmwid32_t) 0x0fffffff)
#define NOT_S3LMWID32(w)  ((w)==BAD_S3LMWID32)
#define IS_S3LMWID32(w)	((w)!=BAD_S3LMWID32)
#define MAX_S3LMWID32	((uint32)0xfffffffe)

/* Generic macro that is applicable to both uint16 and uint32
   Careful with efficiency issue.

   Also, please don't use BAD_S3LATID(l);
*/

#define BAD_LMWID(lm)      (lm->is32bits? BAD_S3LMWID32 : BAD_S3LMWID)
#define NOT_LMWID(lm,w)    (lm->is32bits? NOT_S3LMWID32(w): NOT_S3LMWID(w))
#define IS_LMWID(lm,w)     (lm->is32bits? IS_S3LMWID32(w): IS_S3LMWID(w))
#define MAX_LMWID(lm)      (lm->is32bits? MAX_S3LMWID32: MAX_S3LMWID)

typedef int32		s3latid_t;	/** Lattice entry id */
#define BAD_S3LATID	((s3latid_t) -1)
#define NOT_S3LATID(l)	((l)<0)
#define IS_S3LATID(l)	((l)>=0)
#define MAX_S3LATID	((int32)0x7ffffffe)

typedef int16   	s3frmid_t;	/** Frame id (must be SIGNED integer) */
#define BAD_S3FRMID	((s3frmid_t) -1)
#define NOT_S3FRMID(f)	((f)<0)
#define IS_S3FRMID(f)	((f)>=0)
#define MAX_S3FRMID	((int32)0x7ffe)

typedef uint16   	s3senid_t;	/** Senone id */
#define BAD_S3SENID	((s3senid_t) 0xffff)
#define NOT_S3SENID(s)	((s) == BAD_S3SENID)
#define IS_S3SENID(s)	((s) != BAD_S3SENID)
#define MAX_S3SENID	((int16)0x7ffe)

typedef int16   	s3mgauid_t;	/** Mixture-gaussian codebook id */
#define BAD_S3MGAUID	((s3mgauid_t) -1)
#define NOT_S3MGAUID(m)	((m)<0)
#define IS_S3MGAUID(m)	((m)>=0)
#define MAX_S3MGAUID	((int32)0x00007ffe)

#define S3_LOGPROB_ZERO		((int32) 0xc8000000)	/** Integer version of log of zero Approx -infinity!! */
#define S3_LOGPROB_ZERO_F	((float32) -1e30)	/** Float version of log of zero Approx -infinity!! */

#define RENORM_THRESH     ((int32) ((S3_LOGPROB_ZERO)>>1))       /** Bestscore getting close to 0 */

#define S3_SUCCESS      0
#define S3_ERROR        -1
#define S3_WARNING      -2

/** The maximum # of states for any given acoustic model */
#define MAX_N_STATE     20

/** The maximum # of attributes associated with any
 * given acoustic model */
#define MAX_N_ATTRIB    5

#ifndef TRUE
#define TRUE  1
#define FALSE 0 /* assume that true is never defined w/o false */
#endif

/* Timer for elapsed I/O time */
#define IO_ELAPSED      0

/* Timer for utt processing elapsed time */
#define UTT_ELAPSED     1
#define UTT_IO_ELAPSED  2
#define UTT_BW_ELAPSED  3

#define TYING_NON_EMITTING      (0xffffffff)
#define TYING_NO_ID             (0xffffffff)

#define MAX_VERSION_LEN 128

#define MEG *1024*1024

#if 0
{ /* Stop indent from complaining */
#endif
#ifdef __cplusplus
}
#endif

#endif


text:
module QA
  module Page
    module Profile
      class SSHKeys < Page::Base
        view 'app/views/profiles/keys/_form.html.haml' do
          element :key_expiry_date_field
          element :key_title_field
          element :key_public_key_field
          element :add_key_button
        end

        view 'app/views/profiles/keys/_key_details.html.haml' do
          element :delete_key_button
        end

        view 'app/views/profiles/keys/_key_table.html.haml' do
          element :ssh_keys_list
        end

        def add_key(public_key, title)
          fill_element(:key_public_key_field, public_key)
          fill_element(:key_title_field, title)
          # Expire in 2 days just in case the key is created just before midnight
          fill_expiry_date(Date.today + 2)

          click_element(:add_key_button)
        end

        def fill_expiry_date(date)
          date = date.strftime('%m/%d/%Y') if date.is_a?(Date)
          Date.strptime(date, '%m/%d/%Y') rescue ArgumentError raise "Expiry date must be in mm/dd/yyyy format"

          fill_element(:key_expiry_date_field, date)
        end

        def remove_key(title)
          click_link(title)

          accept_alert do
            click_element(:delete_key_button)
          end
        end

        def keys_list
          find_element(:ssh_keys_list).text
        end
      end
    end
  end
end


text:
package org.apache.ignite.internal.commandline.cache;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.function.Predicate;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import org.apache.ignite.IgniteSystemProperties;
import org.apache.ignite.internal.client.GridClient;
import org.apache.ignite.internal.client.GridClientConfiguration;
import org.apache.ignite.internal.client.GridClientNode;
import org.apache.ignite.internal.commandline.AbstractCommand;
import org.apache.ignite.internal.commandline.Command;
import org.apache.ignite.internal.commandline.cache.check_indexes_inline_size.CheckIndexInlineSizesResult;
import org.apache.ignite.internal.commandline.cache.check_indexes_inline_size.CheckIndexInlineSizesTask;
import org.apache.ignite.internal.util.typedef.F;
import org.apache.ignite.internal.util.typedef.internal.SB;
import org.apache.ignite.internal.visor.VisorTaskArgument;

import static java.util.stream.Collectors.toSet;
import static org.apache.ignite.internal.commandline.CommandLogger.INDENT;

/**
 * Command for check secondary indexes inline size on the different nodes.
 */
public class CheckIndexInlineSizes extends AbstractCommand<Void> {
    /** Success message. */
    public static final String INDEXES_INLINE_SIZE_ARE_THE_SAME =
        "All secondary indexes have the same effective inline size on all cluster nodes.";

    /** Predicate to filter server nodes. */
    private static final Predicate<GridClientNode> SRV_NODES = node -> !node.isClient() && !node.isDaemon();

    /** {@inheritDoc} */
    @Override public Object execute(GridClientConfiguration clientCfg, Logger log) throws Exception {
        try (GridClient client = Command.startClient(clientCfg)) {
            Set<GridClientNode> serverNodes = client.compute().nodes().stream()
                .filter(SRV_NODES)
                .collect(toSet());

            Collection<UUID> serverNodeIds = F.transform(serverNodes, GridClientNode::nodeId);

            CheckIndexInlineSizesResult res = client.compute().projection(serverNodes).execute(
                CheckIndexInlineSizesTask.class.getName(),
                new VisorTaskArgument<>(serverNodeIds, false)
            );

            analyzeResults(log, res);
        }

        return null;
    }

    /**
     * Compares inline sizes from nodes and print to log information about "problem" indexes.
     *
     * @param log Logger
     * @param res Indexes inline size.
     */
    private void analyzeResults(
        Logger log,
        CheckIndexInlineSizesResult res
    ) {
        Map<String, Map<Integer, Set<UUID>>> indexToSizeNode = new HashMap<>();

        for (Map.Entry<UUID, Map<String, Integer>> nodeRes : res.inlineSizes().entrySet()) {
            for (Map.Entry<String, Integer> index : nodeRes.getValue().entrySet()) {
                Map<Integer, Set<UUID>> sizeToNodes = indexToSizeNode.computeIfAbsent(index.getKey(), x -> new HashMap<>());

                sizeToNodes.computeIfAbsent(index.getValue(), x -> new HashSet<>()).add(nodeRes.getKey());
            }
        }

        log.info("Found " + indexToSizeNode.size() + " secondary indexes.");

        Map<String, Map<Integer, Set<UUID>>> problems = indexToSizeNode.entrySet().stream()
            .filter(e -> e.getValue().size() > 1)
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        if (F.isEmpty(problems))
            log.info(INDEXES_INLINE_SIZE_ARE_THE_SAME);
        else
            printProblemsAndShowRecommendations(problems, log);
    }

    /** */
    private void printProblemsAndShowRecommendations(Map<String, Map<Integer, Set<UUID>>> problems, Logger log) {
        log.info(problems.size() +
            " index(es) have different effective inline size on nodes. It can lead to performance degradation in SQL queries.");
        log.info("Index(es):");

        for (Map.Entry<String, Map<Integer, Set<UUID>>> entry : problems.entrySet()) {
            SB sb = new SB();

            sb.a("Full index name: ").a(entry.getKey());

            for (Integer size : entry.getValue().keySet())
                sb.a(" nodes: ").a(entry.getValue().get(size)).a(" inline size: ").a(size).a(",");

            sb.setLength(sb.length() - 1);

            log.info(INDENT + sb);
        }

        log.info("");

        log.info("Recommendations:");
        log.info(
            INDENT + "Check that value of property " + IgniteSystemProperties.IGNITE_MAX_INDEX_PAYLOAD_SIZE + " are the same on all nodes."
        );
        log.info(INDENT + "Recreate indexes (execute DROP INDEX, CREATE INDEX commands) with different inline size.");
    }

    /** {@inheritDoc} */
    @Override public Void arg() {
        return null;
    }

    /** {@inheritDoc} */
    @Override public void printUsage(Logger logger) {
        usageCache(
            logger,
            CacheSubcommands.CHECK_INDEX_INLINE_SIZES,
            "Checks that secondary indexes inline size are same on the cluster nodes.",
            null
        );
    }

    /** {@inheritDoc} */
    @Override public String name() {
        return CacheSubcommands.CHECK_INDEX_INLINE_SIZES.text().toUpperCase();
    }
}


text:
package org.delta.system.service;

import org.delta.core.dao.Filter;
import org.delta.core.entity.service.EntityService;
import org.delta.core.metadata.EntityMetadata;
import org.delta.core.metadata.service.MetadataProvider;
import org.delta.core.utils.ValueMap;
import org.delta.system.SystemEntity;
import org.apache.commons.collections.MapUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;

/**
 * date: 2010-7-27
 *
 * version: 1.0
 * commonts: ......
 */
@Service
public class OrgService {
	private static Logger logger = Logger.getLogger(OrgService.class);

	private static ValueMap orgMap = null;

	@Resource
	private MetadataProvider metadataProvider;
	@Resource
	private EntityService entityService;

	@PostConstruct
	public void load() {
		orgMap = new ValueMap();
        EntityMetadata metadata = metadataProvider.getEntityMetadata(SystemEntity.ORG);
        List<ValueMap> list = entityService.list(SystemEntity.ORG, Filter.emptyFilter(), null);
        for (ValueMap map : list) {
            orgMap.put(MapUtils.getString(map, metadata.getPkCode()), map);
        }
	}

	public ValueMap getOrg(String id) {
		if (orgMap == null) {
			load();
		}
		return (ValueMap) orgMap.get(id);
	}
}


text:
A free LDL factorisation routine for quasi-definite linear systems: `Ax=b`

[![Build Status](https://travis-ci.org/oxfordcontrol/qdldl.svg?branch=master)](https://travis-ci.org/oxfordcontrol/qdldl)
[![Build status](https://ci.appveyor.com/api/projects/status/ns4br7v6y3i5stai/branch/master?svg=true)](https://ci.appveyor.com/project/bstellato/qdldl-8q1mv/branch/master)
[![Coverage Status](https://coveralls.io/repos/github/oxfordcontrol/qdldl/badge.svg)](https://coveralls.io/github/oxfordcontrol/qdldl)

## Getting started
To start using QDLDL, first clone the repository

```bash
git clone https://github.com/oxfordcontrol/qdldl.git
```

### Build

To build QDLDL, you need to install [cmake](https://cmake.org/) and run

```bash
mkdir build
cd build
cmake ..
cmake --build .
```

This will generate an `out/` folder with contents:

- `qdldl_example`: a **code example** from [`examples/c/example.c`](./examples/c/example.c)
- `libqdldl`: a static and a dynamic versions of the library.

You can include an addition option `-DUNITTESTS=ON` when calling `cmake`, which will result in an additional executable `qdldl_tester` being built in the `out/` folder to test QDLDL on a variety of problems, including those with rank deficient or otherwise ill-formatted inputs.

**N.B.** All files will have file extensions appropriate to your operating system.

### Install/Uninstall

To install (uninstall) the libraries and headers you can simply run `make install` (`make uninstall`) after running the `cmake` command above.

## Calling QDLDL

### Main API

The QDLDL API consists of 5 functions documented in [`include/qdldl.h`](./include/qdldl.h).
For more details and a working example see [`examples/c/example.c`](./examples/c/example.c).

**N.B.** There is **no memory allocation** performed in these routines. The user is assumed to have the working vectors already allocated.

Here is a brief summary.

* `QDLDL_etree`: compute the elimination tree for the quasidefinite matrix factorization `A = LDL'`
* `QDLDL_factor`: return the factors `L`, `D` and `Dinv = 1./D`
* `QDLDL_solve`: solves the linear system `LDL'x = b`
* `QDLDL_Lsolve`: solves `Lx = b`
* `QDLDL_Ltsolve`: solves `L'x = b`

In the above function calls the matrices `A` and `L` are stored in compressed sparse column (CSC) format.   The matrix `A` is assumed to be symmetric and only the upper triangular portion of A should be passed to the API.   The factor `L` is lower triangular with implicit ones on the diagonal (i.e. the diagonal of L is not stored as part of the CSC formatted data.)

The matrices `D` and `Dinv` are both diagonal matrices, with the diagonal values stored in an array.

The matrix input `A` should be quasidefinite.   The API provides some (non-comprehensive) error checking to protect against non-quasidefinite or non-upper triangular inputs.

### Custom types for integer, floats and booleans
QDLDL uses its own internal types for integers, floats and booleans (`QDLDL_int, QDLDL_float, QDLDL_bool`. They can be specified using the cmake options:

- `DFLOAT` (default false): uses float numbers instead of doubles
- `DLONG` (default true): uses long integers for indexing (for large matrices)

The `QDLDL_bool` is internally defined as `unsigned char`.

## Linking QDLDL

### Basic Example
A basic example appears in [`examples/c/example.c`](./examples/c/example.c) and is compiled using cmake and the `CMakeLists.txt` file in the root folder.

### Including in a cmake project

You can include QDLDL in a cmake project `foo` by adding the subdirectory as
```
# Add project
add_subdirectory(qdldl)
```

QDLDL can be linked using a static or dynamic linker
```
# Link static library
target_link_libraries (foo qdldlstatic)

# Link shared library
target_link_libraries (foo qdldl)
```
for dynamic linking the shared library should be available in your path.

There is also the option to include QDLDL as an object library in your project.
The current `CMakeLists.txt` file creates an object library called `qdldlobject`.
This can be added to your project by adding it after your sources.
For example, when creating a library `foo` you can add

```
add_library(foo foo.c foo.h $<TARGET_OBJECTS:qdldlobject>)
```
for more details see the [cmake documentation](https://cmake.org/cmake/help/latest/command/add_library.html#object-libraries).

## The algorithm

The algorithm is an independent implementation of the elimination tree and factorisation procedures outlined in

> T. A Davis. [Algorithm 849: a concise sparse cholesky factorization package](https://dl.acm.org/citation.cfm?id=1114277). ACM Trans. Math. Softw., 31(4):587–591, 2005.

## Credits

- [Paul Goulart](http://users.ox.ac.uk/~engs1373/): main development
- [Bartolomeo Stellato](https://stellato.io/): code refactoring and testing
- [Goran Banjac](http://control.ee.ethz.ch/~gbanjac/)


text:
@interface ComGoogleCommonCollectSortedMultisets ()

- (instancetype)init;

+ (id)getElementOrThrowWithComGoogleCommonCollectMultiset_Entry:(id<ComGoogleCommonCollectMultiset_Entry>)entry_;

+ (id)getElementOrNullWithComGoogleCommonCollectMultiset_Entry:(id<ComGoogleCommonCollectMultiset_Entry>)entry_;

@end

__attribute__((unused)) static void ComGoogleCommonCollectSortedMultisets_init(ComGoogleCommonCollectSortedMultisets *self);

__attribute__((unused)) static ComGoogleCommonCollectSortedMultisets *new_ComGoogleCommonCollectSortedMultisets_init() NS_RETURNS_RETAINED;

__attribute__((unused)) static ComGoogleCommonCollectSortedMultisets *create_ComGoogleCommonCollectSortedMultisets_init();

__attribute__((unused)) static id ComGoogleCommonCollectSortedMultisets_getElementOrThrowWithComGoogleCommonCollectMultiset_Entry_(id<ComGoogleCommonCollectMultiset_Entry> entry_);

__attribute__((unused)) static id ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_(id<ComGoogleCommonCollectMultiset_Entry> entry_);

__attribute__((unused)) static IOSObjectArray *ComGoogleCommonCollectSortedMultisets__Annotations$0();

@interface ComGoogleCommonCollectSortedMultisets_ElementSet () {
 @public
  __unsafe_unretained id<ComGoogleCommonCollectSortedMultiset> multiset_;
}

@end

__attribute__((unused)) static id<ComGoogleCommonCollectSortedMultiset> ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(ComGoogleCommonCollectSortedMultisets_ElementSet *self);

@implementation ComGoogleCommonCollectSortedMultisets

J2OBJC_IGNORE_DESIGNATED_BEGIN
- (instancetype)init {
  ComGoogleCommonCollectSortedMultisets_init(self);
  return self;
}
J2OBJC_IGNORE_DESIGNATED_END

+ (id)getElementOrThrowWithComGoogleCommonCollectMultiset_Entry:(id<ComGoogleCommonCollectMultiset_Entry>)entry_ {
  return ComGoogleCommonCollectSortedMultisets_getElementOrThrowWithComGoogleCommonCollectMultiset_Entry_(entry_);
}

+ (id)getElementOrNullWithComGoogleCommonCollectMultiset_Entry:(id<ComGoogleCommonCollectMultiset_Entry>)entry_ {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_(entry_);
}

+ (const J2ObjcClassInfo *)__metadata {
  static J2ObjcMethodInfo methods[] = {
    { NULL, NULL, 0x2, -1, -1, -1, -1, -1, -1 },
    { NULL, "LNSObject;", 0xa, 0, 1, -1, 2, -1, -1 },
    { NULL, "LNSObject;", 0xa, 3, 1, -1, 2, -1, 4 },
  };
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wobjc-multiple-method-names"
  methods[0].selector = @selector(init);
  methods[1].selector = @selector(getElementOrThrowWithComGoogleCommonCollectMultiset_Entry:);
  methods[2].selector = @selector(getElementOrNullWithComGoogleCommonCollectMultiset_Entry:);
  #pragma clang diagnostic pop
  static const void *ptrTable[] = { "getElementOrThrow", "LComGoogleCommonCollectMultiset_Entry;", "<E:Ljava/lang/Object;>(Lcom/google/common/collect/Multiset$Entry<TE;>;)TE;", "getElementOrNull", (void *)&ComGoogleCommonCollectSortedMultisets__Annotations$0, "LComGoogleCommonCollectSortedMultisets_ElementSet;LComGoogleCommonCollectSortedMultisets_NavigableElementSet;" };
  static const J2ObjcClassInfo _ComGoogleCommonCollectSortedMultisets = { "SortedMultisets", "com.google.common.collect", ptrTable, methods, NULL, 7, 0x10, 3, 0, -1, 5, -1, -1, -1 };
  return &_ComGoogleCommonCollectSortedMultisets;
}

@end

void ComGoogleCommonCollectSortedMultisets_init(ComGoogleCommonCollectSortedMultisets *self) {
  NSObject_init(self);
}

ComGoogleCommonCollectSortedMultisets *new_ComGoogleCommonCollectSortedMultisets_init() {
  J2OBJC_NEW_IMPL(ComGoogleCommonCollectSortedMultisets, init)
}

ComGoogleCommonCollectSortedMultisets *create_ComGoogleCommonCollectSortedMultisets_init() {
  J2OBJC_CREATE_IMPL(ComGoogleCommonCollectSortedMultisets, init)
}

id ComGoogleCommonCollectSortedMultisets_getElementOrThrowWithComGoogleCommonCollectMultiset_Entry_(id<ComGoogleCommonCollectMultiset_Entry> entry_) {
  ComGoogleCommonCollectSortedMultisets_initialize();
  if (entry_ == nil) {
    @throw new_JavaUtilNoSuchElementException_init();
  }
  return [entry_ getElement];
}

id ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_(id<ComGoogleCommonCollectMultiset_Entry> entry_) {
  ComGoogleCommonCollectSortedMultisets_initialize();
  return (entry_ == nil) ? nil : [((id<ComGoogleCommonCollectMultiset_Entry>) nil_chk(entry_)) getElement];
}

IOSObjectArray *ComGoogleCommonCollectSortedMultisets__Annotations$0() {
  return [IOSObjectArray newArrayWithObjects:(id[]){ [IOSObjectArray newArrayWithObjects:(id[]){ create_JavaxAnnotationNullable() } count:1 type:JavaLangAnnotationAnnotation_class_()] } count:1 type:IOSClass_arrayType(JavaLangAnnotationAnnotation_class_(), 1)];
}

J2OBJC_CLASS_TYPE_LITERAL_SOURCE(ComGoogleCommonCollectSortedMultisets)

@implementation ComGoogleCommonCollectSortedMultisets_ElementSet

- (instancetype)initWithComGoogleCommonCollectSortedMultiset:(id<ComGoogleCommonCollectSortedMultiset>)multiset {
  ComGoogleCommonCollectSortedMultisets_ElementSet_initWithComGoogleCommonCollectSortedMultiset_(self, multiset);
  return self;
}

- (id<ComGoogleCommonCollectSortedMultiset>)multiset {
  return ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self);
}

- (id<JavaUtilComparator>)comparator {
  return [((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) comparator];
}

- (id<JavaUtilSortedSet>)subSetWithId:(id)fromElement
                               withId:(id)toElement {
  return [((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) subMultisetWithId:fromElement withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, CLOSED) withId:toElement withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, OPEN)])) elementSet];
}

- (id<JavaUtilSortedSet>)headSetWithId:(id)toElement {
  return [((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) headMultisetWithId:toElement withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, OPEN)])) elementSet];
}

- (id<JavaUtilSortedSet>)tailSetWithId:(id)fromElement {
  return [((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) tailMultisetWithId:fromElement withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, CLOSED)])) elementSet];
}

- (id)first {
  return ComGoogleCommonCollectSortedMultisets_getElementOrThrowWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) firstEntry]);
}

- (id)last {
  return ComGoogleCommonCollectSortedMultisets_getElementOrThrowWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) lastEntry]);
}

- (id<JavaUtilSpliterator>)spliterator {
  return JavaUtilSortedSet_spliterator(self);
}

- (void)__javaClone:(ComGoogleCommonCollectSortedMultisets_ElementSet *)original {
  [super __javaClone:original];
  JreRelease(multiset_);
}

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id *)stackbuf count:(NSUInteger)len {
  return JreDefaultFastEnumeration(self, state, stackbuf, len);
}

+ (const J2ObjcClassInfo *)__metadata {
  static J2ObjcMethodInfo methods[] = {
    { NULL, NULL, 0x0, -1, 0, -1, 1, -1, -1 },
    { NULL, "LComGoogleCommonCollectSortedMultiset;", 0x10, -1, -1, -1, 2, -1, -1 },
    { NULL, "LJavaUtilComparator;", 0x1, -1, -1, -1, 3, -1, -1 },
    { NULL, "LJavaUtilSortedSet;", 0x1, 4, 5, -1, 6, -1, -1 },
    { NULL, "LJavaUtilSortedSet;", 0x1, 7, 8, -1, 9, -1, -1 },
    { NULL, "LJavaUtilSortedSet;", 0x1, 10, 8, -1, 9, -1, -1 },
    { NULL, "LNSObject;", 0x1, -1, -1, -1, 11, -1, -1 },
    { NULL, "LNSObject;", 0x1, -1, -1, -1, 11, -1, -1 },
  };
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wobjc-multiple-method-names"
  methods[0].selector = @selector(initWithComGoogleCommonCollectSortedMultiset:);
  methods[1].selector = @selector(multiset);
  methods[2].selector = @selector(comparator);
  methods[3].selector = @selector(subSetWithId:withId:);
  methods[4].selector = @selector(headSetWithId:);
  methods[5].selector = @selector(tailSetWithId:);
  methods[6].selector = @selector(first);
  methods[7].selector = @selector(last);
  #pragma clang diagnostic pop
  static const J2ObjcFieldInfo fields[] = {
    { "multiset_", "LComGoogleCommonCollectSortedMultiset;", .constantValue.asLong = 0, 0x12, -1, -1, 12, -1 },
  };
  static const void *ptrTable[] = { "LComGoogleCommonCollectSortedMultiset;", "(Lcom/google/common/collect/SortedMultiset<TE;>;)V", "()Lcom/google/common/collect/SortedMultiset<TE;>;", "()Ljava/util/Comparator<-TE;>;", "subSet", "LNSObject;LNSObject;", "(TE;TE;)Ljava/util/SortedSet<TE;>;", "headSet", "LNSObject;", "(TE;)Ljava/util/SortedSet<TE;>;", "tailSet", "()TE;", "Lcom/google/common/collect/SortedMultiset<TE;>;", "LComGoogleCommonCollectSortedMultisets;", "<E:Ljava/lang/Object;>Lcom/google/common/collect/Multisets$ElementSet<TE;>;Ljava/util/SortedSet<TE;>;" };
  static const J2ObjcClassInfo _ComGoogleCommonCollectSortedMultisets_ElementSet = { "ElementSet", "com.google.common.collect", ptrTable, methods, fields, 7, 0x8, 8, 1, 13, -1, -1, 14, -1 };
  return &_ComGoogleCommonCollectSortedMultisets_ElementSet;
}

@end

void ComGoogleCommonCollectSortedMultisets_ElementSet_initWithComGoogleCommonCollectSortedMultiset_(ComGoogleCommonCollectSortedMultisets_ElementSet *self, id<ComGoogleCommonCollectSortedMultiset> multiset) {
  ComGoogleCommonCollectMultisets_ElementSet_init(self);
  self->multiset_ = multiset;
}

ComGoogleCommonCollectSortedMultisets_ElementSet *new_ComGoogleCommonCollectSortedMultisets_ElementSet_initWithComGoogleCommonCollectSortedMultiset_(id<ComGoogleCommonCollectSortedMultiset> multiset) {
  J2OBJC_NEW_IMPL(ComGoogleCommonCollectSortedMultisets_ElementSet, initWithComGoogleCommonCollectSortedMultiset_, multiset)
}

ComGoogleCommonCollectSortedMultisets_ElementSet *create_ComGoogleCommonCollectSortedMultisets_ElementSet_initWithComGoogleCommonCollectSortedMultiset_(id<ComGoogleCommonCollectSortedMultiset> multiset) {
  J2OBJC_CREATE_IMPL(ComGoogleCommonCollectSortedMultisets_ElementSet, initWithComGoogleCommonCollectSortedMultiset_, multiset)
}

id<ComGoogleCommonCollectSortedMultiset> ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(ComGoogleCommonCollectSortedMultisets_ElementSet *self) {
  return self->multiset_;
}

J2OBJC_CLASS_TYPE_LITERAL_SOURCE(ComGoogleCommonCollectSortedMultisets_ElementSet)

@implementation ComGoogleCommonCollectSortedMultisets_NavigableElementSet

- (instancetype)initWithComGoogleCommonCollectSortedMultiset:(id<ComGoogleCommonCollectSortedMultiset>)multiset {
  ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_(self, multiset);
  return self;
}

- (id)lowerWithId:(id)e {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) headMultisetWithId:e withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, OPEN)])) lastEntry]);
}

- (id)floorWithId:(id)e {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) headMultisetWithId:e withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, CLOSED)])) lastEntry]);
}

- (id)ceilingWithId:(id)e {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) tailMultisetWithId:e withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, CLOSED)])) firstEntry]);
}

- (id)higherWithId:(id)e {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) tailMultisetWithId:e withComGoogleCommonCollectBoundType:JreLoadEnum(ComGoogleCommonCollectBoundType, OPEN)])) firstEntry]);
}

- (id<JavaUtilNavigableSet>)descendingSet {
  return new_ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) descendingMultiset]);
}

- (id<JavaUtilIterator>)descendingIterator {
  return [((id<JavaUtilNavigableSet>) nil_chk([self descendingSet])) iterator];
}

- (id)pollFirst {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) pollFirstEntry]);
}

- (id)pollLast {
  return ComGoogleCommonCollectSortedMultisets_getElementOrNullWithComGoogleCommonCollectMultiset_Entry_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) pollLastEntry]);
}

- (id<JavaUtilNavigableSet>)subSetWithId:(id)fromElement
                             withBoolean:(jboolean)fromInclusive
                                  withId:(id)toElement
                             withBoolean:(jboolean)toInclusive {
  return new_ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) subMultisetWithId:fromElement withComGoogleCommonCollectBoundType:ComGoogleCommonCollectBoundType_forBooleanWithBoolean_(fromInclusive) withId:toElement withComGoogleCommonCollectBoundType:ComGoogleCommonCollectBoundType_forBooleanWithBoolean_(toInclusive)]);
}

- (id<JavaUtilNavigableSet>)headSetWithId:(id)toElement
                              withBoolean:(jboolean)inclusive {
  return new_ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) headMultisetWithId:toElement withComGoogleCommonCollectBoundType:ComGoogleCommonCollectBoundType_forBooleanWithBoolean_(inclusive)]);
}

- (id<JavaUtilNavigableSet>)tailSetWithId:(id)fromElement
                              withBoolean:(jboolean)inclusive {
  return new_ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_([((id<ComGoogleCommonCollectSortedMultiset>) nil_chk(ComGoogleCommonCollectSortedMultisets_ElementSet_multiset(self))) tailMultisetWithId:fromElement withComGoogleCommonCollectBoundType:ComGoogleCommonCollectBoundType_forBooleanWithBoolean_(inclusive)]);
}

- (NSUInteger)countByEnumeratingWithState:(NSFastEnumerationState *)state objects:(__unsafe_unretained id *)stackbuf count:(NSUInteger)len {
  return JreDefaultFastEnumeration(self, state, stackbuf, len);
}

+ (const J2ObjcClassInfo *)__metadata {
  static J2ObjcMethodInfo methods[] = {
    { NULL, NULL, 0x0, -1, 0, -1, 1, -1, -1 },
    { NULL, "LNSObject;", 0x1, 2, 3, -1, 4, -1, -1 },
    { NULL, "LNSObject;", 0x1, 5, 3, -1, 4, -1, -1 },
    { NULL, "LNSObject;", 0x1, 6, 3, -1, 4, -1, -1 },
    { NULL, "LNSObject;", 0x1, 7, 3, -1, 4, -1, -1 },
    { NULL, "LJavaUtilNavigableSet;", 0x1, -1, -1, -1, 8, -1, -1 },
    { NULL, "LJavaUtilIterator;", 0x1, -1, -1, -1, 9, -1, -1 },
    { NULL, "LNSObject;", 0x1, -1, -1, -1, 10, -1, -1 },
    { NULL, "LNSObject;", 0x1, -1, -1, -1, 10, -1, -1 },
    { NULL, "LJavaUtilNavigableSet;", 0x1, 11, 12, -1, 13, -1, -1 },
    { NULL, "LJavaUtilNavigableSet;", 0x1, 14, 15, -1, 16, -1, -1 },
    { NULL, "LJavaUtilNavigableSet;", 0x1, 17, 15, -1, 16, -1, -1 },
  };
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wobjc-multiple-method-names"
  methods[0].selector = @selector(initWithComGoogleCommonCollectSortedMultiset:);
  methods[1].selector = @selector(lowerWithId:);
  methods[2].selector = @selector(floorWithId:);
  methods[3].selector = @selector(ceilingWithId:);
  methods[4].selector = @selector(higherWithId:);
  methods[5].selector = @selector(descendingSet);
  methods[6].selector = @selector(descendingIterator);
  methods[7].selector = @selector(pollFirst);
  methods[8].selector = @selector(pollLast);
  methods[9].selector = @selector(subSetWithId:withBoolean:withId:withBoolean:);
  methods[10].selector = @selector(headSetWithId:withBoolean:);
  methods[11].selector = @selector(tailSetWithId:withBoolean:);
  #pragma clang diagnostic pop
  static const void *ptrTable[] = { "LComGoogleCommonCollectSortedMultiset;", "(Lcom/google/common/collect/SortedMultiset<TE;>;)V", "lower", "LNSObject;", "(TE;)TE;", "floor", "ceiling", "higher", "()Ljava/util/NavigableSet<TE;>;", "()Ljava/util/Iterator<TE;>;", "()TE;", "subSet", "LNSObject;ZLNSObject;Z", "(TE;ZTE;Z)Ljava/util/NavigableSet<TE;>;", "headSet", "LNSObject;Z", "(TE;Z)Ljava/util/NavigableSet<TE;>;", "tailSet", "LComGoogleCommonCollectSortedMultisets;", "<E:Ljava/lang/Object;>Lcom/google/common/collect/SortedMultisets$ElementSet<TE;>;Ljava/util/NavigableSet<TE;>;" };
  static const J2ObjcClassInfo _ComGoogleCommonCollectSortedMultisets_NavigableElementSet = { "NavigableElementSet", "com.google.common.collect", ptrTable, methods, NULL, 7, 0x8, 12, 0, 18, -1, -1, 19, -1 };
  return &_ComGoogleCommonCollectSortedMultisets_NavigableElementSet;
}

@end

void ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_(ComGoogleCommonCollectSortedMultisets_NavigableElementSet *self, id<ComGoogleCommonCollectSortedMultiset> multiset) {
  ComGoogleCommonCollectSortedMultisets_ElementSet_initWithComGoogleCommonCollectSortedMultiset_(self, multiset);
}

ComGoogleCommonCollectSortedMultisets_NavigableElementSet *new_ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_(id<ComGoogleCommonCollectSortedMultiset> multiset) {
  J2OBJC_NEW_IMPL(ComGoogleCommonCollectSortedMultisets_NavigableElementSet, initWithComGoogleCommonCollectSortedMultiset_, multiset)
}

ComGoogleCommonCollectSortedMultisets_NavigableElementSet *create_ComGoogleCommonCollectSortedMultisets_NavigableElementSet_initWithComGoogleCommonCollectSortedMultiset_(id<ComGoogleCommonCollectSortedMultiset> multiset) {
  J2OBJC_CREATE_IMPL(ComGoogleCommonCollectSortedMultisets_NavigableElementSet, initWithComGoogleCommonCollectSortedMultiset_, multiset)
}

J2OBJC_CLASS_TYPE_LITERAL_SOURCE(ComGoogleCommonCollectSortedMultisets_NavigableElementSet)


text:
import WebpackDevServer from 'webpack-dev-server';
import webpack from 'webpack';
import config from '../webpack.config.dev';

const compiler = webpack(config);

// Live reload
config.entry.app.unshift(`webpack-dev-server/client?http://localhost:${process.env.DEV_SERVER_PORT}/`);

const server = new WebpackDevServer(compiler, {
  contentBase: '/dist',
  historyApiFallback: true,
  quiet: false,
  noInfo: false,
  filename: 'app.js',
  watchOptions: {
    aggregateTimeout: 300,
    poll: 1000,
  },
  headers: { 'X-Custom-Header': 'yes' },
  stats: { colors: true },
});

server.listen(
  process.env.DEV_SERVER_PORT || 8080,
  'localhost',
);


text:
package etcd

import (
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apiserver/pkg/registry/generic"
	"k8s.io/apiserver/pkg/registry/generic/registry"
	"k8s.io/apiserver/pkg/registry/rest"
	"k8s.io/apiserver/pkg/storage"
	"k8s.io/kubernetes/pkg/printers"
	printerstorage "k8s.io/kubernetes/pkg/printers/storage"

	"github.com/openshift/api/oauth"
	oauthapi "github.com/openshift/origin/pkg/oauth/apis/oauth"
	"github.com/openshift/origin/pkg/oauth/apiserver/registry/oauthauthorizetoken"
	"github.com/openshift/origin/pkg/oauth/apiserver/registry/oauthclient"
	printersinternal "github.com/openshift/origin/pkg/printers/internalversion"
)

// rest implements a RESTStorage for authorize tokens against etcd
type REST struct {
	*registry.Store
}

var _ rest.StandardStorage = &REST{}

// NewREST returns a RESTStorage object that will work against authorize tokens
func NewREST(optsGetter generic.RESTOptionsGetter, clientGetter oauthclient.Getter) (*REST, error) {
	strategy := oauthauthorizetoken.NewStrategy(clientGetter)
	store := &registry.Store{
		NewFunc:                  func() runtime.Object { return &oauthapi.OAuthAuthorizeToken{} },
		NewListFunc:              func() runtime.Object { return &oauthapi.OAuthAuthorizeTokenList{} },
		DefaultQualifiedResource: oauth.Resource("oauthauthorizetokens"),

		TableConvertor: printerstorage.TableConvertor{TablePrinter: printers.NewTablePrinter().With(printersinternal.AddHandlers)},

		TTLFunc: func(obj runtime.Object, existing uint64, update bool) (uint64, error) {
			token := obj.(*oauthapi.OAuthAuthorizeToken)
			expires := uint64(token.ExpiresIn)
			return expires, nil
		},

		CreateStrategy: strategy,
		UpdateStrategy: strategy,
		DeleteStrategy: strategy,
	}

	options := &generic.StoreOptions{
		RESTOptions: optsGetter,
		AttrFunc:    storage.AttrFunc(storage.DefaultNamespaceScopedAttr).WithFieldMutation(oauthapi.OAuthAuthorizeTokenFieldSelector),
	}
	if err := store.CompleteWithOptions(options); err != nil {
		return nil, err
	}
	return &REST{store}, nil
}


text:
namespace mojo {
namespace test {

StructWithTraitsImpl::StructWithTraitsImpl() {}

StructWithTraitsImpl::~StructWithTraitsImpl() {}

}  // namespace test
}  // namespace mojo


text:
import json
from js9 import j
from .Message import Message
import JumpScale9.data.email.Sender as Sender
from .utils import get_msg_path, get_json_msg

JSBASE = j.application.jsbase_get_class()
class EmailTool(JSBASE):

    def __init__(self):
        self.__jslocation__ = "j.tools.email"
        JSBASE.__init__(self)

    def _get_lastest_keys(self, n=100):
        """
        Gets the latest (n) keys in the the queue

        :return: list

        """
        return j.core.db.lrange('mails.queue', -1 * n, -1)

    def getLast(self, num=100):
        """
        Gets most recent `num` emails

        :return: list
        """

        messages = []
        keys = self._get_lastest_keys()
        for k in keys:
            m = Message(k, j.core.db.hmget('mails', key))
            messages.append(m)

        return messages

    def _pop_key(self, n=1):
        """
        pops the most recent (n) keys in the queue.

        :returns a key
        """
        return j.core.db.lpop('mails.queue', n)

    def pop(self):
        """
        Pops oldest email from the queue.

        :return: Message
        """
        #  we are adding from the right. the oldest is the one on the left.
        k = self._pop_key()  # ts-guid
        msg = get_json_msg(k)  # get message path
        return Message(k, msg)

    def getSender(self, username, password, host='smtp.mandrillapp.com', port=587):
        return Sender.Sender(username, password, host, port)

    def getDefaultSender(self):
        """
        Gets the default configured email sender

        :return: Sender instance
        """
        #BAD SHOULD NOT BE DONE LIKE THIS !

        # cfg = j.data.serializer.yaml.load(j.sal.fs.joinPaths(j.dirs.JSCFGDIR, 'smtp.yaml'))
        # return self.getSender(cfg['username'], cfg['password'], cfg['host'], cfg['port'])


text:
require 'spec_helper'

describe GoogleDistanceMatrix::Places do
  let(:values) { [{ address: 'one' }, { address: 'two' }, { address: 'three' }] }
  let(:places) { values.map { |v| GoogleDistanceMatrix::Place.new v } }

  let(:place_4) { GoogleDistanceMatrix::Place.new address: 'four' }
  let(:place_5) { GoogleDistanceMatrix::Place.new address: 'five' }
  let(:place_6) { GoogleDistanceMatrix::Place.new address: 'six' }

  subject { described_class.new places }

  it { should include(*places) }
  it { should_not include 5 }

  %w[<< push unshift].each do |attr|
    describe attr.to_s do
      it 'adds value' do
        expect do
          subject.public_send attr, place_4
        end.to change { subject.include? place_4 }.to true
      end

      it 'keeps uniq values' do
        subject.public_send attr, place_4

        expect do
          subject.public_send attr, place_4
        end.to_not change subject, :length
      end

      it 'is chanable' do
        subject.public_send(attr, place_5).public_send(attr, place_6)

        expect(subject).to include place_5, place_6
      end

      it 'wraps values in a Place' do
        subject.public_send attr, address: 'four'

        expect(subject.all? { |place| place.is_a? GoogleDistanceMatrix::Place }).to be true
        expect(subject.any? { |place| place.address == 'four' }).to be true
      end
    end
  end

  %w[push unshift].each do |attr|
    describe attr.to_s do
      it 'adds multiple values at once' do
        subject.public_send attr, place_4, place_5
        expect(subject).to include place_4, place_5
      end
    end
  end

  describe '#concat' do
    let(:places_2) { [place_4, place_5, place_6] }

    it 'adds the given array' do
      subject.concat places_2
      expect(subject).to include(*places_2)
    end

    it 'keeps values uniq' do
      subject.concat places_2

      expect do
        subject.concat places_2
      end.to_not change subject, :length
    end

    it 'returns self' do
      expect(subject.concat(places_2)).to eq subject
    end
  end
end


text:
import React from 'react';
import VideoStore from './VideoStore';
import AppActions from './actions/AppActions';
import styles from './VideoItem.less';

function getSelectState() {
  return {
    sortOption: VideoStore.getSort()
  };
}

const SortVideos = React.createClass({

  getInitialState () {
    return getSelectState();
  },

  componentDidMount: function () {
    VideoStore.addChangeListener(this._onChange);
  },

  componentWillUnmount: function () {
    VideoStore.removeChangeListener(this._onChange);
  },

  handleChange (e) {
    AppActions.changeSort(e.target.value)
  },

  render() {

    return (
      <div className={styles.sorting}>Sort by:
        <select name="sortBy" value={this.state.sortOption}
                onChange={this.handleChange}>
          <option></option>
          <option value="mostRecent">Most recent</option>
          <option value="mostPopular">Most popular this month</option>
        </select>
      </div>
    );
  },

  _onChange () {
    this.setState(getSelectState());
  }

});

export default SortVideos;


text:
/* You can add global styles to this file, and also import other style files */

@import '~https://fonts.googleapis.com/icon?family=Material+Icons';
@import '~@angular/material/core/theming/prebuilt/indigo-pink.css';


text:
<?php
require_once 'resources/init.php';

require_once 'template/header.inc.php';
?>

ABOUT

<?php
require_once 'template/footer.inc.php';
?>


text:
namespace MarkdownFileHandler.Models
{
    public class AsyncActionModel
    {
        public string JobIdentifier { get; set; }

        public MarkdownFileHandler.JobStatus Status { get; set; }

        public string Title { get; set; }

    }
}


text:
package object

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"reflect"
	"strconv"
	"time"
)

// Object struct encapsulates our key-value pairs (KV) and a single-item
// per-key history of the previous value stored for a given key
// (ChangedColumns).  We also store any instances of 'child records'
// which may be relevant (for instance, when saving with nested
// transactions).  'dirty' is used to track the internal state of
// whether an object was recently modified since being retrieved from the
// underlying database.
type Object struct {
	Type           string
	KV             map[string]interface{}
	HiddenKV       map[string]interface{}
	ChangedColumns map[string]interface{}
	Children       map[string]Array
	Dirty          bool
}

func (o *Object) CopyTo(dest *Object) error {
	data, err := json.Marshal(o)
	if err != nil {
		return err
	}

	err = json.Unmarshal([]byte(data), &dest)
	if err != nil {
		return err
	}
	return nil
}

// New is an empty constructor
func New(objType string) *Object {
	return &Object{Type: objType, KV: makeEmptyMap(), HiddenKV: nil,
		ChangedColumns: makeEmptyMap(), Children: makeEmptyChildrenMap(),
		Dirty: true}
}

// just a bit of shorthand for the methods below
func makeEmptyMap() map[string]interface{} {
	return make(map[string]interface{})
}

// MakeHiddenKVIfNeeded allocates an empty map and assigns it to HiddenKV if needed.
func (o *Object) MakeHiddenKVIfNeeded() {
	if o.HiddenKV == nil {
		o.HiddenKV = makeEmptyMap()
	}
}

// Get is the most basic accessor, for cases
// that may not be handled by other methods
func (o *Object) Get(k string) interface{} {
	return o.KV[k]
}

// GetWithFlag is the second most basic accessor, for cases
// that may not be handled by other methods
func (o *Object) GetWithFlag(k string) (interface{}, bool) {
	v, ok := o.KV[k]
	return v, ok
}

// HiddenGetWithFlag is the second most basic accessor, for cases
// that may not be handled by other methods
func (o *Object) HiddenGetWithFlag(k string) (interface{}, bool) {
	if o.HiddenKV == nil {
		return nil, false
	}
	_, ok := o.HiddenKV[k]
	return nil, ok
}

// GetString is a safe, typed string accessor
func (o *Object) GetString(k string) (string, bool) {
	v, ok := o.KV[k].(string)
	return v, ok
}

func (o *Object) GetTime(k string) (*time.Time, error) {
	v, ok := o.KV[k]
	if !ok {
		return nil, ErrKeyWasMissing
	}

	switch v.(type) {
	case time.Time:
		fl := v.(time.Time)
		return &fl, nil
	case *time.Time:
		fl := v.(*time.Time)
		return fl, nil
	// If / when we see any SQLValues for a time value.. we'll have to get tricky.
	// TODO: Add test cases for this scenario.
	case *SQLValue:
		fl := v.(*SQLValue)
		if ValueIsNULL(fl) {
			return &time.Time{}, nil
		}
		// what do we do?
		return nil, fmt.Errorf("GetTime: unknown SQLValue '%v'", fl)
	case nil:
		return nil, ErrValueWasNil
	default:
		return nil, fmt.Errorf("GetTime: unrecognized type %v", reflect.TypeOf(v))
	}
}

// GetStringCastCore is a safe, typed string accessor. It will force conversion away
// from float64, int64, uint64, string, and nil values. Nils and unrecognized values
// are marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetStringCastCore(v interface{}) (string, error) {
	switch v.(type) {
	case float32:
		fl := v.(float32)
		// TODO: Turn these into strconv, which is much faster.
		return strconv.FormatFloat(float64(fl), 'f', 6, 64), nil
	case float64:
		fl := v.(float64)
		return strconv.FormatFloat(fl, 'f', 6, 64), nil
	case int:
		fl := v.(int)
		return strconv.Itoa(fl), nil
	case int64:
		fl := v.(int64)
		return strconv.FormatInt(fl, 10), nil
	case uint64:
		fl := v.(uint64)
		return strconv.FormatUint(fl, 10), nil
	case string:
		fl := v.(string)
		return fl, nil
	case sql.NullString:
		fl := v.(sql.NullString)
		if !fl.Valid {
			return "", ErrValueWasNil
		}
		return fl.String, nil
	case *sql.NullString:
		fl := v.(*sql.NullString)
		if !fl.Valid {
			return "", ErrValueWasNil
		}
		return fl.String, nil
	case *SQLValue:
		fl := v.(*SQLValue)
		// TODO: Should return ErrIsSQLValue as a flag error?
		return fl.String(), nil
	case SQLValue:
		fl := v.(SQLValue)
		// TODO: Should return ErrIsSQLValue as a flag error?
		return fl.String(), nil
	case bool:
		fl := v.(bool)
		if fl {
			return "true", nil
		} else {
			return "false", nil
		}
	case nil:
		return "", ErrValueWasNil
	default:
		return "", fmt.Errorf("GetStringCastCore: unrecognized type %v", reflect.TypeOf(v))
	}
}

// GetStringCast is a safe, typed string accessor. It will force conversion away
// from float64, int64, uint64, string, and nil values. Nils and unrecognized values
// are marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetStringCast(k string) (string, error) {
	v, ok := o.KV[k]
	if !ok {
		return "", ErrKeyWasMissing
	}

	return o.GetStringCastCore(v)
}

// GetStringAlways is a safe, typed string accessor. It will force conversion away
// from float64, int64, uint64, string, and nil values. Nils and unrecognized values
// are marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetStringAlways(k string) (string, error) {
	return o.GetStringCast(k)
}

// GetFloatCast is a safe, typed float64 accessor. It will force conversion away
// from float64, int64, uint64, string, and nil values. Nils and unrecognized values
// are marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetFloatCast(k string) (float64, error) {
	v, ok := o.KV[k]
	if !ok {
		return 0, ErrKeyWasMissing
	}

	switch v.(type) {
	case float32:
		fl := v.(float32)
		return float64(fl), nil
	case float64:
		fl := v.(float64)
		return fl, nil
	case int:
		fl := v.(int)
		return float64(fl), nil
	case int64:
		fl := v.(int64)
		return float64(fl), nil
	case uint64:
		fl := v.(uint64)
		return float64(fl), nil
	case string:
		fl := v.(string)
		return strconv.ParseFloat(fl, 64)
	case bool:
		return 0, ErrRefusingCast
	case nil:
		return 0, ErrValueWasNil
	default:
		return 0, fmt.Errorf("GetFloatCast: unrecognized type %v", reflect.TypeOf(v))
	}
}

// GetFloatAlways is a safe, typed float64 accessor. It will force conversion away
// from float64, int64, uint64, string, and nil values. Nils and unrecognized values
// are marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetFloatAlways(k string) (float64, error) {
	return o.GetFloatCast(k)
}

// GetIntCast is a safe, typed int64 accessor. It will force conversion away
// from float64, uint64, int64 and string values. Nils and unrecognized values are
// marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetInt64(k string) (int64, error) {
	v, ok := o.KV[k]
	if !ok {
		return 0, ErrKeyWasMissing
	}

	switch v.(type) {
	case int:
		fl := v.(int)
		return int64(fl), nil
	case int32:
		fl := v.(int32)
		return int64(fl), nil
	case int64:
		fl := v.(int64)
		return fl, nil
	case uint32:
		fl := v.(uint32)
		return int64(fl), nil
	case uint64:
		fl := v.(uint64)
		return int64(fl), nil
	case float32:
		fl := v.(float32)
		return int64(fl), nil
	case float64:
		fl := v.(float64)
		return int64(fl), nil
	case string:
		fl := v.(string)
		val, err := strconv.ParseInt(fl, 10, 64)
		if err != nil {
			return 0, fmt.Errorf("%s: key:'%s' value:[%v]", err.Error(), k, v)

		}
		return val, nil
	case sql.NullString:
		fl := v.(sql.NullString)
		if !fl.Valid {
			return 0, ErrValueWasNil
		}
		return strconv.ParseInt(fl.String, 10, 64)
	case bool:
		return 0, ErrRefusingCast
	case nil:
		return 0, ErrValueWasNil
	default:
		return 0, fmt.Errorf("GetIntCast: unrecognized type %v", reflect.TypeOf(v))
	}
}

// GetUint64 is a safe, typed uint64 accessor. It will force conversion
// away from float64, int64, and string values. Nils and unrecognized values
// are marked as an error (nil values will return 0 and ErrValueWasNil)
func (o *Object) GetUint64(k string) (uint64, error) {
	v, ok := o.KV[k]
	if !ok {
		return 0, ErrKeyWasMissing
	}

	switch v.(type) {
	case int:
		fl := v.(int)
		return uint64(fl), nil
	case int32:
		fl := v.(int32)
		return uint64(fl), nil
	case int64:
		fl := v.(int64)
		return uint64(fl), nil
	case uint:
		fl := v.(uint)
		return uint64(fl), nil
	case uint32:
		fl := v.(uint32)
		return uint64(fl), nil
	case uint64:
		fl := v.(uint64)
		return fl, nil
	case float32:
		fl := v.(float32)
		return uint64(fl), nil
	case float64:
		fl := v.(float64)
		return uint64(fl), nil
	case string:
		fl := v.(string)
		return strconv.ParseUint(fl, 10, 64)
	case bool:
		return 0, ErrRefusingCast
	case nil:
		return 0, ErrValueWasNil
	default:
		return 0, fmt.Errorf("GetUint64: unrecognized type %v", reflect.TypeOf(v))
	}
}

// Set is our typical setter. It attempts to track changes in records and the
// current state of whether an object appears to have been modified from what
// the database had (or should have).
func (o *Object) Set(k string, v interface{}) {
	oldVal := o.Get(k)

	if oldVal != nil {
		// Avoid redundant Set()s
		if oldVal == v {
			return
		}
		o.ColumnChanged(k, oldVal)
	}
	if !o.IsDirty() {
		o.MarkDirty(true)
	}
	o.SetCore(k, v)
}

// ColumnChanged records the previous value for something that is about to be
// set
func (o *Object) ColumnChanged(k string, oldVal interface{}) {
	o.ChangedColumns[k] = oldVal
}

// SetCore just mutates the internal object KV without any of the usual
// tracking that occurs when Set is called.
func (o *Object) SetCore(k string, v interface{}) {
	o.KV[k] = v
}

// ResetChangedColumns can be used in conjunction with an ORM... For instance,
// once a Save() method is invoked
func (o *Object) ResetChangedColumns() {
	o.ChangedColumns = make(map[string]interface{})
}

// MarkDirty is our setter for the 'object is saved' status field
func (o *Object) MarkDirty(status bool) {
	o.Dirty = status
}

// IsDirty is our getter for the 'object is saved' bool field
func (o *Object) IsDirty() bool {
	return o.Dirty
}

func (o *Object) Hide(k string) bool {
	setv, ok := o.GetWithFlag(k)
	if ok {
		o.MakeHiddenKVIfNeeded()
		o.HiddenKV[k] = setv
		delete(o.KV, k)
	}
	return ok
}

func (o *Object) Unhide(k string) bool {
	var ok bool
	setv, ok := o.HiddenGetWithFlag(k)
	if ok {
		o.SetCore(k, setv)
		o.KV[k] = setv
		delete(o.HiddenKV, k)
	}
	return ok
}


text:
title: Procs Overview | Juttle Language Reference
---

# Procs

[TOC]

A Juttle proc is a flowgraph node that can be a source, a processor, or a sink.

```text
(source; source) | processor | (processor; processor) | processor | (sink; sink)
```

## Sources

Source procs appear at the beginning of a flowgraph to feed data points into it.

**[emit](../sources/emit.md)**

Use `emit` source to synthetically generate points that contain only a timestamp, to compose test/example Juttle programs.

**[read](../sources/read.md)**

Read data via adapters such as the built-in `read file`, `read stochastic`, `read http`, or plug in external [adapters](../adapters/index.md) to read from remote backends.

## Processors

Processor nodes reside in the middle of a Juttle flowgraph, modifying streams as they pass through. Example modifications include transforming, reducing, and filtering.

**[batch](../processors/batch.md)**

Create batches by segmenting a sequence of points ordered by time stamp,
each segment spanning a specified interval of time.

**[filter](../processors/filter.md)**

Output only the points for which the given filtering expression
evaluates to true.

**[head](../processors/head.md)**

Only emit the first limit points from each batch.

**[join](../processors/join.md)**

Create new points from the points of multiple input streams.

**[keep](../processors/keep.md)**

Prune the input stream by removing all fields except the specified ones.

**[pace](../processors/pace.md)**

Play back historic points in real time or at the specified pace.

**[put](../processors/put.md)**

Set the specified field of each point to the result of an expression.

**[reduce](../processors/reduce.md)**

Accumulate collections of points and aggregate them using reducers,
optionally within a moving time window.

**[remove](../processors/remove.md)**

Prune the input stream by removing the specified fields.

**[sort](../processors/sort.md)**

Sort points in order based on values of one or more specified fields.

**[split](../processors/split.md)**

Split each incoming point, emitting one new point for each of the
specified fields in the original point.

**[tail](../processors/tail.md)**

Only emit the last limit points from each batch.

**[unbatch](../processors/unbatch.md)**

Turn a batched stream into an unbatched stream.

**[uniq](../processors/uniq.md)**

Compare adjacent points and discard any duplicates.

## Sinks

Final nodes of Juttle flowgraphs are referred to as sinks.

**[view](../sinks/view.md)**

Visualize data using the view sink with built-in views `view table`, `view text`, or charts available via juttle-viz library.

**[write](../sinks/write.md)**

Send data out using the write sink with built-in adapters `write file`, `write http`, or plug in external [adapters](../adapters/index.md) to write to remote backends.


text:
Run `dotnet msbuild /t:GenerateCode` to generate code.

### AutoRest Configuration
> see https://aka.ms/autorest

```yaml
repo: https://github.com/Azure/azure-rest-api-specs/blob/fdf4bbfd7a73b28960d3a62490440345d6f2e8e3
```

``` yaml
public-clients: true
input-file:
    - $(repo)/specification/synapse/data-plane/Microsoft.Synapse/preview/2020-02-01-preview/roleAssignments.json
    - $(repo)/specification/synapse/data-plane/Microsoft.Synapse/preview/2020-02-01-preview/roles.json
```


text:
The Hourglass

I gazed with rapt attention at

            the object borne to me alas

            by fortuity or fate...

            Boundless bourns,

            wherein constraints

            of time did not pertain,

            becalmed all force of will within

            enchantments cast unknown therein

            by lands in sandy waves.

 The souls of all who passed before

            the turning of this place of yore

            from fertileness to waste,

            whispered ever nigh across,

            and through the weathered hulks of lost

            kingdoms in their wake.

 One last fortress remained therein

            to guard this realm, beset within

            by the strifes of ancient folk;

            One last bastion yet unchecked

            by the turning tides of fate to rest

            in lonesome solitude.

 The storms that swept across these lands

            in days of old, where bells foretold

            of prophecies to come and pass,

            filled the depths of leafless gutters

            and empty streets with arid sands.

 Within the age portending such,

            where heedless hearts began to clutch

            the tempests yet unwoven,

            dwelt miracles in gilded halls...

            Dreams in waking, never failing

            to leave their charges thus enthralled.

 These raptures however, in the turning,

            could not stand the ever swirling

            mists of time, and fearing such,

            fled to armored keeps instead;

            to be forgotten, one by one,

            till all had been undone.

 Only the whispering sands can now be heard,

            whenever stirred

            by the restless wind's caress;

            As only the rumble of ancient works

            can still be felt, disconcerting from nighted halls,

            where great machines run on and on

            far beneath the earth.

 Could I divine the ages hence,

            and beholding fate, determine whence

            that time may come again,

            I would comply for peace of mind...

            Though galaxies may rise and fall

            and twilight may descend.

 Bryan Garaventa (2003)


text:
class DelayedJob < Delayed::Job
  has_paper_trail
end


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.widget.DrawerLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/profile_drawer_layout"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

        <com.github.florent37.materialviewpager.MaterialViewPager
        android:id="@+id/profile_material_view_pager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:viewpager_logo="@layout/header_logo"
        app:viewpager_logoMarginTop="100dp"
        app:viewpager_color="@color/colorPrimary"
        app:viewpager_headerHeight="250dp"
        app:viewpager_headerAlpha="1.0"
        app:viewpager_hideLogoWithFade="false"
        app:viewpager_hideToolbarAndTitle="true"
        app:viewpager_enableToolbarElevation="true"
        app:viewpager_parallaxHeaderFactor="1.5"
        app:viewpager_headerAdditionalHeight="20dp"
        app:viewpager_displayToolbarWhenSwipe="false"
        app:viewpager_transparentToolbar="false"
        app:viewpager_animatedHeaderImage="true"
        app:viewpager_disableToolbar="true"
        app:viewpager_pagerTitleStrip="@layout/material_view_pager_pagertitlestrip_newstand"
        />

</android.support.v4.widget.DrawerLayout>