text:
using System;
using System.Collections.Generic;
using System.Drawing;

namespace Microsoft.Protocols.TestTools.StackSdk.RemoteDesktop.Rdprfx
{
    public class RdprfxServer
    {
        public const int TileSize = 0x40;

        private TS_RFX_CODEC_QUANT codecQuant;

        public RdprfxServer()
        {
            initCodecQuant();
        }

        #region Encode Header Messages

        /// <summary>
        /// Method to create TS_RFX_SYNC.
        /// </summary>
        public TS_RFX_SYNC CreateTsRfxSync()
        {
            TS_RFX_SYNC rfxSync = new TS_RFX_SYNC();
            rfxSync.BlockT.blockType = blockType_Value.WBT_SYNC;
            rfxSync.BlockT.blockLen = 12;
            rfxSync.magic = 0xCACCACCA;
            rfxSync.version = 0x0100;
            return rfxSync;
        }

        /// <summary>
        /// Method to create TS_RFX_CODEC_VERSIONS.
        /// </summary>
        public TS_RFX_CODEC_VERSIONS CreateTsRfxCodecVersions()
        {
            TS_RFX_CODEC_VERSIONS rfxVersions = new TS_RFX_CODEC_VERSIONS();
            rfxVersions.BlockT.blockType = blockType_Value.WBT_CODEC_VERSIONS;
            rfxVersions.BlockT.blockLen = 10;
            rfxVersions.numCodecs = 0x01;
            rfxVersions.codecs = new TS_RFX_CODEC_VERSIONT();
            rfxVersions.codecs.codecId = 0x01;
            rfxVersions.codecs.version = 0x0100;

            return rfxVersions;
        }

        /// <summary>
        /// Method to create TS_RFX_CHANNELS.
        /// </summary>
        public TS_RFX_CHANNELS CreateTsRfxChannels()
        {
            TS_RFX_CHANNELS rfxChannels = new TS_RFX_CHANNELS();
            rfxChannels.BlockT.blockType = blockType_Value.WBT_CHANNELS;
            rfxChannels.BlockT.blockLen = 12;
            rfxChannels.numChannels = 0x01;
            rfxChannels.channels = new TS_RFX_CHANNELT[1];
            rfxChannels.channels[0].channelId = 0x00;
            rfxChannels.channels[0].width = RdprfxServer.TileSize;
            rfxChannels.channels[0].height = RdprfxServer.TileSize;

            return rfxChannels;
        }

        /// <summary>
        /// Method to create TS_RFX_CONTEXT.
        /// </summary>
        /// <param name="isImageMode">Indicates the operational mode.</param>
        /// <param name="entropy">Indicates the entropy algorithm.</param>
        public TS_RFX_CONTEXT CreateTsRfxContext(OperationalMode opMode, EntropyAlgorithm entropy)
        {
            TS_RFX_CONTEXT rfxContext = new TS_RFX_CONTEXT();
            rfxContext.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxContext.CodecChannelT.blockType = blockType_Value.WBT_CONTEXT;
            rfxContext.CodecChannelT.blockLen = 13;
            rfxContext.CodecChannelT.codecId = 0x01;
            rfxContext.CodecChannelT.channelId = 0x00;
            rfxContext.ctxId = 0x00;
            rfxContext.tileSize = 0x0040;

            ushort flags = 0x0002;
            if (opMode == OperationalMode.VideoMode) flags = 0x0000;
            ushort cct = 0x0001;
            ushort xft = 0x0001;
            ushort et = 0x0001;
            if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
            ushort qt = 0x0001;
            ushort r = 0x0000;

            rfxContext.properties = 0x0000;
            rfxContext.properties |= flags;
            rfxContext.properties |= (ushort)(cct << 3);
            rfxContext.properties |= (ushort)(xft << 5);
            rfxContext.properties |= (ushort)(et << 9);
            rfxContext.properties |= (ushort)(qt << 13);
            rfxContext.properties |= (ushort)(r << 15);

            return rfxContext;
        }

        #endregion

        #region Encode Data Messages

        /// <summary>
        /// Method to create TS_RFX_FRAME_BEGIN.
        /// </summary>
        /// <param name="frameIdx">The frame index.</param>
        public TS_RFX_FRAME_BEGIN CreateTsRfxFrameBegin(uint frameIdx)
        {
            TS_RFX_FRAME_BEGIN rfxBegin = new TS_RFX_FRAME_BEGIN();
            rfxBegin.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxBegin.CodecChannelT.blockType = blockType_Value.WBT_FRAME_BEGIN;
            rfxBegin.CodecChannelT.blockLen = 14;
            rfxBegin.CodecChannelT.codecId = 0x01;
            rfxBegin.CodecChannelT.channelId = 0x00;
            rfxBegin.frameIdx = frameIdx;
            rfxBegin.numRegions = 1;

            return rfxBegin;
        }

        /// <summary>
        /// Method to create TS_RFX_REGION.
        /// </summary>
        /// <param name="rects">Array of rects, if this parameter is null, will send a 64*64 rect </param>
        /// <param name="numRectsZero">A boolean variable to indicate whether the numRectsZero field of the TS_RFX_REGION is zero </param>
        public TS_RFX_REGION CreateTsRfxRegion(Rectangle[] rects = null, bool numRectsZero = false)
        {
            TS_RFX_REGION rfxRegion = new TS_RFX_REGION();
            rfxRegion.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxRegion.CodecChannelT.blockType = blockType_Value.WBT_REGION;
            rfxRegion.CodecChannelT.codecId = 0x01;
            rfxRegion.CodecChannelT.channelId = 0x00;
            rfxRegion.regionFlags = 0x01;

            if (numRectsZero)
            {
                rfxRegion.numRects = 0;
                rfxRegion.CodecChannelT.blockLen = 15;
                rfxRegion.rects = new TS_RFX_RECT[0];
                rfxRegion.regionType = 0xCAC1;
                rfxRegion.numTilesets = 0x0001;

                return rfxRegion;
            }

            if (rects == null || rects.Length == 0)
            {
                rfxRegion.numRects = 1;
                rfxRegion.CodecChannelT.blockLen = (uint)(15 + 1 * 8);
                rfxRegion.rects = new TS_RFX_RECT[1];
                rfxRegion.rects[0].x = 0;
                rfxRegion.rects[0].y = 0;
                rfxRegion.rects[0].width = RdprfxServer.TileSize;
                rfxRegion.rects[0].height = RdprfxServer.TileSize;
            }
            else
            {
                rfxRegion.numRects = (ushort) rects.Length;
                rfxRegion.CodecChannelT.blockLen = (uint)(15 + rfxRegion.numRects * 8);
                rfxRegion.rects = new TS_RFX_RECT[rects.Length];
                for (int i = 0; i < rects.Length; i++)
                {
                    rfxRegion.rects[i].x = (ushort) rects[i].Left;
                    rfxRegion.rects[i].y = (ushort) rects[i].Top;
                    rfxRegion.rects[i].width = (ushort) rects[i].Width;
                    rfxRegion.rects[i].height = (ushort) rects[i].Height;
                }

            }
            rfxRegion.regionType = 0xCAC1;
            rfxRegion.numTilesets = 0x0001;

            return rfxRegion;
        }

        /// <summary>
        /// Method to create TS_RFX_TILESET.
        /// </summary>
        /// <param name="opMode">Indicates the operational mode.</param>
        /// <param name="entropy">Indicates the entropy algorithm.</param>
        /// <param name="tileImage">A bitmap in Image type for a tile. The width and heigth must be less than or equals with 64.</param>
        /// <param name="codecQuantVals">Quant values array</param>
        /// <param name="quantIdxY">Index of Y component in Quant value array</param>
        /// <param name="quantIdxCb">Index of Cb component in Quant value array</param>
        /// <param name="quantIdxCr">Index of Cr component in Quant value array</param>
        /// <returns></returns>
        public TS_RFX_TILESET CreateTsRfxTileSet(OperationalMode opMode, EntropyAlgorithm entropy, Image tileImage,
            TS_RFX_CODEC_QUANT[] codecQuantVals = null, byte quantIdxY = 0, byte quantIdxCb = 0, byte quantIdxCr = 0)
        {
            if (codecQuantVals == null)
            {
                codecQuantVals = new TS_RFX_CODEC_QUANT[1];
                codecQuantVals[0] = codecQuant;
            }

            TS_RFX_TILESET rfxTileSet = new TS_RFX_TILESET();
            rfxTileSet.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxTileSet.CodecChannelT.blockType = blockType_Value.WBT_EXTENSION;
            rfxTileSet.CodecChannelT.blockLen = 22 + 5;
            rfxTileSet.CodecChannelT.codecId = 0x01;
            rfxTileSet.CodecChannelT.channelId = 0x00;
            rfxTileSet.subtype = 0xCAC2;
            rfxTileSet.idx = 0x0000;

            ushort lt = 0x0001;
            ushort flags = 0x0002;
            if (opMode == OperationalMode.VideoMode) flags = 0x0000;
            ushort cct = 0x0001;
            ushort xft = 0x0001;
            ushort et = 0x0001;
            if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
            ushort qt = 0x0001;
            rfxTileSet.properties = lt;
            rfxTileSet.properties |= (ushort)(flags << 1);
            rfxTileSet.properties |= (ushort)(cct << 4);
            rfxTileSet.properties |= (ushort)(xft << 6);
            rfxTileSet.properties |= (ushort)(et << 10);
            rfxTileSet.properties |= (ushort)(qt << 14);

            rfxTileSet.numQuant = (byte)codecQuantVals.Length;
            rfxTileSet.tileSize = RdprfxServer.TileSize;
            rfxTileSet.numTiles = 1;

            rfxTileSet.quantVals = codecQuantVals;

            byte[] yData, cbData, crData;

            RemoteFXCodecContext encodingContext = new RemoteFXCodecContext(codecQuantVals, quantIdxY, quantIdxCb, quantIdxCr, entropy);
            RemoteFXEncoder.EncodeTile(tileImage, 0, 0, encodingContext);
            yData = encodingContext.YData;
            cbData = encodingContext.CbData;
            crData = encodingContext.CrData;

            rfxTileSet.tiles = new TS_RFX_TILE[1];
            rfxTileSet.tiles[0].BlockT.blockType = blockType_Value.CBT_TILE;
            rfxTileSet.tiles[0].BlockT.blockLen = (uint)(19 + yData.Length + cbData.Length + crData.Length);
            rfxTileSet.tiles[0].quantIdxY = quantIdxY;
            rfxTileSet.tiles[0].quantIdxCb = quantIdxCb;
            rfxTileSet.tiles[0].quantIdxCr = quantIdxCr;
            rfxTileSet.tiles[0].xIdx = 0;
            rfxTileSet.tiles[0].yIdx = 0;
            rfxTileSet.tiles[0].YLen = (ushort)yData.Length;
            rfxTileSet.tiles[0].CbLen = (ushort)cbData.Length;
            rfxTileSet.tiles[0].CrLen = (ushort)crData.Length;
            rfxTileSet.tiles[0].YData = yData;
            rfxTileSet.tiles[0].CbData = cbData;
            rfxTileSet.tiles[0].CrData = crData;

            rfxTileSet.tilesDataSize = rfxTileSet.tiles[0].BlockT.blockLen;
            rfxTileSet.CodecChannelT.blockLen = (uint)(22 + 5 * rfxTileSet.numQuant + rfxTileSet.tilesDataSize);

            return rfxTileSet;
        }

        /// <summary>
        /// Method to create TS_RFX_TILESET.
        /// </summary>
        /// <param name="opMode">Indicates the operational mode.</param>
        /// <param name="entropy">Indicates the entropy algorithm.</param>
        /// <param name="tileImages">An array of bitmaps in Image type for a tile. The width and heigth must be less than or equals with 64.</param>
        /// <param name="positions">A TILE_POSITION array indicating the positions of each tile images</param>
        /// <param name="codecQuantVals">Quant values array</param>
        /// <param name="quantIdxYs">Index array of Y component in Quant value array</param>
        /// <param name="quantIdxCbs">Index array of Cb component in Quant value array</param>
        /// <param name="quantIdxCrs">Index array of Cr component in Quant value array</param>
        /// <returns></returns>
        public TS_RFX_TILESET CreateTsRfxTileSet(
            OperationalMode opMode,
            EntropyAlgorithm entropy,
            Image[] tileImages,
            TILE_POSITION[] positions,
            TS_RFX_CODEC_QUANT[] codecQuantVals = null,
            byte[] quantIdxYs = null,
            byte[] quantIdxCbs = null,
            byte[] quantIdxCrs = null
            )
        {
            if (codecQuantVals == null)
            {
                codecQuantVals = new TS_RFX_CODEC_QUANT[1];
                codecQuantVals[0] = codecQuant;
            }

            TS_RFX_TILESET rfxTileSet = new TS_RFX_TILESET();
            rfxTileSet.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxTileSet.CodecChannelT.blockType = blockType_Value.WBT_EXTENSION;
            rfxTileSet.CodecChannelT.blockLen = 22 + 5;
            rfxTileSet.CodecChannelT.codecId = 0x01;
            rfxTileSet.CodecChannelT.channelId = 0x00;
            rfxTileSet.subtype = 0xCAC2;
            rfxTileSet.idx = 0x0000;

            ushort lt = 0x0001;
            ushort flags = 0x0002;
            if (opMode == OperationalMode.VideoMode) flags = 0x0000;
            ushort cct = 0x0001;
            ushort xft = 0x0001;
            ushort et = 0x0001;
            if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
            ushort qt = 0x0001;
            rfxTileSet.properties = lt;
            rfxTileSet.properties |= (ushort)(flags << 1);
            rfxTileSet.properties |= (ushort)(cct << 4);
            rfxTileSet.properties |= (ushort)(xft << 6);
            rfxTileSet.properties |= (ushort)(et << 10);
            rfxTileSet.properties |= (ushort)(qt << 14);

            rfxTileSet.numQuant = (byte)codecQuantVals.Length;
            rfxTileSet.tileSize = RdprfxServer.TileSize;
            rfxTileSet.numTiles = 1;

            rfxTileSet.quantVals = codecQuantVals;

            byte[] yData, cbData, crData;

            rfxTileSet.tiles = new TS_RFX_TILE[tileImages.Length];
            rfxTileSet.numTiles = (ushort) rfxTileSet.tiles.Length;

            for (int i = 0; i < tileImages.Length; i++)
            {
                byte quantIdxY = quantIdxYs == null ? (byte)0 : (quantIdxYs.Length > i ? quantIdxYs[i] : (byte)0);
                byte quantIdxCb = quantIdxCbs == null ? (byte)0 : (quantIdxCbs.Length > i ? quantIdxCbs[i] : (byte)0);
                byte quantIdxCr = quantIdxCrs == null ? (byte)0 : (quantIdxCrs.Length > i ? quantIdxCrs[i] : (byte)0);

                RemoteFXCodecContext encodingContext = new RemoteFXCodecContext(codecQuantVals, quantIdxY, quantIdxCb, quantIdxCr, entropy);
                RemoteFXEncoder.EncodeTile(tileImages[i], 0, 0, encodingContext);
                yData = encodingContext.YData;
                cbData = encodingContext.CbData;
                crData = encodingContext.CrData;

                rfxTileSet.tiles[i].BlockT.blockType = blockType_Value.CBT_TILE;
                rfxTileSet.tiles[i].BlockT.blockLen = (uint)(19 + yData.Length + cbData.Length + crData.Length);
                rfxTileSet.tiles[i].quantIdxY = quantIdxY;
                rfxTileSet.tiles[i].quantIdxCb = quantIdxCb;
                rfxTileSet.tiles[i].quantIdxCr = quantIdxCr;
                rfxTileSet.tiles[i].xIdx = positions[i].xIdx;
                rfxTileSet.tiles[i].yIdx = positions[i].yIdx;
                rfxTileSet.tiles[i].YLen = (ushort)yData.Length;
                rfxTileSet.tiles[i].CbLen = (ushort)cbData.Length;
                rfxTileSet.tiles[i].CrLen = (ushort)crData.Length;
                rfxTileSet.tiles[i].YData = yData;
                rfxTileSet.tiles[i].CbData = cbData;
                rfxTileSet.tiles[i].CrData = crData;

                rfxTileSet.tilesDataSize += rfxTileSet.tiles[i].BlockT.blockLen;
                rfxTileSet.CodecChannelT.blockLen = (uint)(22 + 5 * rfxTileSet.numQuant + rfxTileSet.tilesDataSize);
            }

            return rfxTileSet;
        }

        /// <summary>
        /// Method to create TS_RFX_TILESET.
        /// </summary>
        /// <param name="isImageMode">Indicates the operational mode.</param>
        /// <param name="entropy">Indicates the entropy algorithm.</param>
        /// <param name="tileImage">A RgbTile. The width and heigth must be less than or equals with 64.</param>
        public TS_RFX_TILESET CreateTsRfxTileSet(OperationalMode opMode, EntropyAlgorithm entropy, RgbTile tileImage)
        {
            TS_RFX_TILESET rfxTileSet = new TS_RFX_TILESET();
            rfxTileSet.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxTileSet.CodecChannelT.blockType = blockType_Value.WBT_EXTENSION;
            rfxTileSet.CodecChannelT.blockLen = 22 + 5;
            rfxTileSet.CodecChannelT.codecId = 0x01;
            rfxTileSet.CodecChannelT.channelId = 0x00;
            rfxTileSet.subtype = 0xCAC2;
            rfxTileSet.idx = 0x0000;

            ushort lt = 0x0001;
            ushort flags = 0x0002;
            if (opMode == OperationalMode.VideoMode) flags = 0x0000;
            ushort cct = 0x0001;
            ushort xft = 0x0001;
            ushort et = 0x0001;
            if (entropy == EntropyAlgorithm.CLW_ENTROPY_RLGR3) et = 0x0004;
            ushort qt = 0x0001;
            rfxTileSet.properties = lt;
            rfxTileSet.properties |= (ushort)(flags << 1);
            rfxTileSet.properties |= (ushort)(cct << 4);
            rfxTileSet.properties |= (ushort)(xft << 6);
            rfxTileSet.properties |= (ushort)(et << 10);
            rfxTileSet.properties |= (ushort)(qt << 14);

            rfxTileSet.numQuant = 1;
            rfxTileSet.tileSize = RdprfxServer.TileSize;
            rfxTileSet.numTiles = 1;

            rfxTileSet.quantVals = new TS_RFX_CODEC_QUANT[1];
            rfxTileSet.quantVals[0] = codecQuant;

            byte[] yData, cbData, crData;

            RemoteFXCodecContext encodingContext = new RemoteFXCodecContext(codecQuant, entropy);
            RemoteFXEncoder.EncodeTile(tileImage, 0, 0, encodingContext);
            yData = encodingContext.YData;
            cbData = encodingContext.CbData;
            crData = encodingContext.CrData;

            rfxTileSet.tiles = new TS_RFX_TILE[1];
            rfxTileSet.tiles[0].BlockT.blockType = blockType_Value.CBT_TILE;
            rfxTileSet.tiles[0].BlockT.blockLen = (uint)(19 + yData.Length + cbData.Length + crData.Length);
            rfxTileSet.tiles[0].quantIdxY = 0;
            rfxTileSet.tiles[0].quantIdxCb = 0;
            rfxTileSet.tiles[0].quantIdxCr = 0;
            rfxTileSet.tiles[0].xIdx = 0;
            rfxTileSet.tiles[0].yIdx = 0;
            rfxTileSet.tiles[0].YLen = (ushort)yData.Length;
            rfxTileSet.tiles[0].CbLen = (ushort)cbData.Length;
            rfxTileSet.tiles[0].CrLen = (ushort)crData.Length;
            rfxTileSet.tiles[0].YData = yData;
            rfxTileSet.tiles[0].CbData = cbData;
            rfxTileSet.tiles[0].CrData = crData;

            rfxTileSet.tilesDataSize = rfxTileSet.tiles[0].BlockT.blockLen;
            rfxTileSet.CodecChannelT.blockLen = 22 + 5 + rfxTileSet.tilesDataSize;

            return rfxTileSet;
        }

        /// <summary>
        /// Method to create TS_RFX_FRAME_END.
        /// </summary>
        public TS_RFX_FRAME_END CreateTsRfxFrameEnd()
        {
            TS_RFX_FRAME_END rfxEnd = new TS_RFX_FRAME_END();
            rfxEnd.CodecChannelT = new TS_RFX_CODEC_CHANNELT();
            rfxEnd.CodecChannelT.blockType = blockType_Value.WBT_FRAME_END;
            rfxEnd.CodecChannelT.blockLen = 8;
            rfxEnd.CodecChannelT.codecId = 0x01;
            rfxEnd.CodecChannelT.channelId = 0x00;

            return rfxEnd;
        }

        #endregion

        /// <summary>
        /// Set the default Codec Quant
        /// </summary>
        private void initCodecQuant()
        {
            codecQuant = new TS_RFX_CODEC_QUANT();
            codecQuant.LL3_LH3 = 0x66;
            codecQuant.HL3_HH3 = 0x66;
            codecQuant.LH2_HL2 = 0x77;
            codecQuant.HH2_LH1 = 0x88;
            codecQuant.HL1_HH1 = 0x98;
        }
    }
}


text:
<?php

namespace Symfony\Tests\Component\Locale;

abstract class TestCase extends \PHPUnit_Framework_TestCase
{
    protected static $icuVersion = null;

    protected function is32Bit()
    {
        return PHP_INT_SIZE == 4;
    }

    protected function is64Bit()
    {
        return PHP_INT_SIZE == 8;
    }

    protected function isIntlExtensionLoaded()
    {
        return extension_loaded('intl');
    }

    protected function skipIfIntlExtensionIsNotLoaded()
    {
        if (!$this->isIntlExtensionLoaded()) {
            $this->markTestSkipped('The intl extension is not available.');
        }
    }

    protected function skipIfICUVersionIsTooOld()
    {
        if ($this->isLowerThanIcuVersion('4.0')) {
            $this->markTestSkipped(
              'Please upgrade ICU version to 4+'
            );
        }
    }

    protected function isGreaterOrEqualThanIcuVersion($version)
    {
        $version = $this->normalizeIcuVersion($version);
        $icuVersion = $this->normalizeIcuVersion($this->getIntlExtensionIcuVersion());

        return $icuVersion >= $version;
    }

    protected function isLowerThanIcuVersion($version)
    {
        $version = $this->normalizeIcuVersion($version);
        $icuVersion = $this->normalizeIcuVersion($this->getIntlExtensionIcuVersion());

        return $icuVersion < $version;
    }

    protected function normalizeIcuVersion($version)
    {
        return ((float) $version) * 100;
    }

    protected function getIntlExtensionIcuVersion()
    {
        if (isset(self::$icuVersion)) {
            return self::$icuVersion;
        }

        if (!$this->isIntlExtensionLoaded()) {
            throw new \RuntimeException('The intl extension is not available');
        }

        ob_start();
        phpinfo(INFO_MODULES);
        $output = ob_get_clean();

        preg_match('/^ICU version => (.*)$/m', $output, $matches);
        self::$icuVersion = $matches[1];

        return self::$icuVersion;
    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.araqne.logdb.query.parser;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.araqne.logdb.AbstractQueryCommandParser;
import org.araqne.logdb.QueryCommand;
import org.araqne.logdb.QueryContext;
import org.araqne.logdb.QueryErrorMessage;
import org.araqne.logdb.QueryParseException;
import org.araqne.logdb.query.command.Purge;
import org.araqne.logdb.query.command.StorageObjectName;
import org.araqne.logstorage.LogStorage;
import org.araqne.logstorage.LogTableRegistry;

/**
 * @since 2.2.10
 *
 * @author darkluster
 *
 */
public class PurgeParser extends AbstractQueryCommandParser {
	private LogStorage storage;
	private LogTableRegistry tableRegistry;

	public PurgeParser(LogStorage storage, LogTableRegistry tableRegistry) {
		this.storage = storage;
		this.tableRegistry = tableRegistry;

		setDescriptions("Purge specified range of data when query starts. This command requires administrator privilege.",
				"전체 쿼리가 시작하는 시점에 지정한 날짜 범위의 테이블 데이터를 파기합니다. 주로 쿼리를 실행할 때마다 기존 데이터를 파기하고 새로운 데이터를 입력하려는 경우에 사용합니다. 이 커맨드를 실행하려면 관리자 권한이 필요합니다.");
		setOptions("from", true, "yyyyMMdd format. Start day of range", "yyyyMMdd 포맷, 파기 대상 시작 날짜");
		setOptions("to", true, "yyyyMMdd format. End day of range", "yyyyMMdd 포맷, 파기 대상 끝 날짜");
	}

	@Override
	public String getCommandName() {
		return "purge";
	}

	@Override
	public Map<String, QueryErrorMessage> getErrorMessages() {
		Map<String, QueryErrorMessage> m = new HashMap<String, QueryErrorMessage>();
		m.put("11400", new QueryErrorMessage("no-permission", "프로시저를 찾을 수 없습니다."));
		m.put("11401", new QueryErrorMessage("missing-field", "불완전한 표현식입니다."));
		m.put("11402", new QueryErrorMessage("from-not-found", "시작 날짜를 입력하십시오."));
		m.put("11403", new QueryErrorMessage("to-not-found", "끝 날짜를 입력하십시오."));
		m.put("11404", new QueryErrorMessage("invalid-date-format", "잘못된 날짜표현식입니다: [msg]."));
		m.put("11405", new QueryErrorMessage("table-not-found", "[table] 테이블이 존재하지 않습니다."));
		m.put("11406", new QueryErrorMessage("invalid-date-range", "유효하지 않은 날짜 범위 입니다."));
		return m;
	}

	@SuppressWarnings("unchecked")
	@Override
	public QueryCommand parse(QueryContext context, String commandString) {
		if (!context.getSession().isAdmin())
			// throw new QueryParseException("no-permission", -1);
			throw new QueryParseException("11400", -1, -1, null);

		if (commandString.trim().endsWith(","))
			// throw new QueryParseException("missing-field",
			// commandString.length());
			throw new QueryParseException("11401", -1, -1, null);

		ParseResult r = QueryTokenizer.parseOptions(context, commandString, getCommandName().length(),
				Arrays.asList("from", "to"), getFunctionRegistry());
		Map<String, String> options = (Map<String, String>) r.value;
		if (options.get("from") == null)
			// throw new QueryParseException("from-not-found", -1);
			throw new QueryParseException("11402", -1, -1, null);

		if (options.get("to") == null)
			// throw new QueryParseException("to-not-found", -1);
			throw new QueryParseException("11403", -1, -1, null);

		String fromString = options.get("from").toString();
		String toString = options.get("to").toString();

		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		try {
			Date from = sdf.parse(fromString);
			Date to = sdf.parse(toString);

			if (from.after(to))
				throw new QueryParseException("11406", -1, -1, null);

			String tableName = ExpressionParser.evalContextReference(context, commandString.substring(r.next).trim(),
					getFunctionRegistry());

			return new Purge(storage, expandTableNames(tableName), from, to);
		} catch (ParseException e) {
			// throw new QueryParseException("invalid-date-format", -1);
			Map<String, String> params = new HashMap<String, String>();
			params.put("msg", e.getMessage());
			throw new QueryParseException("11404", -1, -1, params);
		}
	}

	private List<String> expandTableNames(String tableName) {
		List<String> localTableNames = new ArrayList<String>();
		for (String splitedTableName : tableName.split(",")) {
			WildcardTableSpec tableMatcher = new WildcardTableSpec(splitedTableName);
			for (StorageObjectName son : tableMatcher.match(tableRegistry)) {
				if (son.getNamespace() != null && !son.getNamespace().equals("*"))
					continue;
				if (son.isOptional() && !tableRegistry.exists(son.getTable()))
					continue;
				if (!son.isOptional() && !tableRegistry.exists(son.getTable())) {
					// hrow new QueryParseException("table-not-found", -1);
					Map<String, String> params = new HashMap<String, String>();
					params.put("table", tableName);
					throw new QueryParseException("11405", -1, -1, params);
				}
				localTableNames.add(son.getTable());
			}
		}
		return localTableNames;
	}
}


text:
/**
 * @fileoverview Utilities for working with JsUnit.  Writes out the JsUnit file
 * that needs to be included in every unit test.
 *
 * Testing code should not have dependencies outside of goog.testing so as to
 * reduce the chance of masking missing dependencies.
 */

goog.setTestOnly('goog.testing.jsunit');
goog.provide('goog.testing.jsunit');

goog.require('goog.dom.TagName');
goog.require('goog.testing.TestCase');
goog.require('goog.testing.TestRunner');

/**
 * @define {boolean} If this code is being parsed by JsTestC, we let it disable
 * the onload handler to avoid running the test in JsTestC.
 */
goog.testing.jsunit.AUTO_RUN_ONLOAD =
    goog.define('goog.testing.jsunit.AUTO_RUN_ONLOAD', true);

/**
 * @define {number} Sets a delay in milliseconds after the window onload event
 * and running the tests. See goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS.
 */
goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS_DEFAULT =
    goog.define('goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS_DEFAULT', 0);

/**
 * @type {number} Sets a delay in milliseconds after the window onload event
 * and running the tests. Used as a workaround for IE failing to report load
 * event if the page has iframes.  The appropriate value is zero;
 * maximum should be 500.  Do not use this value to support asynchronous tests.
 */
goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS =
    goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS_DEFAULT;

(function() {
'use strict';
// Only allow one global test runner to be created on a page.
if (goog.global['G_testRunner'] instanceof goog.testing.TestRunner) {
  return;
}

// Increases the maximum number of stack frames in Google Chrome from the
// default 10 to 50 to get more useful stack traces.
Error.stackTraceLimit = 50;

// Store a reference to the window's timeout so that it can't be overridden
// by tests.
/** @type {!Function} */
var realTimeout = window.setTimeout;

// Create a test runner.
var tr = new goog.testing.TestRunner();

// Export it so that it can be queried by Selenium and tests that use a
// compiled test runner.
goog.exportSymbol('G_testRunner', tr);
goog.exportSymbol('G_testRunner.initialize', tr.initialize);
goog.exportSymbol('G_testRunner.isInitialized', tr.isInitialized);
goog.exportSymbol('G_testRunner.isFinished', tr.isFinished);
goog.exportSymbol('G_testRunner.getUniqueId', tr.getUniqueId);
goog.exportSymbol('G_testRunner.isSuccess', tr.isSuccess);
goog.exportSymbol('G_testRunner.getReport', tr.getReport);
goog.exportSymbol('G_testRunner.getRunTime', tr.getRunTime);
goog.exportSymbol('G_testRunner.getNumFilesLoaded', tr.getNumFilesLoaded);
goog.exportSymbol('G_testRunner.setStrict', tr.setStrict);
goog.exportSymbol('G_testRunner.logTestFailure', tr.logTestFailure);
goog.exportSymbol('G_testRunner.getTestResults', tr.getTestResults);
goog.exportSymbol('G_testRunner.getTestResultsAsJson', tr.getTestResultsAsJson);

// Export debug as a global function for JSUnit compatibility.  This just
// calls log on the current test case.
if (!goog.global['debug']) {
  goog.exportSymbol('debug', goog.bind(tr.log, tr));
}

// If the application has defined a global error filter, set it now.  This
// allows users who use a base test include to set the error filter before
// the testing code is loaded.
if (goog.global['G_errorFilter']) {
  tr.setErrorFilter(goog.global['G_errorFilter']);
}

var maybeGetStack = function(error) {
  'use strict';
  var stack = error && error.stack;
  return typeof stack === 'string' ? stack : '';
};

// Add an error handler to report errors that may occur during
// initialization of the page.
var onerror = window.onerror;
window.onerror = function(messageOrEvent, url, line) {
  'use strict';
  // TODO(johnlenz): fix this function parameters once the "onerror"
  // definition has been corrected.
  // colno and errObj were added later.
  var colno = arguments[3];
  var errObj = arguments[4];
  // Call any existing onerror handlers, except our boot handler.
  if (onerror && onerror != window['__onerror_at_boot']) {
    onerror.apply(window, arguments);
  }
  var stack = maybeGetStack(errObj || messageOrEvent);
  if (stack) {
    tr.logError(String(messageOrEvent) + '\n' + stack);
  } else if (typeof messageOrEvent == 'object') {
    var error = /** @type {{target: ?}} */ (messageOrEvent);
    // Some older webkit browsers pass an event object as the only argument
    // to window.onerror.  It doesn't contain an error message, url or line
    // number.  We therefore log as much info as we can.
    if (error.target && error.target.tagName == goog.dom.TagName.SCRIPT) {
      tr.logError('UNKNOWN ERROR: Script ' + error.target.src);
    } else {
      tr.logError('UNKNOWN ERROR: No error information available.');
    }
  } else {
    // Add the column if it is available, older browsers won't have it.
    var colstr = colno != null ? '\nColumn: ' + colno : '';
    tr.logError(
        'JS ERROR: ' + messageOrEvent + '\nURL: ' + url + '\nLine: ' + line +
        colstr);
  }
};

/**
 * The onerror handler that may have been set by the test runner.
 *  @type {?function(string, string=, number=, number=, Object=)}
 */
window['__onerror_at_boot'] = window['__onerror_at_boot'] || null;
/**
 * The arguments for any call to window.onerror occuring before this point.
 * @type {?Array<!Array<?>>}
 */
window['__errors_since_boot'] = window['__errors_since_boot'] || null;

if (window['__onerror_at_boot']) {
  if (window['__errors_since_boot']) {
    for (var i = 0; i < window['__errors_since_boot'].length; i++) {
      var args = window['__errors_since_boot'][i];
      window.onerror.apply(window, args);
    }
  }
  // http://perfectionkills.com/understanding-delete/#ie_bugs
  window['__onerror_at_boot'] = null;
}

// Create an onload handler, if the test runner hasn't been initialized then
// no test has been registered with the test runner by the test file.  We
// then create a new test case and auto discover any tests in the global
// scope. If this code is being parsed by JsTestC, we let it disable the
// onload handler to avoid running the test in JsTestC.
if (goog.testing.jsunit.AUTO_RUN_ONLOAD) {
  var onload = window.onload;
  window.onload = function(e) {
    'use strict';
    // Call any existing onload handlers.
    if (onload) {
      onload(e);
    }
    // Execute the test on the next turn, to allow the WebDriver.get()
    // operation to return to the test runner and begin polling.
    var executionDelayAfterLoad = goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS;

    realTimeout(function() {
      'use strict';
      if (!tr.initialized) {
        var testCase = new goog.testing.TestCase(document.title);
        goog.testing.TestCase.initializeTestCase(testCase);
        tr.initialize(testCase);
      }
      tr.execute();
    }, executionDelayAfterLoad);
    window.onload = null;
  };
}
})();


text:
		<meta http-equiv="content-type" content="text/html;charset=utf-8">
		<title>Version 0.9.1</title>
		<meta name="robots" content="anchors">
		<link href="rnotes.css" type="text/css" rel="stylesheet" media="all">

Account Bugfix

	           Hopefully fixed a bug that caused the upload buttons to never enable for some users.


text:
$(document).ready(function() {

  $('section').on({
    'mouseover': wider,
    'mouseleave': average
  });

  function wider() {
    $('section').removeClass('average').not($(this)).addClass('narrow');
    $(this).addClass('wide');
  }

  function average() {
    $('section').removeClass('narrow wide').addClass('average');
  }

});


text:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>A Pragmatic Application of Scrum</title>
<meta name="generator" content="Org mode" />
<meta name="author" content="John Cumming" />

<link rel="stylesheet"
                         href="/css/solarized-dark.css"
                         type="text/css"/>

John's Draft Blog | home

A Pragmatic Application of Scrum

Table of Contents

Agile Development

The Manifesto for Agile Software Development

The Twelve Principles of Agile Software

Lean Principles

Scrum

Process

Roles

Team

Product Owner

Scrummaster

Artefacts

Product Backlog

Release Burndown Chart

Sprint Backlog

Sprint Burndown Chart

Events

Sprint Planning

Sprint

Daily Scrum

Sprint Review

Retrospective

Applying Scrum Principles and Practices to your Project

Roles

Product Owner

Team

Scrummaster

Artefacts

Product Backlog

Release Burndown Chart

Sprint Backlog

Sprint Burndown Chart

Events

Sprint Planning

Daily Scrum

Sprint Review

Retrospective

Agile Development

In the late 1990s, several development methodologies started to
appear in response to the inevitable requirements churn in most
software project requirements. They emphasised close communication
between the engineering team, the business and users and an ability
to respond quickly and deliver value frequently and predictably.

At a summit of a small group of practitioners of these methodologies
a consensus on the principles and values that sum up what it means
to be Agile was composed; the now famous Agile Manifesto:

The Manifesto for Agile Software Development

We are uncovering better ways of developing software by doing it
and helping others do it.

Through this work we have come to value:

Individuals and interactions over processes and tools

Working software over comprehensive documentation

Customer collaboration over contract negotiation

Responding to change over following a plan

That is, while there is value in the items on the right, we value
the items on the left more.

Supplementing this was the principles of agile development:

The Twelve Principles of Agile Software

We follow these principles:

Our highest priority is to satisfy the customer through early
and continuous delivery of valuable software.

Welcome changing requirements, even late in development. Agile
processes harness change for the customer's competitive
advantage.

Deliver working software frequently, from a couple of weeks to a
couple of months, with a preference to the shorter timescale.

Business people and developers must work together daily
throughout the project.

Build projects around motivated individuals. Give them the
environment and support they need, and trust them to get the job
done.

The most efficient and effective method of conveying information
to and within a development team is face-to-face conversation.

Working software is the primary measure of progress.

Agile processes promote sustainable development. The sponsors,
developers, and users should be able to maintain a constant pace
indefinitely.

Continuous attention to technical excellence and good design
enhances agility.

Simplicity–the art of maximizing the amount of work not done–is
essential.

The best architectures, requirements, and designs emerge from
self-organizing teams.

At regular intervals, the team reflects on how to become more
effective, then tunes and adjusts its behaviour accordingly.

It is from these principles that Agile processes, practices and
frameworks such as Scrum and XP have developed.

Lean Principles

While the Agile Manifesto is a result of a consolidation of what was
starting to happen in software engineering, Lean development
principles came as a result of adapting and applying principles
borrowed from Lean Manufacturing. Lean Manufacturing was centred on
"Preserving Value with Less Work" and came from ideas and philosophy
that had been developed by Toyota in Japan.

Lean development can be summarised by seven principles:

Eliminate Waste. Everything that is not adding value for the
customer should be considered waste. This includes time delays
and unnecessary features and process.

Amplify Learning. Short iterations encourage rapid feedback. This
helps the team and the customer learn about their product and
process quickly.

Decide as late as possible. As software development is always
carried out with some uncertainty. Decisions should be delayed
until they can be made on facts not assumptions. The capacity for
change should be built into a system.

Deliver as fast as possible. The sooner a product is delivered
the sooner feedback can be obtained and the sooner value can be
realised by the customer.

Empower the team. Find good people and let them decide how to do
their job.

Build integrity in. Simplicity, Clarity, Minimal features
resulting from refactoring continuously. Continuous integration
of features should include thorough testing to verify the
integrity.

See the whole. Ensure communication between teams developing
different components of a system to encourage an understanding of
interactions between components.

Lean thinking can be summarised by: "Think big, act small, fail
fast, learn rapidly"

Scrum

Scrum is a popular process framework based on short iterations of
development known as sprints; its primary principle is Inspect and
Adapt, a direct response to thinking in a lean way. It is the
recognition that we need to learn as we have gaps in our knowledge
about the product. It is the acknowledgement that we need to fail
fast, but in relation to small actions. It is also the point at
which waste can be identified and eliminated.

Inspect and Adapt is also a response to the agile principle of
responding to change over following a plan. Inspection and
adaptation is important enough in scrum to have a dedicated meeting
every Sprint, the Retrospective.

The short iteration cycle, or Sprint, allows for a lot of the Lean
principles to be applied, including delivering fast, deciding late
and amplifying learning. In scrum, the Team is empowered to decide
how it wants to work and integrity is encouraged by having
multi-disciplined team members with an ability to develop and test.

The Daily Scrum, a point at which all team members notify each other
of work done, work in progress and impediments applies the principle
of Individuals and Interactions over process and tools and the
Sprint Planning and Sprint Review encourage Customer Collaboration
via the Product Owner, who is the customer representative to the
Team.

In a scrum project a Scrummaster is often in place, not as a project
manager but rather a mentor and coach to encourage the Inspect and
Adapt principle and help remove any impediments external to the
Team.

Process

The Scrum process is a relatively simple one, as shown below:

The product is defined by a list of User Stories held in a Product
Backlog. This is managed by the Product Owner.

Sprint Planning is carried out to determine, based on the Team's
throughput, known as Velocity, how much can be taken into the Sprint
Backlog. Once this has been agreed by the Team, the Sprint, a fixed
development iteration, can start.

As the Sprint goes on, every morning the Team will inform each other
of work done, work in progress and Impediments in the Daily Scrum.

Once the Sprint is finished, the User Stories are demo'd to the
Product Owner by the Team in the Sprint Review. The Product Owner
then agrees which User Stories are done and removes them from the
Product Backlog The total value of Effort for the done User Stories
in the Sprint makes up the Team's Velocity.

The Sprint is completed and the Team now hold a Retrospective where
they discuss and identify what is going well, what is going badly,
how to get the most out of what is going well and address what is
going badly.

The Velocity, Product Backlog and actions from the Retrospective are
all brought to the table again in the Sprint Planning to plan the
next Sprint.

Roles

There are 3 roles in the Scrum Process:

Team

The Team is responsible for estimating and delivering the product
to the customer, adapting its process and practices as it needs,
ensuring the quality of its product and identifying problems and
addressing them as they arise.

Product Owner

The Product Owner is responsible for representing the customer,
maintaining the backlog, prioritising User Stories.

Scrummaster

The Scrummaster is responsible for coaching and encouraging agile
thinking, unblocking the team of external impediments.

Artefacts

The four main artefacts in Scrum are as follows:

Product Backlog

The Product Backlog contains a prioritised and estimated list of
all functionality required by the user. Low Priority stories are
often coarse grained and undetailed in their nature and are often
referred to as Epics. As the story moves up in priority it often
needs to be broken up into smaller chunks so the resulting high
priority items are fine grained and take minimal effort to
complete. This is one of the essential components of scrum. Scrum
cannot really happen in any sense without it, it is important that
it is maintained in terms of estimates and prioritisation.

Release Burndown Chart

The Release Burndown Chart is a graph of progress through the
backlog showing the total Effort left in the backlog at the end of
each sprint. An example of a release burndown chart is shown
below. The graph shows a reducing value that can be used to
predict the release date.

Sprint Backlog

The Sprint Backlog is similar to the Product Backlog but just the
work committed by the Team for the current Sprint. This is usually
split down into Tasks which have an associated estimated work
remaining updated daily.

Sprint Burndown Chart

The Sprint Burndown Chart is similar to the Release Burndown chart
but tracking the work remaining in the Sprint Backlog.

Events

Scrum typically has 5 meetings or events.

Sprint Planning

At sprint planning, the Team decides how much capacity they have
for the next sprint, based on their previous Sprints'
Velocities. The Product Owner also decides on a goal for the
Sprint. The Team then goes through the backlog with the PO,
ensuring User Acceptance Criteria are up to date and estimates are
correct, and commit to User Stories until the effort required to
complete them matches their expected Velocity. This list is the
Sprint Backlog.

The User Stories on the Sprint Backlog can then be split down into
individual tasks and the remaining work estimated. Once the total
remaining work has been estimated and both Team and Product owner
are happy with the Sprint Backlog, the Team commits to doing the
work in the Sprint and the remaining work value used as a starting
point for the Sprint Burndown Chart.

Sprint

The sprint is when the work is carried out by the Team. The Sprint
Burndown Chart can be used to monitor progress as the remaining
work is reduced on a daily basis or more frequently. The Sprint
backlog is fixed for the duration of the sprint and the Team gets
on with the work, ensuring integrity and quality of the product
they are producing.

Daily Scrum

At a fixed time every day of the Sprint, usually first thing in
the morning, the team gets together for a quick stand-up
face-to-face meeting to inform each other of yesterday's progress,
today's tasks and any impediments that are blocking their progress
on a particular task or story. The Daily Scrum is a very important
part of scrum. It encourages communication, allows the team to
identify issues early and impediments cleared as and when they
happen.

Sprint Review

The purpose of the sprint review is for the Team to demo the User
Stories to the Product Owner and any other potential users or user
representatives. The Product Owner can try out the features, ask
questions and possibly formulate new User Stories for scenarios
not covered by the original User Acceptance Criteria. Once the
Product Owner is satisfied that a User Story is complete, they
mark the User Story as done and remove it from the backlog.

Once all User Stories are demo'd and marked as done or otherwise,
the total effort for those User Stories is recorded as the Team's
Velocity for the Sprint.

Retrospective

After the Sprint Review the team carries out a Retrospective on
the previous sprint, possibly including feedback from the Sprint
Review. The retrospective can take many forms, but typically
involves analysing good and bad things that are happening within
the Team, Process etc. and identifying actions to resolve them.

Applying Scrum Principles and Practices to your Project

While some scrum practitioners are quite strict in their approach to
applying scrum, I believe it is up to the team to determine how best
to apply scrum to their project. I have put together some thoughts
based on my experience as to when the items above are essential,
eneficial, unnecessary or sometimes a hindrance.

If you make choices based on my experience, only time and your
experience will tell whether they were the right ones. Therefore it
may be appropriate to adopt the whole of scrum and then use the
Retrospective to adapt the process as needed.

Roles

Product Owner

The product owner is the human interface to your users. This role
is essential if you want to truly capture your users' needs. It is
possible that a single person could fulfil 2 roles, Product Owner
and Scrummaster, although there will be a risk of encouraging the
ompromising of agile and lean principles by that one person as
they will be occupying 2 roles where conflicting interests may
need to be resolved.

I would always recommend that for any development, even for a Team
of 1, the Product Owner should be outside the team.

Team

It goes without saying that the team is essential, otherwise the
work will just not be done. Ideally the team should have members
that are multi-disciplined engineers, although this is not always
possible. However the team should always have within it all the
capability to design, develop and fully test User Stories and the
product to a point where the Product Owner can agree to the User
Story being done.

The ideal team size is said to be around 8 members. Much more than
this will start to get difficult, but many principles can still be
applied. The more people there are in a team, the more amplified
the difference of opinion may become, also the amount of work in
progress for the team as a whole increases meaning they will have
to keep a closer eye on in sprint progress.

Smaller teams however have different problems. It is more affected
by external distraction and often can be difficult to maintain a
predictable velocity. The constant production of a Sprint Backlog
that is rarely completed each sprint can be a real discouragement,
especially to a small team starting out with scrum. Often at this
time it is very important for the team to analyse the way that its
working and adapt scrum to reduce the amount of wasted time.

Scrummaster

The scrummaster is an interesting role. Many people say that if a
team is mature, understands scrum fully, is thinking in an agile
and lean manner, then it shouldn't need a scrummaster. The
scrummaster generally acts as a coach and mentor, so is important
for any team starting with scrum. Some teams even rotate the role
of Scrummaster each sprint so everyone gets a chance to learn
about applying scrum.

I would suggest that for teams of more than 1 then the role is
needed, especially on start-up. Only when a team and product is
mature is a scrummaster no longer needed, although even that is
debatable, as the scrummaster often brings more benefits than just
coaching

Artefacts

Product Backlog

The product backlog is essential, it defines the product, it
defines the future of the product, it is the basis for estimating,
prioritising and planning. The whole backlog should be prioritised
and estimated, with regular 'grooming' sessions to ensure that it
reflects priorities and expectations.

You cannot do scrum without a product backlog.

Release Burndown Chart

The release burndown chart is just a means of visualising the
Product Backlog; it is a means to an end. When used alongside the
Product Backlog, the Release Burndown Chart can be used to assist
planning and strategy.

How you visualise the progress through the backlog is up to you. I
would suggest a Release Burndown Chart as a starting
point. Cumulative Flow Diagrams are also very useful for
identifying lead times and bottlenecks, based on the change of
work In progress and are a good substitute for Release Burndown
Charts.

Sprint Backlog

The sprint backlog is a means of batching up work and tracking
small incremental batches of work. For a large team I would
suggest that in order for inspecting efficiency and tracking
progress then this is an essential item

However, for small teams that have an unpredictable velocity the
generation of the Sprint Backlog during Sprint Planning can be a
frustrating experience. Perhaps working directly from the Product
Backlog is more appropriate. Inspection of metrics gleaned from
the changing state of the Product Backlog may be more appropriate
in improving efficiency and tracking progress than a Sprint
Backlog.

Sprint Burndown Chart

Much like the Release Burndown Chart, the Sprint Burndown Chart is
just a means of visualising the progress through the Sprint
Backlog. It is a very useful graph and I would recommend that if a
Sprint Backlog is present, then a Sprint Burndown Chart is
essential.

Events

The first thing I would say that presuming there is more than 1
person involved with a project (Product Owner and 1 man Team as a
minimum) then these events are all necessary, how they are carried
out depends very much on how the artefacts are being used. I have
included some notes on each event.

Sprint Planning

Sprint planning is about just that, planning the Sprint. A goal
should always be set for the sprint by the Product Owner; an
expected target should also be set on the Product Backlog, based
on the Velocity.

Whether a Sprint backlog should be used was mentioned briefly
earlier.

The Sprint Planning meeting is often a good opportunity for some
Product Backlog grooming in terms of estimating and prioritising.

Daily Scrum

The Daily scrum is there to encourage communication and keep
everyone up to date. It requires minimal effort for small teams;
it can even be done remotely if needed, although a lot of
practitioners would discourage this.

The important thing is that everyone is up to date with what the
team is doing and impediments are being reported and addressed.

Sprint Review

The sprint review is necessary to check that the work in the
sprint backlog has been done. If you are adopting a more pipeline
approach, just taking work directly from the product backlog, then
it may be more appropriate for the Product Owner to review each
User Story as the team completes them. That way, work in progress
is also kept to a minimum.

Retrospective

Inspect and Adapt is an essential principle of scrum. It is
important that you determine ways and means of analysing what's
going well and badly as a Team and the Retrospective is the best
point at which to do this. As a 1 member team it is just as
appropriate to carry out a retrospective yourself at the end of a
sprint and record actions in order to improve the efficiency of
the way you work.

Author: John Cumming

Created: 2018-07-22 Sun 17:51

Validate


text:
<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Merchant_bankcard_manage extends MY_Controller {

	function __construct()
	{
		parent::__construct();
		parent::check_merchant_login();
	}

	public function index()
	{
        $seller_id = $this->session->userdata('seller_id');
        $bankcard = $this->db->query("select * from bankbind where user_id=$seller_id and type='0'")->row_array();
        $this->out_data['qq'] = $this->db->query("select qq from qqkefu where type = 2")->row_array();
		$this->out_data['qq'] = $this->out_data['qq']['qq'];
        if(!$bankcard){
            $this->out_data['con_page'] = 'merchant/bankcard_manage';
		    $this->load->view('merchant_default', $this->out_data);
        }else{
        	$this->out_data['bankcard'] = $bankcard;
            $this->out_data['con_page'] = 'merchant/bound_bankCard';
		    $this->load->view('merchant_default', $this->out_data);
        }

	}

	public function delete_bankcard()
	{
		$id = $this->input->post('bankcard_id');
		$this->db->delete('bankbind', array('id' => $id));
		$result['status'] = true;
		echo json_encode($result);
	}
}


text:
package org.apache.logging.log4j.docker.model;

import com.fasterxml.jackson.annotation.JsonProperty;

/**
 *
 */
public class HostConfig {

    @JsonProperty("NetworkMode")
    private String networkMode;
}


text:
@implementation AppDelegate

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    NSURL* appURL = [[[[NSBundle mainBundle] bundleURL] URLByAppendingPathComponent:@"../../../../Contents/MacOS/GrowlTunes" isDirectory:NO] URLByResolvingSymlinksInPath];
    NSLog(@"Launching GrowlTunes at URL: %@", appURL);
    NSDictionary* conf = [NSDictionary dictionary];
    NSError* error = nil;
    [[NSWorkspace sharedWorkspace] launchApplicationAtURL:appURL options:NSWorkspaceLaunchDefault configuration:conf error:&error];
    if (error) {
        NSLog(@"%@", error);
    }
    [NSApp terminate:nil];
}

@end


text:
package biz.webgate.dominoext.poi.component.containers;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.faces.component.UIComponentBase;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;
import javax.faces.el.ValueBinding;

import org.apache.poi.xwpf.usermodel.XWPFDocument;

import biz.webgate.dominoext.poi.component.data.ITemplateSource;
import biz.webgate.dominoext.poi.component.data.document.IDocumentBookmark;
import biz.webgate.dominoext.poi.component.data.document.table.DocumentTable;
import biz.webgate.dominoext.poi.component.data.image.IBookmarkImage;
import biz.webgate.dominoext.poi.component.kernel.DocumentProcessor;
import biz.webgate.dominoext.poi.utils.logging.LoggerFactory;

import com.ibm.commons.util.StringUtil;
import com.ibm.xsp.binding.MethodBindingEx;
import com.ibm.xsp.component.FacesAjaxComponent;
import com.ibm.xsp.util.FacesUtil;
import com.ibm.xsp.util.StateHolderUtil;

public class UIDocument extends UIComponentBase implements FacesAjaxComponent {

	public static final String COMPONENT_TYPE = "biz.webgate.dominoext.poi.Document"; //$NON-NLS-1$
	public static final String COMPONENT_FAMILY = "biz.webgate.dominoext.poi.Document"; //$NON-NLS-1$
	public static final String RENDERER_TYPE = "biz.webgate.dominoext.poi.Document"; //$NON-NLS-1$

	private List<IDocumentBookmark> m_Bookmarks;
	private List<DocumentTable> m_Tables;
	private List<IBookmarkImage> m_BookmarksImages;
	private String m_pathInfo;
	private String m_DownloadFileName;
	private ITemplateSource m_TemplateSource;
	private MethodBinding m_PostGenerationProcess;
	private Boolean m_PdfOutput;

	public UIDocument() {

		super();
		setRendererType(RENDERER_TYPE);
	}

	public List<IDocumentBookmark> getBookmarks() {
		return m_Bookmarks;
	}

	public void setBookmarks(List<IDocumentBookmark> bookmarks) {
		m_Bookmarks = bookmarks;
	}

	public void addBookmark(IDocumentBookmark myBookmark) {
		if (m_Bookmarks == null) {
			m_Bookmarks = new ArrayList<IDocumentBookmark>();
		}
		m_Bookmarks.add(myBookmark);
	}

	public List<IBookmarkImage> getBookmarksImages() {
		return m_BookmarksImages;
	}

	public void setBookmarksImages(List<IBookmarkImage> bookmarksImages) {
		m_BookmarksImages = bookmarksImages;
	}

	public void addBookmarkImage(IBookmarkImage myBookmarkImage) {
		if (m_Bookmarks == null) {
			m_Bookmarks = new ArrayList<IDocumentBookmark>();
		}
		m_BookmarksImages.add(myBookmarkImage);
	}

	public List<DocumentTable> getTables() {
		return m_Tables;
	}

	public void setTables(List<DocumentTable> tables) {
		m_Tables = tables;
	}

	public void addTables(DocumentTable myTable) {
		if (m_Tables == null) {
			m_Tables = new ArrayList<DocumentTable>();
		}
		m_Tables.add(myTable);
	}

	public String getPathInfo() {
		if (null != m_pathInfo) {
			return m_pathInfo;
		}
		ValueBinding _vb = getValueBinding("pathInfo"); //$NON-NLS-1$
		if (_vb != null) {
			return (java.lang.String) _vb.getValue(FacesContext.getCurrentInstance());
		} else {
			return null;
		}
	}

	public void setPathInfo(String linkName) {
		m_pathInfo = linkName;
	}

	public String getDownloadFileName() {
		if (null != m_DownloadFileName) {
			return m_DownloadFileName;
		}
		ValueBinding _vb = getValueBinding("downloadFileName"); //$NON-NLS-1$
		if (_vb != null) {
			return (java.lang.String) _vb.getValue(FacesContext.getCurrentInstance());
		} else {
			return null;
		}
	}

	public void setDownloadFileName(String downloadFileName) {
		m_DownloadFileName = downloadFileName;
	}

	public ITemplateSource getTemplateSource() {
		return m_TemplateSource;
	}

	public void setTemplateSource(ITemplateSource templateSource) {
		m_TemplateSource = templateSource;
	}

	@Override
	public String getFamily() {
		return COMPONENT_FAMILY;
	}

	public boolean getPdfOutput() {
		if (null != m_PdfOutput) {
			return m_PdfOutput;
		}
		ValueBinding _vb = getValueBinding("pdfOutput"); //$NON-NLS-1$
		if (_vb != null) {
			return (Boolean) _vb.getValue(FacesContext.getCurrentInstance());
		} else {
			return false;
		}
	}

	public void setPdfOutput(boolean pdfOutput) {
		m_PdfOutput = pdfOutput;
	}

	public boolean handles(FacesContext context) {
		String reqPathInfo = context.getExternalContext().getRequestPathInfo();
		if (StringUtil.isNotEmpty(reqPathInfo)) {
			String pathInfo = getPathInfo();
			if (StringUtil.isEmpty(pathInfo)) {
				return false;
			}
			if (!pathInfo.startsWith("/")) {
				pathInfo = "/" + pathInfo;
			}
			if (!pathInfo.endsWith("/")) {
				pathInfo += "/";
			}
			if (!reqPathInfo.startsWith("/")) {
				reqPathInfo = "/" + reqPathInfo;
			}
			if (!reqPathInfo.endsWith("/")) {
				reqPathInfo += "/";
			}
			if (reqPathInfo.startsWith(pathInfo)) {
				return true;
			}
		}
		return false;
	}

	public void processAjaxRequest(FacesContext context) throws IOException {
		DocumentProcessor.INSTANCE.processCall(context, this, false, null);
	}

	public ByteArrayOutputStream processRequestAndGetStream() throws IOException {
		ByteArrayOutputStream bos = null;
		Logger logCurrent = LoggerFactory.getLogger(this.getClass().getCanonicalName());

		ITemplateSource itsCurrent = getTemplateSource();
		if (itsCurrent == null) {
			logCurrent.severe("No Template found!");
			return bos;
		}
		logCurrent.info("Start processing UIDocument generation");
		try {
			bos = DocumentProcessor.INSTANCE.generateNewByteArrayOutputStream(itsCurrent, getBookmarks(), getTables(), getBookmarksImages(), getFacesContext(), this);
		} catch (Exception e) {
			logCurrent.log(Level.SEVERE, "Error in UIGeneration", e);
		}
		return bos;
	}

	// SAVING AND RESTORING
	@Override
	public Object saveState(FacesContext context) {
		try {
			Object[] state = new Object[9];
			state[0] = super.saveState(context);
			state[1] = m_DownloadFileName;
			state[2] = m_pathInfo;
			state[3] = FacesUtil.objectToSerializable(context, m_TemplateSource);
			state[4] = StateHolderUtil.saveList(context, m_Bookmarks);
			state[5] = StateHolderUtil.saveMethodBinding(context, m_PostGenerationProcess);
			state[6] = m_PdfOutput;
			state[7] = StateHolderUtil.saveList(context, m_Tables);
			state[8] = StateHolderUtil.saveList(context, m_BookmarksImages);
			return state;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public void restoreState(FacesContext context, Object value) {
		Object[] state = (Object[]) value;
		super.restoreState(context, state[0]);
		m_DownloadFileName = (String) state[1];
		m_pathInfo = (String) state[2];
		m_TemplateSource = (ITemplateSource) FacesUtil.objectFromSerializable(context, this, state[3]);
		m_Bookmarks = StateHolderUtil.restoreList(context, this, state[4]);
		m_PostGenerationProcess = StateHolderUtil.restoreMethodBinding(context, this, state[5]);
		m_PdfOutput = (Boolean) state[6];
		m_Tables = StateHolderUtil.restoreList(context, this, state[7]);
		m_BookmarksImages = StateHolderUtil.restoreList(context, this, state[8]);

	}

	public MethodBinding getPostGenerationProcess() {
		return m_PostGenerationProcess;
	}

	public void setPostGenerationProcess(MethodBinding postGenerationProcess) {
		m_PostGenerationProcess = postGenerationProcess;
	}

	public boolean postGenerationProcess(FacesContext context, XWPFDocument document) {
		if (m_PostGenerationProcess != null) {
			Object[] params = null;
			if (m_PostGenerationProcess instanceof MethodBindingEx) {
				params = new Object[] { document };
				((MethodBindingEx) m_PostGenerationProcess).setComponent(this);
				((MethodBindingEx) m_PostGenerationProcess).setParamNames(s_postGenParamNames);
			}
			/*
			 * if (FacesUtil.isCancelled(m_PostGenerationProcess.invoke(context,
			 * params))) { return false; }
			*/
			doPostGenerationProcessPrivileged(context, params);
			return true;
		}
		return true;
	}

	public void doPostGenerationProcessPrivileged(final FacesContext context, final Object[] params) {
		try {
			AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
				public Void run() throws Exception {
					m_PostGenerationProcess.invoke(context, params);
					return null;
				}
			});
		} catch (PrivilegedActionException e) {
			e.printStackTrace();
		}
	}

	private static final String[] s_postGenParamNames = { "xwpfdocument" }; // $NON-NLS-1$
}


text:
<!doctype html>

    <meta charset="utf-8">

    <title>Responsive Testing mit Galen</title>

    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">

    <meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no">

    <link rel="stylesheet" href="styles/reveal.css" media="all">

    <link rel="stylesheet" href="styles/presentation.css" media="all">

    <link rel="shortcut icon" href="images/brand/favicon.png">

NOTES:">


text:
package com.communote.server.web.fe.widgets;

import java.util.Map;

import com.communote.common.paging.PageInformation;
import com.communote.common.util.PageableList;
import com.communote.server.api.core.common.IdentifiableEntityData;
import com.communote.server.core.filter.ResultSpecification;
import com.communote.server.core.filter.SortedResultSpecification;
import com.communote.server.core.vo.query.QueryParameters;
import com.communote.server.core.vo.query.config.FilterWidgetParameterNameProvider;
import com.communote.server.core.vo.query.config.QueryParametersConfigurator;
import com.communote.server.widgets.AbstractMultipleResultWidget;

/**
 * Abstract widget to be used by Widgets which only return a single result
 *
 * @param
 *            the type of {@link IdentifiableEntityData} the widget will return
 * @author Communote GmbH - http://www.communote.com/
 */
public abstract class AbstractPagedListWidget extends AbstractMultipleResultWidget implements
        PagedWidget {
    private final static FilterWidgetParameterNameProvider NAME_PROVIDER = FilterWidgetParameterNameProvider.INSTANCE;
    /**
     * Key to be used in the response metadata to denote whether there are more elements available
     * that can be fetched with an additional query.
     */
    protected static final String METADATA_KEY_MORE_AVAILABLE = "moreElementsAvailable";
    /**
     * Key to be used in the response metadata to denote the number of elements contained in the
     * response.
     */
    protected static final String METADATA_KEY_ELEMENTS_CONTAINED = "numberOfElementsContained";
    private PageInformation pageInformation;

    /**
     * Parameter for the paging interval
     */
    public static final String PARAM_PAGING_INTERVAL = "pagingInterval";

    /**
     * Returns 'default'
     *
     * @return the message key suffix
     * @see PagedWidget#getDefaultPagingMessageKeySuffix()
     */
    @Override
    public String getDefaultPagingMessageKeySuffix() {
        return "default";
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public PageInformation getPageInformation() {
        return pageInformation;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Map<String, String> getParameterDescriptions() {
        return null;
    }

    /**
     * Get a result specification using the parameters offset and maxcount
     *
     * @return The result specification initialized by the parameters
     */
    protected ResultSpecification getResultSpecification() {
        QueryParametersConfigurator configurer = new QueryParametersConfigurator(NAME_PROVIDER);
        ResultSpecification resultSpecification = configurer
                .getResultSpecification(getParameters());
        return resultSpecification;
    }

    /**
     * Get a sorted specification using the parameters offset and max count
     *
     * @return The sorted result specification initialized by the parameters
     */
    protected SortedResultSpecification getSortedResultSpecification() {
        int offset = getIntParameter(NAME_PROVIDER.getNameForOffset(), 0);
        int maxCount = getIntParameter(NAME_PROVIDER.getNameForMaxCount(), 0);

        SortedResultSpecification resultSpecification = new SortedResultSpecification(offset,
                maxCount);
        return resultSpecification;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected abstract PageableList handleQueryList();

    @Override
    public Object handleRequest() {
        PageableList result = handleQueryList();
        this.setCommonResponseMetadata(result);
        return result;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected void initParameters() {
        setParameter(NAME_PROVIDER.getNameForOffset(), "0");
        setParameter(NAME_PROVIDER.getNameForMaxCount(), "10");
        setParameter(PARAM_PAGING_INTERVAL, "5");

    }

    /**
     * Set common meta data extracted from the query result. This includes
     * {@link #METADATA_KEY_MORE_AVAILABLE} and {@link #METADATA_KEY_ELEMENTS_CONTAINED}
     *
     * @param result
     *            the query result
     */
    protected void setCommonResponseMetadata(PageableList<?> result) {
        if (result != null) {
            setResponseMetadata(METADATA_KEY_MORE_AVAILABLE,
                    result.getMinNumberOfAdditionalElements() > 0);
            setResponseMetadata(METADATA_KEY_ELEMENTS_CONTAINED,
                    result.size());
            if (result.getOffset() == 0 && result.size() == 0) {
                setResponseMetadata(METADATA_KEY_NO_CONTENT, true);
            }
        } else {
            setResponseMetadata(METADATA_KEY_ELEMENTS_CONTAINED, 0);
        }
    }

    /**
     * Set the Page Information
     *
     * @param result
     *            the list
     * @param resultSpecification
     *            the result specification
     */
    protected void setPageInformation(PageableList<?> result,
            ResultSpecification resultSpecification) {
        int pagingInterval = getIntParameter(PARAM_PAGING_INTERVAL, 5);
        pageInformation = QueryParameters.getPageInformation(result, resultSpecification,
                pagingInterval);

    }

    /**
     * @param pageInformation
     *            the pageInformation to set
     */
    protected void setPageInformation(PageInformation pageInformation) {
        this.pageInformation = pageInformation;
    }

    /**
     * Set the Page Information
     *
     * @param queryParameters
     *            the instance
     * @param result
     *            the list
     */
    protected void setPageInformation(QueryParameters queryParameters,
            PageableList<? extends IdentifiableEntityData> result) {
        int pagingInterval = getIntParameter(PARAM_PAGING_INTERVAL, 5);
        pageInformation = queryParameters.getPageInformation(result, pagingInterval);
    }
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<title>Simulate noscript</title>

	<meta name="description" content="DESCRIPTION" />
	<meta name="keywords" content="KEYWORDS" />

	<link rel="schema.DCTERMS" href="http://purl.org/dc/terms/" />
	<link rel="schema.AGLSTERMS" href="http://www.agls.gov.au/agls/terms/" />

	<meta name="DCTERMS.creator" scheme="AGLSTERMS.GOLD" content="c=AU; o=The State of Queensland; ou=DEPARTMENT NAME; ou=UNIT NAME" />
	<meta name="DCTERMS.publisher" scheme="AGLSTERMS.AglsAgent" content="corporateName=The State of Queensland; jurisdiction=Queensland" />
	<meta name="DCTERMS.created" content="2015-05-29" />
	<meta name="DCTERMS.modified" content="2015-05-29" />
	<meta name="DCTERMS.title" content="Neighbourhood dispute resolution | Your rights, crime and the law" />
	<meta name="DCTERMS.description" content="DESCRIPTION" />
	<meta name="DCTERMS.subject" scheme="AGLSTERMS.APAIS" content="Dispute resolution" />
	<meta name="AGLSTERMS.function" scheme="AGLSTERMS.AGIFT" content="JUSTICE ADMINISTRATION - Civil Law - Dispute mediation programs" />

	<meta name="DCTERMS.type" scheme="DCTERMS.DCMIType" content="Text" />
	<meta name="AGLSTERMS.documentType" scheme="AGLSTERMS.agls-document" content="index" />
	<meta name="DCTERMS.audience" scheme="AGLSTERMS.agls-audience" content="Queensland" />
	<meta name="DCTERMS.jurisdiction" scheme="AGLSTERMS.AglsJuri" content="Queensland" />
	<meta name="DCTERMS.license" scheme="DCTERMS.URI" content="http://creativecommons.org/licenses/by/3.0/au/" />
	<meta name="DCTERMS.source" scheme="DCTERMS.URI" content="https://staging.data.qld.gov.au/dataset/dispute-resolution-datasets/resource/56ac21ba-3de3-421a-ac40-297713e37e9d" />

You are here:

Your rights, crime and the law

Legal, mediation and justice of the peace

Settling disputes out of court

Neighbourhood mediation

Neighbourhood dispute resolution

Neighbourhood dispute resolution

Use this tool to discover how to resolve a neighbourhood dispute.

We provide general information which does not consider your individual circumstances.
					If you are unsure about your legal rights you should get independent legal advice.

What can I read or do next?

A cross-selling link

A second cross-selling link

A third cross-selling link

Ways to resolve your dispute

Self resolution can be the fastest and cheapest way to resolve disputes.

Assisted resolution may involve mean conciliation or mediation. It can save time and money for you and the community.

Formal resolution may mean going to a court or tribunal. It costs time and money but will give you a result that can be enforced.

Legal advice

Find a solicitor, law firm, barrister or free legal services.

Body corporate disputes

Formal resolution of many disputes between neighbours in a body corporate can only be dealt with through the Office of the Commissioner for Body Corporate and Community Management.

Tell us what you think

Does this site help? Fill in the feedback section and let us know.

Licence

Last updated

29 May 2015

Neighbourhood mediation

Neighbourhood mediation

How neighbourhood mediation works

Prepare for neighbourhood mediation

Neighbourhood dispute resolution


text:
(function () {

  /* Raffle message ( BBCODE ) */

  let raffleMessage = Array.from(document.querySelectorAll(
    '.raffle-message:not(.puzzle):nth-child(1n):not(.raffle-password)'));

  let raffleOwnerGrade = document.querySelector('div.raffle-username b.usr-label');
  raffleOwnerGrade = (raffleOwnerGrade) ? raffleOwnerGrade.textContent : null;
  raffleOwnerGrade = (raffleOwnerGrade == "Owner" || raffleOwnerGrade == "Admin" ||
    raffleOwnerGrade == "Mod");

  for (let i = 0, len = raffleMessage.length; i < len; i++) {
    raffleMessage[i].innerHTML = BBCode.ReParse(raffleMessage[i].innerHTML, raffleOwnerGrade);
  }

  /* Comments section */

  let comBox = document.querySelector('.raffle-commenters');

  if (comBox) {

    /* Link comments by repply (mouse hover) */

    function HoverTheRainbow(ev) {

      // Select all comments
      let allComs = comBox.querySelectorAll('.comment-container');
      let users = comBox.querySelectorAll('.username');

      // Search the .comment-container parent of the element ( usefull )
      for (let i = 0, c, len = allComs.length; i < len; i++) {
        if (allComs[i].contains(ev.target)) {
          ev.target = allComs[i];
          break;
        }
      }

      if (ev.target.matches(".comment-container")) {

        // Check if the post was a repply
        let userMention = ev.target.querySelector('.user-mention');
        userMention = (userMention) ? userMention.href : null;

        // get the hovered user
        let currUser = ev.target.querySelector('.username').href;

        for (let i = 0, len = users.length; i < len; i++) {

          // If the hover comment was a repply to other user
          if (users[i].href == userMention) {
            allComs[i].classList.add('linked');
          } else {
            allComs[i].classList.remove('linked');
          }

          // If is an other post from the same curr user
          if (users[i].href == currUser) {
            allComs[i].classList.add('currUser');
          } else {
            allComs[i].classList.remove('currUser');
          }
        }

      }
    }

    comBox.addEventListener('mouseover', HoverTheRainbow);

    /* Debug comment section */

    let owner = document.querySelector('.raffle-username a.username');
    owner = (owner) ? owner.textContent : null;

    function DebugCommentBBCODE() {

      let allComs = comBox.querySelectorAll('.comment-content:not(.checked)');

      for (let i = 0, len = allComs.length; i < len; i++) {

        if (!allComs[i].classList.contains('checked')) {

          allComs[i].classList.add('checked');
          allComs[i].innerHTML = BBCode.ReParse(allComs[i].innerHTML);

          /* Check if this user is the raffle owner */

          let userComment = allComs[i].parentElement.parentElement;

          if (userComment.querySelector('.comment-info .username').textContent == owner)
            userComment.classList.add('owner');
        }
      }

    };

    DebugCommentBBCODE();
    comBox.addEventListener('DOMSubtreeModified', DebugCommentBBCODE);
  }

  /* Ended Raffle */

  let ended = document.querySelector(".raffle-time-left");

  if (ended) {

    /* Recreate a Raffle */

    function RecreateRaffle() {
      console.log(BBCode.UnParse(raffleMessage[0].innerHTML));
      console.log(BBCode.UnParse(raffleMessage[1].innerHTML));
      console.log('Raffle recreated :D');
    }

    /* Append Recreate Raffle button */

    function RecreateRaffleButton() {

      return false; // TEMP TODO ... one day maybe ...

      /* That's for the next update */

      let target = document.querySelector('.raffle-well .raffle-opts-row');
      let button = BuildDOM.Create({
        tag: 'button',
        classList: ['btn', 'btn-embossed', 'btn-info', 'recreate-raffle'],
        innerHTML: '<i class="fa fa-plus"></i> Recreate this raffle'
      });

      button.addEventListener('click', RecreateRaffle);
      target.appendChild(button);
    }

    /* Number of winners on ended raffles */

    if (ended.dataset.time == "Raffle Ended") {

      let reclaim = Array.from(document.querySelectorAll("div.raffle-winners > .raffle-winner")),
        green = 0,
        orange = 0;
      for (var i = 0; i < reclaim.length; i++) {
        if (reclaim[i].querySelector('i').style.color == "limegreen") {
          green++
        } else {
          orange++
        };
      }
      ended.textContent += " (" + green + "/" + (green + orange) + ")";
      RecreateRaffleButton();
    }

    /* Button "Recreate raffle" on failed raffle */
    else if (ended.dataset.time == "Raffle Failed") {
      RecreateRaffleButton();
    }

  }

})();


text:
<?php
session_start();

$contenido = 'seguimiento/expedientes';

$data = array(
		'contenido' => $contenido,
);

Flight::render('template/layout', $data);
?>


text:
<!DOCTYPE html>

<TITLE>Manpage of radiusd_selinux</TITLE>
<meta charset="utf-8">
<link rel="stylesheet" href="/css/main.css" type="text/css">

linux manpages

{"type":"documentation"}

radiusd_selinux

Section: radiusd SELinux Policy documentation (8)
Updated: radiusd
Index
Return to Main Contents

NAME

radiusd_selinux - Security Enhanced Linux Policy for the radiusd processes

DESCRIPTION

BOOLEANS

SELinux policy is customizable based on least access required.  radiusd policy is extremely flexible and has several booleans that allow you to manipulate the policy and run radiusd with the tightest access possible.

If you want to allow users to login using a radius serve, you must turn on the authlogin_radius boolean.

setsebool -P authlogin_radius 1

FILE CONTEXTS

SELinux requires files to have an extended attribute to define the file type.

You can see the context of a file using the -Z option to lsP
Policy governs the access confined processes have to these files.
SELinux radiusd policy is very flexible allowing users to setup their radiusd processes in as secure a method as possible.

The following file types are defined for radiusd:

radiusd_etc_rw_t

- Set files with the radiusd_etc_rw_t type, if you want to treat the files as radiusd etc read/write content.

radiusd_etc_t

- Set files with the radiusd_etc_t type, if you want to store radiusd files in the /etc directories.

radiusd_exec_t

- Set files with the radiusd_exec_t type, if you want to transition an executable to the radiusd_t domain.

Paths:

/usr/sbin/freeradius, /etc/cron.(daily|monthly)/radiusd, /usr/sbin/radiusd, /etc/cron.(daily|weekly|monthly)/freeradius

radiusd_initrc_exec_t

- Set files with the radiusd_initrc_exec_t type, if you want to transition an executable to the radiusd_initrc_t domain.

radiusd_log_t

- Set files with the radiusd_log_t type, if you want to treat the data as radiusd log data, usually stored under the /var/log directory.

Paths:

/var/log/radacct(/.*)?, /var/log/radiusd-freeradius(/.*)?, /var/log/radius.log.*, /var/log/freeradius(/.*)?, /var/log/radwtmp.*, /var/log/radius(/.*)?, /var/log/radutmp

radiusd_var_lib_t

- Set files with the radiusd_var_lib_t type, if you want to store the radiusd files under the /var/lib directory.

radiusd_var_run_t

- Set files with the radiusd_var_run_t type, if you want to store the radiusd files under the /run directory.

Paths:

/var/run/radiusd.pid, /var/run/radiusd(/.*)?

Note: File context can be temporarily modified with the chcon command.  If you want to permanently change the file context you need to use the
semanage fcontext

command.  This will modify the SELinux labeling database.  You will need to use
restorecon

to apply the labels.

PORT TYPES

SELinux defines port types to represent TCP and UDP ports.

You can see the types associated with a port by using the following command:

semanage port -l

Policy governs the access confined processes have to these ports.
SELinux radiusd policy is very flexible allowing users to setup their radiusd processes in as secure a method as possible.

The following port types are defined for radiusd:

radius_port_t

Default Defined Ports:
tcp 8021

PROCESS TYPES

SELinux defines process types (domains) for each process running on the system

You can see the context of a process using the -Z option to psP
Policy governs the access confined processes have to files.
SELinux radiusd policy is very flexible allowing users to setup their radiusd processes in as secure a method as possible.

The following process types are defined for radiusd:

radiusd_t

Note:
semanage permissive -a PROCESS_TYPE

can be used to make a process type permissive. Permissive process types are not denied access by SELinux. AVC messages will still be generated.

COMMANDS

semanage fcontext

can also be used to manipulate default file context mappings.

semanage permissive

can also be used to manipulate whether or not a process type is permissive.

semanage module

can also be used to enable/disable/install/remove policy modules.

semanage port

can also be used to manipulate the port definitions

semanage boolean

can also be used to manipulate the booleans

system-config-selinux

is a GUI tool available to customize SELinux policy settings.

AUTHOR<TT>  </TT>

This manual page was autogenerated by genman.py.

SEE ALSO

selinux(8), radiusd(8), semanage(8), restorecon(8), chcon(1)
, setsebool(8)

Index

NAME

DESCRIPTION

BOOLEANS

FILE CONTEXTS

PORT TYPES

PROCESS TYPES

COMMANDS

AUTHOR<TT>  </TT>

SEE ALSO

This document was created by
man2html,
using the manual pages.

Time: 05:34:29 GMT, December 24, 2015


text:
namespace llvm {

// RISCVII - This namespace holds all of the target specific flags that
// instruction info tracks. All definitions must match RISCVInstrFormats.td.
namespace RISCVII {
enum {
  InstFormatPseudo = 0,
  InstFormatR = 1,
  InstFormatR4 = 2,
  InstFormatI = 3,
  InstFormatS = 4,
  InstFormatB = 5,
  InstFormatU = 6,
  InstFormatJ = 7,
  InstFormatCR = 8,
  InstFormatCI = 9,
  InstFormatCSS = 10,
  InstFormatCIW = 11,
  InstFormatCL = 12,
  InstFormatCS = 13,
  InstFormatCA = 14,
  InstFormatCB = 15,
  InstFormatCJ = 16,
  InstFormatOther = 17,

  InstFormatMask = 31
};

// RISC-V Specific Machine Operand Flags
enum {
  MO_None = 0,
  MO_CALL = 1,
  MO_PLT = 2,
  MO_LO = 3,
  MO_HI = 4,
  MO_PCREL_LO = 5,
  MO_PCREL_HI = 6,
  MO_GOT_HI = 7,
  MO_TPREL_LO = 8,
  MO_TPREL_HI = 9,
  MO_TPREL_ADD = 10,
  MO_TLS_GOT_HI = 11,
  MO_TLS_GD_HI = 12,

  // Used to differentiate between target-specific "direct" flags and "bitmask"
  // flags. A machine operand can only have one "direct" flag, but can have
  // multiple "bitmask" flags.
  MO_DIRECT_FLAG_MASK = 15
};
} // namespace RISCVII

namespace RISCVOp {
enum OperandType : unsigned {
  OPERAND_FIRST_RISCV_IMM = MCOI::OPERAND_FIRST_TARGET,
  OPERAND_UIMM4 = OPERAND_FIRST_RISCV_IMM,
  OPERAND_UIMM5,
  OPERAND_UIMM12,
  OPERAND_SIMM12,
  OPERAND_SIMM13_LSB0,
  OPERAND_UIMM20,
  OPERAND_SIMM21_LSB0,
  OPERAND_UIMMLOG2XLEN,
  OPERAND_LAST_RISCV_IMM = OPERAND_UIMMLOG2XLEN
};
} // namespace RISCVOp

// Describes the predecessor/successor bits used in the FENCE instruction.
namespace RISCVFenceField {
enum FenceField {
  I = 8,
  O = 4,
  R = 2,
  W = 1
};
}

// Describes the supported floating point rounding mode encodings.
namespace RISCVFPRndMode {
enum RoundingMode {
  RNE = 0,
  RTZ = 1,
  RDN = 2,
  RUP = 3,
  RMM = 4,
  DYN = 7,
  Invalid
};

inline static StringRef roundingModeToString(RoundingMode RndMode) {
  switch (RndMode) {
  default:
    llvm_unreachable("Unknown floating point rounding mode");
  case RISCVFPRndMode::RNE:
    return "rne";
  case RISCVFPRndMode::RTZ:
    return "rtz";
  case RISCVFPRndMode::RDN:
    return "rdn";
  case RISCVFPRndMode::RUP:
    return "rup";
  case RISCVFPRndMode::RMM:
    return "rmm";
  case RISCVFPRndMode::DYN:
    return "dyn";
  }
}

inline static RoundingMode stringToRoundingMode(StringRef Str) {
  return StringSwitch<RoundingMode>(Str)
      .Case("rne", RISCVFPRndMode::RNE)
      .Case("rtz", RISCVFPRndMode::RTZ)
      .Case("rdn", RISCVFPRndMode::RDN)
      .Case("rup", RISCVFPRndMode::RUP)
      .Case("rmm", RISCVFPRndMode::RMM)
      .Case("dyn", RISCVFPRndMode::DYN)
      .Default(RISCVFPRndMode::Invalid);
}

inline static bool isValidRoundingMode(unsigned Mode) {
  switch (Mode) {
  default:
    return false;
  case RISCVFPRndMode::RNE:
  case RISCVFPRndMode::RTZ:
  case RISCVFPRndMode::RDN:
  case RISCVFPRndMode::RUP:
  case RISCVFPRndMode::RMM:
  case RISCVFPRndMode::DYN:
    return true;
  }
}
} // namespace RISCVFPRndMode

namespace RISCVSysReg {
struct SysReg {
  const char *Name;
  unsigned Encoding;
  const char *AltName;
  // FIXME: add these additional fields when needed.
  // Privilege Access: Read, Write, Read-Only.
  // unsigned ReadWrite;
  // Privilege Mode: User, System or Machine.
  // unsigned Mode;
  // Check field name.
  // unsigned Extra;
  // Register number without the privilege bits.
  // unsigned Number;
  FeatureBitset FeaturesRequired;
  bool isRV32Only;

  bool haveRequiredFeatures(FeatureBitset ActiveFeatures) const {
    // Not in 32-bit mode.
    if (isRV32Only && ActiveFeatures[RISCV::Feature64Bit])
      return false;
    // No required feature associated with the system register.
    if (FeaturesRequired.none())
      return true;
    return (FeaturesRequired & ActiveFeatures) == FeaturesRequired;
  }
};

#define GET_SysRegsList_DECL
#include "RISCVGenSystemOperands.inc"
} // end namespace RISCVSysReg

namespace RISCVABI {

enum ABI {
  ABI_ILP32,
  ABI_ILP32F,
  ABI_ILP32D,
  ABI_ILP32E,
  ABI_LP64,
  ABI_LP64F,
  ABI_LP64D,
  ABI_Unknown
};

// Returns the target ABI, or else a StringError if the requested ABIName is
// not supported for the given TT and FeatureBits combination.
ABI computeTargetABI(const Triple &TT, FeatureBitset FeatureBits,
                     StringRef ABIName);

ABI getTargetABI(StringRef ABIName);

// Returns the register used to hold the stack pointer after realignment.
Register getBPReg();

} // namespace RISCVABI

namespace RISCVFeatures {

// Validates if the given combination of features are valid for the target
// triple. Exits with report_fatal_error if not.
void validate(const Triple &TT, const FeatureBitset &FeatureBits);

} // namespace RISCVFeatures

} // namespace llvm

#endif


text:
namespace DbFriend.Core.Generator.Settings
{
    /// <summary>
    /// </summary>
    public interface IDbScriptFolderConfigurationSetting
    {
        /// <summary>
        /// Gets OutputFolder.
        /// </summary>
        /// <value>
        /// The output folder.
        /// </value>
        string OutputFolder { get; }
    }
}


text:
<!doctype html>

      <title>Image Decoder</title>
      <link rel="stylesheet" type="text/css" href="style.css">

How to use:

Copy image string from aws S3

Paste image string into text box (this takes some time)

Click decode (this takes some time)

Image will appear

    <input type="text" id="img-input">
    <button id="decode-button">
      Decode
    </button>


text:
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Header-only libraries</title>
<link rel="stylesheet" href="../../boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
<link rel="start" href="../../index.html" title="Boost.Build V2 User Manual">
<link rel="up" href="../faq.html" title="Chapter 8. Frequently Asked Questions">
<link rel="prev" href="../recipies/site-config.html" title="Targets in site-config.jam">
<link rel="next" href="../jam.html" title="Appendix A. Boost.Jam Documentation">

Header-only libraries

In modern C++, libraries often consist of just header files, without
    any source files to compile. To use such libraries, you need to add proper
    includes and, maybe, defines, to your project. But with large number of
    external libraries it becomes problematic to remember which libraries are
    header only, and which are "real" ones. However, with Boost.Build a
    header-only library can be declared as Boost.Build target and all
    dependents can use such library without remebering if it's header-only or not.

Header-only libraries are declared using the alias rule,
    that specifies only usage requirements, for example:

alias mylib
    : # no sources
    : # no build requirements
    : # no default build
    : <include>whatever
    ;

    The includes specified in usage requirements of mylib are
    automatically added to build properties of all dependents. The dependents
    need not care if mylib is header-only or not, and it's possible
    to later make mylib into a regular compiled library.

      If you already have proper usage requirements declared for project where
      header-only library is defined, you don't need to duplicate them for
      the alias target:

project my : usage-requirements <include>whatever ;
alias mylib ;


text:
using System;
using System.Xml.Serialization;

namespace Aop.Api.Response
{
    /// <summary>
    /// AlipayOpenWangyanTestDeleteResponse.
    /// </summary>
    public class AlipayOpenWangyanTestDeleteResponse : AopResponse
    {
    }
}


text:
/**
 * @author fvi@
 * 2012 07 18 created
 *
 *
 */

function Topview() {

	//load component dependencies
	height = Ti.Platform.displayCaps.platformHeight, width = Ti.Platform.displayCaps.platformWidth;

	var view = new require('ui/common/FirstView')();

	var user_name = '';
	if(Titanium.App.Properties.getString('user_name') == null){
		user_name = 'ゲスト'
	}else{
		user_name = Titanium.App.Properties.getString('user_name');

	}

	var userLabel = Titanium.UI.createLabel({
		text:'こんにちは '+user_name+'さん',
		textAlign:'center',
		color:'black',
		top:0
	});

	Titanium.App.addEventListener('createdUser',function(e){
		userLabel.setText('こんにちは' +Titanium.App.Properties.getString('user_name')+'さん');
	});
	Titanium.App.addEventListener('ReLogin',function(e){
		userLabel.setText('こんにちは' +Titanium.App.Properties.getString('user_name')+'さん');
	});

	view.add(userLabel);

	var countView = new require('/ui/common/PointFrame')(Titanium.App.Properties.getInt('point'));
	countView.setTop(height * 0.1);

	view.add(countView);

	var back_cork = Titanium.UI.createImageView({
		image : '/images/background/back_lightblue.png',
		width : width,
		height : height * 0.55,
		top : height * 0.27
	});

	view.add(back_cork);
	var rows = [{
		title : '完全ランダム 15問',
		textAlign : 'center',
		color : 'black',
		height : height * 0.12
	}, {
		title : 'ジャンル指定 15問',
		textAlign : 'center',
		color : 'black',
		height : height * 0.12
	}, {
		title : 'マイジャンル! 15問',
		textAlign : 'center',
		color : 'black',
		height : height * 0.12
	}, {
		title : '百問組み手!',
		textAlign : 'center',
		color : 'black',
		height : height * 0.12
	},
	{
		title : '恐怖! 1問5秒 タイムアタック',
		textAlign : 'center',
		color : 'black',
		height : height * 0.12
	},
	{
		title : '一発でドボン',
		textAlign : 'center',
		color : 'black',
		height : height * 0.12
	}];
	var textArea = Titanium.UI.createTableView({
		data : rows,
		width : width * 0.95,
		height : height * 0.5,
		top : height * 0.3,
		showVerticalScrollIndicator:true

	});

	textArea.addEventListener('click', function(e) {
		require('/Quiz/QuizStarter').QuizDownLoadStart({type:'example',shuffle:true});

	});

	view.add(textArea);

	var tabView = require('/ui/common/menuTab/MenuTab').createMenuTab(1);
	view.add(tabView.view);

	//画像が読み込まれたときに発動。 view は画面のフォーカスが完了するまでloadを行わないので代用する
	view.addEventListener('load', function(e) {
		Titanium.UI.createNotification({
			duration : 3000,
			message : "起動特典として 1Qが追加されました"
		}).show();
	});

	return view;
}

module.exports = Topview;


text:
package com.siyeh.ig.controlflow;

import com.intellij.testFramework.fixtures.LightJavaCodeInsightFixtureTestCase;
import com.siyeh.ig.LightJavaInspectionTestCase;

public class UnnecessaryContinueInspectionTest extends LightJavaCodeInsightFixtureTestCase {
  @Override
  protected String getBasePath() {
    return LightJavaInspectionTestCase.INSPECTION_GADGETS_TEST_DATA_PATH + "com/siyeh/igtest/controlflow/unnecessary_continue";
  }

  private void doTest() {
    UnnecessaryContinueInspection inspection = new UnnecessaryContinueInspection();
    inspection.ignoreInThenBranch = true;
    myFixture.enableInspections(inspection);
    myFixture.testHighlighting(getTestName(false) + ".java");
  }

  public void testUnnecessaryContinue() {
    doTest();
  }

}


text:
//
// TBButtonRow.h
// TableViewBuddy
//
// Copyright (c) 2014-2016 Hironori Ichimiya <hiron@hironytic.com>
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

#import "TBActionRow.h"
#import "TBTableDataBuilder.h"

/**
 `TBButtonRow` is a row that user can tap and execute some action.

 In addition to `<TBActionRow>`, the look and feel of the cell indicates that the row has some action,
 i.e. the title text is tinted on iOS 7 or over.
 */
@interface TBButtonRow : TBActionRow

@end

@interface TBTableDataBuilder (TBButtonRow)
/**
 Builds a row of `<TBButtonRow>`.

 @param configurator A block object which configure the row.
 */
- (void)buildButtonRow:(void (^)(TBButtonRow *row))configurator;
@end