text:
const pageScroll = (function () {
    const fn = function (e) {
        e.preventDefault();
        e.stopPropagation();
    };
    let islock = false;

    return {
        lock(el) {
            if (islock) return;
            islock = true;
            (el || document).addEventListener('touchmove', fn);
        },
        unlock(el) {
            islock = false;
            (el || document).removeEventListener('touchmove', fn);
        }
    };
})();

const preventScroll = (function () {
    return {
        lock(el) {
            isIOS && addClass(el || document.body, 'g-fix-ios-prevent-scroll');
        },
        unlock(el) {
            isIOS && removeClass(el || document.body, 'g-fix-ios-prevent-scroll');
        }
    };
})();

const isIOS = !!(window.navigator && window.navigator.userAgent || '').match(/\(i[^;]+;( U;)? CPU.+Mac OS X/);

const isColor = function (value) {
    const colorReg = /^#([a-fA-F0-9]){3}(([a-fA-F0-9]){3})?$/;
    const rgbaReg = /^[rR][gG][bB][aA]\(\s*((25[0-5]|2[0-4]\d|1?\d{1,2})\s*,\s*){3}\s*(\.|\d+\.)?\d+\s*\)$/;
    const rgbReg = /^[rR][gG][bB]\(\s*((25[0-5]|2[0-4]\d|1?\d{1,2})\s*,\s*){2}(25[0-5]|2[0-4]\d|1?\d{1,2})\s*\)$/;

    return colorReg.test(value) || rgbaReg.test(value) || rgbReg.test(value);
};

const getScrollview = function (el) {
    let currentNode = el;
    while (currentNode && currentNode.tagName !== 'HTML' && currentNode.tagName !== 'BODY' && currentNode.nodeType === 1) {
        let overflowY = document.defaultView.getComputedStyle(currentNode).overflowY;
        if (overflowY === 'scroll' || overflowY === 'auto') {
            return currentNode;
        }
        currentNode = currentNode.parentNode;
    }
    return window;
};

const checkInview = function (scrollView, el) {
    const contentHeight = scrollView === window ? document.body.offsetHeight : scrollView.offsetHeight;
    const contentTop = scrollView === window ? 0 : scrollView.getBoundingClientRect().top;

    const post = el.getBoundingClientRect().top - contentTop;
    const posb = post + el.offsetHeight;

    return (post >= 0 && post < contentHeight) || (posb > 0 && posb <= contentHeight);
};

const hasClass = function (elem, cls) {
    cls = cls || '';
    if (cls.replace(/\s/g, '').length === 0 || !elem) return false;
    return new RegExp(' ' + cls + ' ').test(' ' + elem.className + ' ');
};

const addClass = function (ele, cls) {
    if (!hasClass(ele, cls)) {
        ele.className = ele.className === '' ? cls : ele.className + ' ' + cls;
    }
};

const removeClass = function (ele, cls) {
    if (hasClass(ele, cls)) {
        let newClass = ' ' + ele.className.replace(/[\t\r\n]/g, '') + ' ';
        while (newClass.indexOf(' ' + cls + ' ') >= 0) {
            newClass = newClass.replace(' ' + cls + ' ', ' ');
        }
        ele.className = newClass.replace(/^\s+|\s+$/g, '');
    }
};

//Copy from iView. https://www.iviewui.com/
const scrollTop = function (el, from = 0, to, duration = 500, callback) {
    if (!window.requestAnimationFrame) {
        window.requestAnimationFrame = (
            window.webkitRequestAnimationFrame ||
            window.mozRequestAnimationFrame ||
            window.msRequestAnimationFrame ||
            function (callback) {
                return window.setTimeout(callback, 1000 / 60);
            }
        );
    }
    const difference = Math.abs(from - to);
    const step = Math.ceil(difference / duration * 50);

    function scroll(start, end, step) {
        if (start === end) {
            typeof callback === 'function' && callback();
            return;
        }

        let d = (start + step > end) ? end : start + step;
        if (start > end) {
            d = (start - step < end) ? end : start - step;
        }

        if (el === window) {
            window.scrollTo(d, d);
        } else {
            el.scrollTop = d;
        }
        window.requestAnimationFrame(() => scroll(d, end, step));
    }

    scroll(from, to, step);
};

export {pageScroll, preventScroll, isIOS, isColor, getScrollview, checkInview, addClass, removeClass, scrollTop};


text:
require File.expand_path('../../../../../spec_helper', __FILE__)
require 'net/http'
require File.expand_path('../fixtures/http_server', __FILE__)
require File.expand_path('../shared/started', __FILE__)

describe "Net::HTTP#started?" do
  it_behaves_like :net_http_started_p, :started?
end

redpajama_set_name: RedPajamaGithub


text:
#pragma once

#include <string>
#include <memory>
#include <utility>
#include "Core.h"

namespace org {
namespace apache {
namespace nifi {
namespace minifi {
namespace core {

/**
 * Factory that is used as an interface for
 * creating processors from shared objects.
 */
class ObjectFactory {
 public:
  explicit ObjectFactory(std::string group)
      : group_(std::move(group)) {
  }

  ObjectFactory() = default;

  /**
   * Virtual destructor.
   */
  virtual ~ObjectFactory() = default;

  /**
   * Create a unique pointer to a new processor.
   */
  virtual std::unique_ptr<CoreComponent> create(const std::string& /*name*/) {
    return nullptr;
  }

  /**
   * Create a raw pointer to a new processor.
   */
  virtual CoreComponent *createRaw(const std::string& /*name*/) {
    return nullptr;
  }

  /**
   * Create a unique pointer to a new processor.
   */
  virtual std::unique_ptr<CoreComponent> create(const std::string& /*name*/, const utils::Identifier& /*uuid*/) {
    return nullptr;
  }

  /**
   * Create a raw pointer to a new processor.
   */
  virtual CoreComponent* createRaw(const std::string& /*name*/, const utils::Identifier& /*uuid*/) {
    return nullptr;
  }

  virtual std::string getGroupName() const {
    return group_;
  }

  virtual std::string getClassName() = 0;

 private:
  std::string group_;
};
/**
 * Factory that is used as an interface for
 * creating processors from shared objects.
 */
template<class T>
class DefautObjectFactory : public ObjectFactory {
 public:
  DefautObjectFactory() {
    className = core::getClassName<T>();
  }

  explicit DefautObjectFactory(std::string group_name)
      : ObjectFactory(std::move(group_name)) {
    className = core::getClassName<T>();
  }

  /**
   * Create a unique pointer to a new processor.
   */
  std::unique_ptr<CoreComponent> create(const std::string &name) override {
    return std::make_unique<T>(name);
  }

  /**
   * Create a unique pointer to a new processor.
   */
  std::unique_ptr<CoreComponent> create(const std::string &name, const utils::Identifier &uuid) override {
    return std::make_unique<T>(name, uuid);
  }

  /**
   * Create a raw pointer to a new processor.
   */
  CoreComponent* createRaw(const std::string &name) override {
    T *ptr = new T(name);
    return dynamic_cast<CoreComponent*>(ptr);
  }

  /**
   * Create a raw pointer to a new processor.
   */
  CoreComponent* createRaw(const std::string &name, const utils::Identifier &uuid) override {
    T *ptr = new T(name, uuid);
    return dynamic_cast<CoreComponent*>(ptr);
  }

  /**
   * Gets the class name for the object
   * @return class name for the processor.
   */
  std::string getClassName() override {
    return className;
  }

 protected:
  std::string className;
};

}  // namespace core
}  // namespace minifi
}  // namespace nifi
}  // namespace apache
}  // namespace org


text:
<?php
namespace UNL\UCBCN\Event;

use UNL\UCBCN\ActiveRecord\Record;

/**
 * ORM for a record within the database.
 *
 * @package   UNL_UCBCN
 * @author    Brett Bieber <brett.bieber@gmail.com>
 * @copyright 2009 Regents of the University of Nebraska
 * @license   http://www1.unl.edu/wdn/wiki/Software_License BSD License
 * @link      http://code.google.com/p/unl-event-publisher/
 */
class KeyWord extends Record
{

    public $id;                              // int(10)  not_null primary_key unsigned auto_increment
    public $event_id;                        // int(10)  not_null multiple_key unsigned
    public $keyword_id;                      // int(10)  not_null multiple_key unsigned

    public static function getTable()
    {
        return 'event_has_keyword';
    }

    function table()
    {
        return array(
            'id'=>129,
            'event_id'=>129,
            'keyword_id'=>129,
        );
    }

    function keys()
    {
        return array(
            'id',
        );
    }

    function sequenceKey()
    {
        return array('id',true);
    }

    function links()
    {
        return array('event_id'   => 'event:id',
                     'keyword_id' => 'keyword:id');
    }
}


text:
local wire_library, _ = SF.Libraries.Register("wire")

SF.Wire = {}
SF.Wire.Library = wire_library

local wirelink_methods, wirelink_metatable = SF.Typedef("Wirelink")
local wlwrap, wlunwrap = SF.CreateWrapper(wirelink_metatable,true,true)

---
-- @class table
-- @name SF.Wire.WlMetatable
SF.Wire.WlMetatable = wirelink_metatable
SF.Wire.WlMethods = wirelink_methods

---
-- @class function
-- @name SF.Wire.WlWrap
-- @param wirelink
SF.Wire.WlWrap = wlwrap

---
-- @class function
-- @name SF.Wire.WlUnwrap
-- @param wrapped
SF.Wire.WlUnwrap = wlunwrap

-- ------------------------- Internal Library ------------------------- --

-- Allowed Expression2's types in tables and their short names
local expression2types = {
	n = "NORMAL",
	s = "STRING",
	v = "VECTOR",
	a = "ANGLE",
	xwl = "WIRELINK",
	e = "ENTITY",
	t = "TABLE"
}

local function convertFromExpression2(value, shortTypeName)
	local typ = expression2types[shortTypeName]
	if not typ or not SF.Wire.InputConverters[typ] then return nil end

	return SF.Wire.InputConverters[typ](value)
end

local function convertToExpression2(value)
	local typ = type(value)

	-- Simple type?
	if typ == "number" then return value, "n"
	elseif typ == "string" then return value, "s"
	elseif typ == "Vector" then return {value.x, value.y, value.z}, "v"
	elseif typ == "Angle" then return {value.p, value.y, value.r}, "a"

	-- We've got a table there. Is it wrapped object?
	elseif typ == "table" then
		local value = SF.Unsanitize(value)
		typ = type(value)

		if typ == "table" then
			-- It is still table, do recursive convert
			return SF.Wire.OutputConverters.TABLE(value), "t"

		-- Unwrapped entity (wirelink goes to this, but it returns it as entity; don't think somebody needs to put wirelinks in table)
		elseif typ == "Entity" then return value, "e" end
	end

	-- Nothing found / unallowed type
	return nil, nil
end

local function identity(data) return data end
local inputConverters =
{
	NORMAL = identity,
	STRING = identity,
	VECTOR = identity,
	ANGLE = identity,
	WIRELINK = function(wl) return wlwrap(wl) end,

	TABLE = function(tbl)
		if not tbl.s or not tbl.stypes or not tbl.n or not tbl.ntypes or not tbl.size then return {} end
		if tbl.size == 0 then return {} end -- Don't waste our time
		local conv = {}

		-- Key-numeric part of table
		for key, typ in pairs(tbl.ntypes) do
			conv[key] = convertFromExpression2(tbl.n[key], typ)
		end

		-- Key-string part of table
		for key, typ in pairs(tbl.stypes) do
			conv[key] = convertFromExpression2(tbl.s[key], typ)
		end

		return conv
	end
}

local outputConverters =
{
	NORMAL = function(data)
		SF.CheckType(data,"number",1)
		return data
	end,
	STRING = function(data)
		SF.CheckType(data,"string",1)
		return data
	end,
	VECTOR = function(data)
		SF.CheckType(data,"Vector",1)
		return data
	end,
	ANGLE = function(data)
		SF.CheckType(data,"Angle",1)
		return data
	end,

	TABLE = function(data)
		SF.CheckType(data,"table",1)

		local tbl = {istable=true, size=0, n={}, ntypes={}, s={}, stypes={}}

		for key, value in pairs(data) do
			local value, shortType = convertToExpression2(value)

			if shortType then
				if type(key) == "string" then
					tbl.s[key] = value
					tbl.stypes[key] = shortType
					tbl.size = tbl.size+1

				elseif type(key) == "number" then
					tbl.n[key] = value
					tbl.ntypes[key] = shortType
					tbl.size = tbl.size+1
				end
			end
		end

		return tbl
	end
}

SF.Wire.InputConverters = inputConverters
SF.Wire.OutputConverters = outputConverters

--- Adds an input type
-- @param name Input type name. Case insensitive.
-- @param converter The function used to convert the wire data to SF data (eg, wrapping)
function SF.Wire.AddInputType(name, converter)
	inputConverters[name:upper()] = converter
end

--- Adds an output type
-- @param name Output type name. Case insensitive.
-- @param deconverter The function used to check for the appropriate type and convert the SF data to wire data (eg, unwrapping)
function SF.Wire.AddOutputType(name, deconverter)
	outputConverters[name:upper()] = deconverter
end

-- ------------------------- Basic Wire Functions ------------------------- --

--- Creates/Modifies wire inputs. All wire ports must begin with an uppercase
-- letter and contain only alphabetical characters.
-- @param names An array of input names. May be modified by the function.
-- @param types An array of input types. May be modified by the function.
function wire_library.createInputs(names, types)
	SF.CheckType(names,"table")
	SF.CheckType(types,"table")
	local ent = SF.instance.data.entity
	if not ent then SF.throw( "No entity to create inputs on", 2 ) end

	if #names ~= #types then SF.throw( "Table lengths not equal", 2 ) end
	for i=1,#names do
		local newname = names[i]
		local newtype = types[i]
		if type(newname) ~= "string" then SF.throw( "Non-string input name: " .. newname, 2 ) end
		if type(newtype) ~= "string" then SF.throw( "Non-string input type: " .. newtype, 2 ) end
		newtype = newtype:upper()
		if not newname:match( "^[%u][%a%d]*$" ) then SF.throw( "Invalid input name: " .. newname, 2 ) end
		if not inputConverters[ newtype ] then SF.throw( "Invalid/unsupported input type: " .. newtype, 2 ) end
		names[i] = newname
		types[i] = newtype
	end

	WireLib.AdjustSpecialInputs(ent,names,types)
end

--- Creates/Modifies wire outputs. All wire ports must begin with an uppercase
-- letter and contain only alphabetical characters.
-- @param names An array of output names. May be modified by the function.
-- @param types An array of output types. May be modified by the function.
function wire_library.createOutputs(names, types)
	SF.CheckType(names,"table")
	SF.CheckType(types,"table")
	local ent = SF.instance.data.entity
	if not ent then SF.throw( "No entity to create outputs on", 2 ) end

	if #names ~= #types then SF.throw( "Table lengths not equal", 2 ) end
	for i=1,#names do
		local newname = names[i]
		local newtype = types[i]
		if type(newname) ~= "string" then SF.throw( "Non-string output name: " .. newname, 2 ) end
		if type(newtype) ~= "string" then SF.throw( "Non-string output type: " .. newtype, 2 ) end
		newtype = newtype:upper()
		if not newname:match("^[%u][%a%d]*$") then SF.throw( "Invalid output name: " .. newname, 2 ) end
		if not outputConverters[newtype] then SF.throw( "Invalid/unsupported output type: " .. newtype, 2 ) end
		names[i] = newname
		types[i] = newtype
	end

	WireLib.AdjustSpecialOutputs(ent,names,types)
end

--- Returns the wirelink representing this entity.
function wire_library.self()
	local ent = SF.instance.data.entity
	if not ent then SF.throw( "No entity", 2 ) end
	return wlwrap(ent)
end

-- ------------------------- Wirelink ------------------------- --

--- Retrieves an output. Returns nil if the output doesn't exist.
wirelink_metatable.__index = function(self,k)
	SF.CheckType(self,wirelink_metatable)
	if wirelink_methods[k] then
		return wirelink_methods[k]
	else
		local wl = wlunwrap(self)
		if not wl or not wl:IsValid() or not wl.extended then return end -- TODO: What is wl.extended?

		if type(k) == "number" then
			return wl.ReadCell and wl:ReadCell(k) or nil
		else
			local output = wl.Outputs and wl.Outputs[k]
			if not output or not inputConverters[output.Type] then return end
			return inputConverters[output.Type](output.Value)
		end
	end
end

--- Writes to an input.
wirelink_metatable.__newindex = function(self,k,v)
	SF.CheckType(self,wirelink_metatable)
	local wl = wlunwrap(self)
	if not wl or not wl:IsValid() or not wl.extended then return end -- TODO: What is wl.extended?
	if type(k) == "number" then
		SF.CheckType(v,"number")
		if not wl.WriteCell then return
		else wl:WriteCell(k,v) end
	else
		local input = wl.Inputs and wl.Inputs[k]
		if not input or not outputConverters[input.Type] then return end
		WireLib.TriggerInput(wl,k,outputConverters[input.Type](v))
	end
end

--- Checks if a wirelink is valid. (ie. doesn't point to an invalid entity)
function wirelink_methods:isValid()
	SF.CheckType(self,wirelink_metatable)
	return wlunwrap(self) and true or false
end

--- Returns the type of input name, or nil if it doesn't exist
function wirelink_methods:inputType(name)
	SF.CheckType(self,wirelink_metatable)
	local wl = wlunwrap(self)
	if not wl then return end
	local input = wl.Inputs[name]
	return input and input.Type
end

--- Returns the type of output name, or nil if it doesn't exist
function wirelink_methods:outputType(name)
	SF.CheckType(self,wirelink_metatable)
	local wl = wlunwrap(self)
	if not wl then return end
	local output = wl.Outputs[name]
	return output and output.Type
end

--- Returns the entity that the wirelink represents
function wirelink_methods:entity()
	SF.CheckType(self,wirelink_metatable)
	return SF.Entities.Wrap(wlunwrap(self))
end

--- Returns a table of all of the wirelink's inputs
function wirelink_methods:inputs()
	SF.CheckType(self,wirelink_metatable)
	local wl = wlunwrap(self)
	if not wl then return nil end
	local Inputs = wl.Inputs
	if not Inputs then return {} end

	local inputNames = {}
	for _,port in pairs(Inputs) do
		inputNames[#inputNames+1] = port.Name
	end

	local function portsSorter(a,b)
		return Inputs[a].Num < Inputs[b].Num
	end
	table.sort(inputNames, portsSorter)

	return inputNames
end

--- Returns a table of all of the wirelink's outputs
function wirelink_methods:outputs()
	SF.CheckType(self,wirelink_metatable)
	local wl = wlunwrap(self)
	if not wl then return nil end
	local Outputs = wl.Outputs
	if not Outputs then return {} end

	local outputNames = {}
	for _,port in pairs(Outputs) do
		outputNames[#outputNames+1] = port.Name
	end

	local function portsSorter(a,b)
		return Outputs[a].Num < Outputs[b].Num
	end
	table.sort(outputNames, portsSorter)

	return outputNames
end

--- Checks if an input is wired.
function wirelink_methods:isWired(name)
	SF.CheckType(self,wirelink_metatable)
	SF.CheckType(name,"string")
	local wl = wlunwrap(self)
	if not wl then return nil end
	local input = wl.Inputs[name]
	if input and input.Src and input.Src:IsValid() then return true
	else return false end
end

-- ------------------------- Ports Metatable ------------------------- --
local wire_ports_methods, wire_ports_metamethods = SF.Typedef("Ports")

function wire_ports_metamethods:__index(name)
	SF.CheckType(name,"string")
	local instance = SF.instance
	local ent = instance.data.entity
	if not ent then SF.throw( "No entity", 2 ) end

	local input = ent.Inputs[name]
	if not (input and input.Src and input.Src:IsValid()) then
		return nil
	end
	return inputConverters[ent.Inputs[name].Type](ent.Inputs[name].Value)
end

function wire_ports_metamethods:__newindex(name,value)
	SF.CheckType(name,"string")
	local instance = SF.instance
	local ent = instance.data.entity
	if not ent then SF.throw( "No entity", 2 ) end

	local output = ent.Outputs[name]
	if not output then return end

	Wire_TriggerOutput(ent, name, outputConverters[output.Type](value))
end

--- Ports table. Reads from this table will read from the wire input
-- of the same name. Writes will write to the wire output of the same name.
-- @class table
-- @name wire_library.ports
wire_library.ports = setmetatable({},wire_ports_metamethods)

-- ------------------------- Hook Documentation ------------------------- --

--- Called when an input on a wired SF chip is written to
-- @name input
-- @class hook
-- @param input The input name
-- @param value The value of the input

--- Called when a high speed device reads from a wired SF chip
-- @name readcell
-- @class hook
-- @server
-- @param address The address requested
-- @return The value read

--- Called when a high speed device writes to a wired SF chip
-- @name writecell
-- @class hook
-- @param address The address written to
-- @param data The data being written


text:
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch.xsd">

<job id="helloJob" parent="parentJob" incrementer="vsbJobParametersIncrementer"
         xmlns="http://www.springframework.org/schema/batch">
        <step id="hello">
            <tasklet ref="helloTasklet"/>
        </step>
    </job>

</beans>


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

using Xyglo.Friendlier;

namespace Xyglo.Brazil.Xna
{
    /// <summary>
    /// A XygloFile preview when dragging a file around
    /// </summary>
    public class XygloFile : XygloXnaDrawableShape
    {

        /// <summary>
        /// Alpha Blend text
        /// </summary>
        protected bool m_alphaBlendingTest = true;

        /// <summary>
        /// Save our local SpriteBatch
        /// </summary>
        protected SpriteBatch m_spriteBatch;

        /// <summary>
        /// The overall FontManager
        /// </summary>
        protected FontManager m_fontManager;

        /// <summary>
        /// Store the text
        /// </summary>
        protected string m_text;

        /// <summary>
        /// Size of the font we're using
        /// </summary>
        XygloView.ViewSize m_fontSize = XygloView.ViewSize.Medium;

        /// <summary>
        /// The offset at which we've grabbed this piece of text (for example)
        /// </summary>
        Vector3 m_pickupOffset = Vector3.Zero;

        /// <summary>
        /// The first row of the text we're displayed could be indented - allow for this
        /// </summary>
        protected int m_firstRowIndent = 0;

        /// <summary>
        /// A XygloFile constructor
        /// </summary>
        /// <param name="colour"></param>
        /// <param name="effect"></param>
        /// <param name="position"></param>
        public XygloFile(Color colour, BasicEffect effect, Vector3 position)
        {
            m_colour = colour;
            m_effect = effect;
            m_position = position;

            if (m_alphaBlendingTest) m_colour.A = 10;
        }

        /// <summary>
        /// Another XygloFile constructor
        /// </summary>
        /// <param name="fontManager"></param>
        /// <param name="spriteBatch"></param>
        /// <param name="colour"></param>
        /// <param name="effect"></param>
        /// <param name="position"></param>
        /// <param name="viewFontSize"></param>
        /// <param name="text"></param>
        /// <param name="firstRowIndent"></param>
        public XygloFile(FontManager fontManager, SpriteBatch spriteBatch, Color colour, BasicEffect effect, Vector3 position, XygloView.ViewSize viewFontSize, string text, int firstRowIndent)
        {
            m_fontSize = viewFontSize;
            m_fontManager = fontManager;
            m_spriteBatch = spriteBatch;
            m_text = text;

            // Store the effect
            //
            m_effect = effect;
            m_colour = colour;
            m_position = position;
            m_firstRowIndent = firstRowIndent;

            if (m_alphaBlendingTest) m_colour.A = 10;
        }

        /// <summary>
        /// Add a menu option
        /// </summary>
        /// <param name="item"></param>
        public void setText(string text)
        {
            m_text = text;
        }

        /// <summary>
        /// Set the pickup offset to ensure alignment
        /// </summary>
        /// <param name="offset"></param>
        public void setPickupOffset(Vector3 offset)
        {
            m_pickupOffset = offset;
        }

        /// <summary>
        /// Build the shape and populate the Vertex and Index buffers.  Needs to be called after any change
        /// to position.
        /// </summary>
        /// <param name="device"></param>
        public override void buildBuffers(GraphicsDevice device)
        {
        }

        /// <summary>
        /// Draw this XygloText
        /// </summary>
        /// <param name="device"></param>
        public override void draw(GraphicsDevice device, FillMode fillMode)
        {
            // Reenable the texture
            //
            m_effect.TextureEnabled = true;

            float textScale = 1.0f;

            m_spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.AnisotropicClamp, DepthStencilState.DepthRead, RasterizerState.CullNone, m_effect);

            if (m_text.Contains("\n"))
            {
                string[] splitText = m_text.Split('\n');
                for (int i = 0; i < splitText.Count(); i++)
                {
                    m_spriteBatch.DrawString(
                        m_fontManager.getViewFont(m_fontSize),
                        splitText[i],
                        new Vector2(m_position.X - m_pickupOffset.X - (i == 0 ? 0 : m_fontManager.getViewFont(m_fontSize).MeasureString("X").X * m_firstRowIndent),
                        m_position.Y + (i * m_fontManager.getViewFont(m_fontSize).LineSpacing) - m_pickupOffset.Y ),
                        m_colour,
                        0,
                        Vector2.Zero,
                        m_fontManager.getTextScale() * (float)textScale,
                        0,
                        0);
                }
            }
            else
            {
                m_spriteBatch.DrawString(
                    m_fontManager.getViewFont(m_fontSize),
                    m_text,
                    new Vector2(m_position.X - m_pickupOffset.X, m_position.Y - m_pickupOffset.Y),
                    m_colour,
                    0,
                    Vector2.Zero,
                    m_fontManager.getTextScale() * (float)textScale,
                    0,
                    0);
            }

            m_spriteBatch.End();
        }

        /// <summary>
        /// Draw a preview of this text
        /// </summary>
        /// <param name="device"></param>
        /// <param name="boundingBox"></param>
        public override void drawPreview(GraphicsDevice device, BoundingBox fullBoundingBox, BoundingBox previewBoundingBox, Texture2D texture)
        {
            double factor = (double)((previewBoundingBox.Max - previewBoundingBox.Min).Length()) / (double)((fullBoundingBox.Max - fullBoundingBox.Min).Length());

            // Reenable the texture
            //
            m_effect.TextureEnabled = true;
            m_spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.AnisotropicClamp, DepthStencilState.DepthRead, RasterizerState.CullNone, m_effect);

            if (m_text.Contains("\n"))
            {
                string[] splitText = m_text.Split('\n');
                for (int i = 0; i < splitText.Count(); i++)
                {
                    m_spriteBatch.DrawString(
                    m_fontManager.getViewFont(m_fontSize),
                    splitText[i],
                    new Vector2(previewBoundingBox.Min.X + (m_position.X - m_pickupOffset.X ) * (float)factor,
                                previewBoundingBox.Min.Y + (float)(m_position.Y * factor) + i * (m_fontManager.getViewFont(m_fontSize).LineSpacing - m_pickupOffset.Y) * (float)factor),
                    m_colour,
                    0,
                    Vector2.Zero,
                    Math.Max(m_fontManager.getTextScale() * (float)factor, 0.2f),
                    0,
                    0);
                }
            }
            else
            {
                m_spriteBatch.DrawString(
                    m_fontManager.getViewFont(m_fontSize),
                    m_text,
                    new Vector2(previewBoundingBox.Min.X + (float)(m_position.X * factor) - m_pickupOffset.X,
                                previewBoundingBox.Min.Y + (float)(m_position.Y * factor) - m_pickupOffset.Y),
                    m_colour,
                    0,
                    Vector2.Zero,
                    Math.Max(m_fontManager.getTextScale() * (float)factor, 0.2f),
                    0,
                    0);
            }
            m_spriteBatch.End();

        }

        /// <summary>
        /// Override the getBoundingBox call - examine vertex data and return a bounding box
        /// based on that.
        /// </summary>
        /// <returns></returns>
        public override BoundingBox getBoundingBox()
        {
            BoundingBox bb = new BoundingBox();

            bb.Min.X = m_position.X;
            bb.Max.X = bb.Min.X + (m_text.Length * m_fontManager.getViewFont(m_fontSize).MeasureString("X").X);
            bb.Min.Y = m_position.Y;
            bb.Max.Y = bb.Min.Y + m_fontManager.getViewFont(m_fontSize).LineSpacing; // allow for line breaks !!!!!
            bb.Min.Z = m_position.Z;
            bb.Max.Z = bb.Min.Z;

            return bb;
        }

        /// <summary>
        /// Polygons in this item - see this:
        ///
        /// http://xboxforums.create.msdn.com/forums/p/23549/126997.aspx
        /// </summary>
        /// <returns></returns>
        public override int getPolygonCount()
        {
            return m_indices.Count() / 3;
        }
    }
}


text:
<!DOCTYPE html>

 <meta charset="UTF-8">

<title>SimulateDixonSignal—Wolfram Language Documentation</title>
<meta name="buildnumber" content="0000000" />
<meta name="historydata" content="{XX, , , }" />
<meta name="keywords" content="SimulateDixonSignal" />

<meta name="description" content="SimulateDixonSignal[echo, fr, B$0, T$2] simulates an Dixon gradient echo sequence with echotimes. Echotimes echo in ms, fat fraction fr between 0 and 1, field of resonance B0 in Hz and relaxation T2 in ms." />

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

<link rel="stylesheet" href="../css/reference.css" />

            <link rel="stylesheet" href="../css/clipboard.css" />

   Q M R I TOOLS PACKAGE SYMBOL

SimulateDixonSignal

SimulateDixonSignal[echo, fr, B$0, T$2]
simulates an Dixon gradient echo sequence with echotimes. Echotimes echo in ms, fat fraction fr between 0 and 1, field of resonance B0 in Hz and relaxation T2 in ms.

DetailsDetails

The following options can be given:

       <col width="1%" />
       <col width="28%" />
       <col width="28%" />
       <col width="43%" />

DixonPrecessions	-1	DixonPrecessions is an options for DixonReconstruct. Defines the rotation of the signal {-1,1} default is -1.

DixonFieldStrength	3	DixonFieldStrength is an options for DixonReconstruct. Defines the fieldstrengths in Tesla on which the data was acquired.

DixonFrequencies	{{0}, {3.8, 3.4, 3.13, 2.67, 2.46, 1.92, 0.57, -0.6}}	DixonFrequencies is an options for DixonReconstruct. Defines the frequencies in ppm of the fat peaks being used.

DixonAmplitudes	{{1}, {0.089, 0.598, 0.047, 0.077, 0.052, 0.011, 0.035, 0.066}}	DixonAmplitudes is an options for DixonReconstruct. Defines the relative amplitudes of the fat peaks being used.


text:
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace OpenTK
{
    ///
    /// Provides information about the underlying OS and runtime.
    /// You must call <c>Toolkit.Init</c> before accessing members
    /// of this class.
    ///
    public sealed class Configuration
    {
        private static bool runningOnUnix, runningOnMacOS, runningOnLinux;
        private volatile static bool initialized;
        private readonly static object InitLock = new object();

        private Configuration() { }

        /// Gets a System.Boolean indicating whether OpenTK is running on a Windows platform.
        public static bool RunningOnWindows { get; private set; }

        /// Gets a System.Boolean indicating whether OpenTK is running on an X11 platform.
        public static bool RunningOnX11 { get; private set; }

        ///
        /// Gets a <see cref="System.Boolean"/> indicating whether OpenTK is running on a Unix platform.
        ///
        public static bool RunningOnUnix
        {
            get { return runningOnUnix; }
        }

        ///
        /// Gets a System.Boolean indicating whether OpenTK is running on the SDL2 backend.
        ///
        public static bool RunningOnSdl2
        {
            get;
            private set;
        }

        /// Gets a System.Boolean indicating whether OpenTK is running on the Linux kernel.
        public static bool RunningOnLinux { get { return runningOnLinux; } }

        /// Gets a System.Boolean indicating whether OpenTK is running on a MacOS platform.
        public static bool RunningOnMacOS { get { return runningOnMacOS; } }

        ///
        /// Gets a System.Boolean indicating whether OpenTK is running on the Mono runtime.
        ///
        public static bool RunningOnMono { get; private set; }

        ///
        /// Gets a <c>System.Boolean</c> indicating whether
        /// OpenTK is running on an Android device.
        ///
        public static bool RunningOnAndroid
        {
            get
            {
#if ANDROID
                return true;
#else
                return false;
#endif
            }
        }

        ///
        /// Gets a <c>System.Boolean</c> indicating whether
        /// OpenTK is running on an Android device.
        ///
        public static bool RunningOnIOS
        {
            get
            {
#if IPHONE
                return true;
#else
                return false;
#endif
            }
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct utsname
        {
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string sysname;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string nodename;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string release;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string version;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string machine;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 1024)]
            public string extraJustInCase;

        }

        ///
        /// Detects the unix kernel by p/invoking uname (libc).
        ///
        /// <returns></returns>
        private static string DetectUnixKernel()
        {
            Debug.Print("Size: {0}", Marshal.SizeOf(typeof(utsname)).ToString());
            Debug.Flush();
            utsname uts = new utsname();
            uname(out uts);

            Debug.WriteLine("System:");
            Debug.Indent();
            Debug.WriteLine(uts.sysname);
            Debug.WriteLine(uts.nodename);
            Debug.WriteLine(uts.release);
            Debug.WriteLine(uts.version);
            Debug.WriteLine(uts.machine);
            Debug.Unindent();

            return uts.sysname.ToString();
        }

        [DllImport("libc")]
        private static extern void uname(out utsname uname_struct);

        private static bool DetectMono()
        {
            // Detect the Mono runtime (code taken from http://mono.wikia.com/wiki/Detecting_if_program_is_running_in_Mono).
            Type t = Type.GetType("Mono.Runtime");
            return t != null;
        }

        #if SDL2
        private static bool DetectSdl2()
        {
            bool supported = false;

            // Detect whether SDL2 is supported
            // We require:
            // - SDL2 version 2.0.0 or higher (previous beta
            //   versions are not ABI-compatible)
            // - Successful SDL2 initialization (sometimes the
            //   binary exists but fails to initialize correctly)
            var version = new Platform.SDL2.Version();
            try
            {
                version = Platform.SDL2.SDL.Version;
                    if (version.Number >= 2000)
                {
                    if (Platform.SDL2.SDL.WasInit(0))
                    {
                        supported = true;
                    }
                    else
                    {
                        // Attempt to initialize SDL2.
                        var flags =
                            Platform.SDL2.SystemFlags.VIDEO |
                            Platform.SDL2.SystemFlags.TIMER;

                        if (Platform.SDL2.SDL.Init(flags) == 0)
                        {
                            supported = true;
                        }
                        else
                        {
                            Debug.Print("SDL2 init failed with error: {0}",
                                Platform.SDL2.SDL.GetError());
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Debug.Print("SDL2 init failed with exception: {0}", e);
            }

            if (!supported)
            {
                Debug.Print("SDL2 is not supported");
            }
            else
            {
                Debug.Print("SDL2 is supported. Version is {0}.{1}.{2}",
                    version.Major, version.Minor, version.Patch);
            }

            return supported;
        }
        #endif

        private static void DetectUnix(out bool unix, out bool linux, out bool macos)
        {
            unix = linux = macos = false;

            string kernel_name = DetectUnixKernel();
            switch (kernel_name)
            {
                case null:
                case "":
                    throw new PlatformNotSupportedException(
                        "Unknown platform. Please file a bug report at https://github.com/opentk/opentk/issues");

                case "Linux":
                    linux = unix = true;
                    break;

                case "Darwin":
                    macos = unix = true;
                    break;

                default:
                    unix = true;
                    break;
            }
        }

        private static bool DetectWindows()
        {
            return
                System.Environment.OSVersion.Platform == PlatformID.Win32NT ||
                System.Environment.OSVersion.Platform == PlatformID.Win32S ||
                System.Environment.OSVersion.Platform == PlatformID.Win32Windows ||
                System.Environment.OSVersion.Platform == PlatformID.WinCE;
        }

        private static bool DetectX11()
        {
            #if X11
            // Detect whether X is present.
            try { return OpenTK.Platform.X11.API.DefaultDisplay != IntPtr.Zero; }
            catch { return false; }
            #else
            return false;
            #endif
        }

        // Detects the underlying OS and runtime.
        internal static void Init(ToolkitOptions options)
        {
            lock (InitLock)
            {
                if (!initialized)
                {
#if ANDROID || IPHONE
                    RunningOnMono = true;
#else
                    RunningOnMono = DetectMono();
                    RunningOnWindows = DetectWindows();
                    if (!RunningOnWindows)
                    {
                        DetectUnix(out runningOnUnix, out runningOnLinux, out runningOnMacOS);
                    }

                    //if (options.Backend == PlatformBackend.Default)
                    //{
                    //    RunningOnSdl2 = DetectSdl2();
                    //}

                    if ((runningOnLinux && !RunningOnSdl2) || options.Backend == PlatformBackend.PreferX11)
                    {
                        RunningOnX11 = DetectX11();
                    }

                    initialized = true;
#endif
                    Debug.Print("Detected configuration: {0} / {1}",
                        RunningOnWindows ? "Windows" : RunningOnLinux ? "Linux" : RunningOnMacOS ? "MacOS" :
                        runningOnUnix ? "Unix" : RunningOnX11 ? "X11" : "Unknown Platform",
                        RunningOnMono ? "Mono" : ".Net");
                }
            }
        }
    }
}


text:
rm -rf *tar
rm -rf dlls-*
rm -rf out/ queries/
rm -rf *~
rm -rf pfdlls-*
(cd health-web; make clean)
(cd lookout; make clean)
(cd fine-continue; make clean)


text:
import subprocess
import re
import os
import time
import sh
import time
from docker_digitalocean_cassandra import *
from docker_digitalocean_webidentity import *
from docker_digitalocean_webapi import *

ssh_con_str = "root@67.205.147.105"

print "NOTICE: this script has to be run as a user with access to SSH keys."
print "Deployment to remote server (" + ssh_con_str + ") started."

ssh = sh.ssh.bake(ssh_con_str)

print "Successfully connected to remote server."

kill_and_remove_all_containers(ssh)

cassandra_container_id = start_cassandra_container(ssh)
print "Wait for cassandra to warm up."
time.sleep(20) # wait for cassandra to init.

print "Setup cassandra schema."
copy_cassandra_scripts_to_remote_host(cassandra_container_id, ssh_con_str)
copy_cassandra_scripts_to_docker_container(ssh, cassandra_container_id)
run_cassandra_migration_scripts_in_docker_container(ssh, cassandra_container_id)

print "Stop cassandra."
ssh("docker stop biketimer-web-database")

copy_webidentity_src_to_remote_host(ssh_con_str)
build_webidentity_continer_in_remote_host(ssh)

copy_webapi_src_to_remote_host(ssh_con_str)
build_webapi_continer_in_remote_host(ssh)

print "Start cassandra."
ssh("docker start biketimer-web-database")
print "Wait for cassandra to warm up."
time.sleep(20)

print "Start webapi."
run_webapi_container(ssh)

print "Start webidentity."
run_webidentity_container(ssh)


text:
package org.wso2.carbon.apimgt.rest.api.store.dto;

import org.wso2.carbon.apimgt.rest.api.store.dto.TokenDTO;
import java.util.*;

import io.swagger.annotations.*;
import com.fasterxml.jackson.annotation.JsonProperty;

import javax.validation.constraints.NotNull;

@ApiModel(description = "")
public class ApplicationKeyDTO  {

  private String consumerKey = null;

  private String consumerSecret = null;

  private List<String> supportedGrantTypes = new ArrayList<String>();

  private String keyState = null;

  public enum KeyTypeEnum {
     PRODUCTION,  SANDBOX,
  };

  private KeyTypeEnum keyType = null;

  private TokenDTO token = null;

  /**
   * Consumer key of the application
   **/
  @ApiModelProperty(value = "Consumer key of the application")
  @JsonProperty("consumerKey")
  public String getConsumerKey() {
    return consumerKey;
  }
  public void setConsumerKey(String consumerKey) {
    this.consumerKey = consumerKey;
  }

  /**
   * Consumer secret of the application
   **/
  @ApiModelProperty(value = "Consumer secret of the application")
  @JsonProperty("consumerSecret")
  public String getConsumerSecret() {
    return consumerSecret;
  }
  public void setConsumerSecret(String consumerSecret) {
    this.consumerSecret = consumerSecret;
  }

  /**
   * Supported grant types for the application
   **/
  @ApiModelProperty(value = "Supported grant types for the application")
  @JsonProperty("supportedGrantTypes")
  public List<String> getSupportedGrantTypes() {
    return supportedGrantTypes;
  }
  public void setSupportedGrantTypes(List<String> supportedGrantTypes) {
    this.supportedGrantTypes = supportedGrantTypes;
  }

  /**
   * State of the key generation of the application
   **/
  @ApiModelProperty(value = "State of the key generation of the application")
  @JsonProperty("keyState")
  public String getKeyState() {
    return keyState;
  }
  public void setKeyState(String keyState) {
    this.keyState = keyState;
  }

  /**
   * Key type
   **/
  @ApiModelProperty(value = "Key type")
  @JsonProperty("keyType")
  public KeyTypeEnum getKeyType() {
    return keyType;
  }
  public void setKeyType(KeyTypeEnum keyType) {
    this.keyType = keyType;
  }

  /**
   * Token details object
   **/
  @ApiModelProperty(value = "Token details object")
  @JsonProperty("token")
  public TokenDTO getToken() {
    return token;
  }
  public void setToken(TokenDTO token) {
    this.token = token;
  }

  @Override
  public String toString()  {
    StringBuilder sb = new StringBuilder();
    sb.append("class ApplicationKeyDTO {\n");

    sb.append("  consumerKey: ").append(consumerKey).append("\n");
    sb.append("  consumerSecret: ").append(consumerSecret).append("\n");
    sb.append("  supportedGrantTypes: ").append(supportedGrantTypes).append("\n");
    sb.append("  keyState: ").append(keyState).append("\n");
    sb.append("  keyType: ").append(keyType).append("\n");
    sb.append("  token: ").append(token).append("\n");
    sb.append("}\n");
    return sb.toString();
  }
}


text:
namespace Tangram {

std::string PointLight::s_classBlock;
std::string PointLight::s_typeName = "PointLight";

PointLight::PointLight(const std::string& _name, bool _dynamic) :
    Light(_name, _dynamic),
    m_position(0.0),
    m_attenuation(0.0),
    m_innerRadius(0.0),
    m_outerRadius(0.0) {

    m_type = LightType::point;

}

PointLight::~PointLight() {

}

void PointLight::setPosition(const glm::vec3 &_pos) {
    m_position.x = _pos.x;
    m_position.y = _pos.y;
    m_position.z = _pos.z;
    m_position.w = 0.0;
}

void PointLight::setAttenuation(float _att){
    m_attenuation = _att;
}

void PointLight::setRadius(float _outer){
    m_innerRadius = 0.0;
    m_outerRadius = _outer;
}

void PointLight::setRadius(float _inner, float _outer){
    m_innerRadius = _inner;
    m_outerRadius = _outer;
}

void PointLight::setupProgram(const View& _view, ShaderProgram& _shader) {
    if (m_dynamic) {
        Light::setupProgram(_view, _shader);

        glm::vec4 position = m_position;

        if (m_origin == LightOrigin::world) {
            // For world origin, format is: [longitude, latitude, meters (default) or pixels w/px units]

            // Move light's world position into camera space
            glm::dvec2 camSpace = _view.getMapProjection().LonLatToMeters(glm::dvec2(m_position.x, m_position.y));
            position.x = camSpace.x - _view.getPosition().x;
            position.y = camSpace.y - _view.getPosition().y;
            position.z = position.z - _view.getPosition().z;

        } else if (m_origin == LightOrigin::ground) {
            // Leave light's xy in camera space, but z needs to be moved relative to ground plane
            position.z = position.z - _view.getPosition().z;
        }

        if (m_origin == LightOrigin::world || m_origin == LightOrigin::ground) {
            // Light position is a vector from the camera to the light in world space;
            // we can transform this vector into camera space the same way we would with normals
            position = _view.getViewMatrix() * position;
        }

        _shader.setUniformf(getUniformName()+".position", position);

        if (m_attenuation!=0.0) {
            _shader.setUniformf(getUniformName()+".attenuation", m_attenuation);
        }

        if (m_innerRadius!=0.0) {
            _shader.setUniformf(getUniformName()+".innerRadius", m_innerRadius);
        }

        if (m_outerRadius!=0.0) {
            _shader.setUniformf(getUniformName()+".outerRadius", m_outerRadius);
        }
    }
}

std::string PointLight::getClassBlock() {
    if (s_classBlock.empty()) {
        s_classBlock = stringFromResource("pointLight.glsl")+"\n";
    }
    return s_classBlock;
}

std::string PointLight::getInstanceDefinesBlock() {
    std::string defines = "";

    if (m_attenuation!=0.0) {
        defines += "#define TANGRAM_POINTLIGHT_ATTENUATION_EXPONENT\n";
    }

    if (m_innerRadius!=0.0) {
        defines += "#define TANGRAM_POINTLIGHT_ATTENUATION_INNER_RADIUS\n";
    }

    if (m_outerRadius!=0.0) {
        defines += "#define TANGRAM_POINTLIGHT_ATTENUATION_OUTER_RADIUS\n";
    }
    return defines;
}

std::string PointLight::getInstanceAssignBlock() {
    std::string block = Light::getInstanceAssignBlock();
    if (!m_dynamic) {
        block += ", " + glm::to_string(m_position);
        if (m_attenuation!=0.0) {
            block += ", " + std::to_string(m_attenuation);
        }
        if (m_innerRadius!=0.0) {
            block += ", " + std::to_string(m_innerRadius);
        }
        if (m_outerRadius!=0.0) {
            block += ", " + std::to_string(m_outerRadius);
        }
        block += ")";
    }
    return block;
}

const std::string& PointLight::getTypeName() {

    return s_typeName;

}

}


text:
import React, { PureComponent } from 'react'
import SplashScreenSVG from '../../images/splash-screen.svg'
import ccLogo from '../../images/cc-logo.png'

const HIDE_AFTER = 1800 // ms
// Note that transition duration has to match value in CSS file.
const TRANSITION_DURATION = 500 // ms
// If window is smaller than provided dimensions, apply scaling.
const MIN_HEIGHT = 700 // px
const MIN_WIDTH = 500 // px

function scale () {
  const height = window.innerHeight
  const width = window.innerWidth
  return Math.min(1, height / MIN_HEIGHT, width / MIN_WIDTH)
}

const mainContainerStyle = {
  position: 'fixed',
  left: 0,
  right: 0,
  top: 0,
  bottom: 0,
  width: '100%',
  height: '100%',
  zIndex: 100000,
  display: 'flex',
  justifyContent: 'center',
  alignItems: 'center',
  background: '#fff',
  fontSize: '25px'
}

const fadeOutStyle = {
  opacity: 0,
  transition: 'opacity 500ms'
}

const splashImgStyle = {
  width: '450px',
  height: 'auto',
  marginBottom: '30px',
  display: 'block'
}

const ccLogoStyle = {
  width: '250px',
  verticalAlign: 'middle'
}

export default class SplashScreen extends PureComponent {
  constructor (props) {
    super(props)
    this.state = {
      show: true,
      fadeOut: false,
      scale: scale()
    }
  }

  componentDidMount () {
    setTimeout(() => {
      this.setState({ fadeOut: true })
    }, HIDE_AFTER - TRANSITION_DURATION)
    setTimeout(() => {
      this.setState({ show: false })
    }, HIDE_AFTER)
  }

  render () {
    const { show, fadeOut, scale } = this.state
    if (!show) {
      return null
    }
    return (

        <div style={{ transform: `scale(${scale}, ${scale})` }}>
          <SplashScreenSVG style={splashImgStyle} />

a product of

    )
  }
}


text:
using Orchard.DynamicForms.Services.Models;

namespace Orchard.DynamicForms.Validators.Settings {
    public class TextFieldValidationSettings : ValidationSettingsBase {
        public bool? IsRequired { get; set; }
        public int? MinimumLength { get; set; }
        public int? MaximumLength { get; set; }
        public string ValidationExpression { get; set; }
    }
}


text: Bunch of sass helper classes


text:
input: <input id="input" /><button id="btn-input">set input</button>

textarea: <textarea id="text"></textarea>
<button id="btn-text">set area</button>


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace Facepunch.Steamworks
{
    /// <summary>
    /// Used to set up the server.
    /// The variables in here are all required to be set, and can't be changed once the server is created.
    /// </summary>
    public class ServerInit
    {
        public uint IpAddress = 0;
        public ushort SteamPort;
        public ushort GamePort = 27015;
        public ushort QueryPort = 27016;
        public bool Secure = true;

        /// <summary>
        /// The version string is usually in the form x.x.x.x, and is used by the master server to detect when the server is out of date.
        /// If you go into the dedicated server tab on steamworks you'll be able to server the latest version. If this version number is
        /// less than that latest version then your server won't show.
        /// </summary>
        public string VersionString = "2.0.0.0";

        /// <summary>
        /// This should be the same directory game where gets installed into. Just the folder name, not the whole path. I.e. "Rust", "Garrysmod".
        /// </summary>
        public string ModDir = "unset";

        /// <summary>
        /// The game description. Setting this to the full name of your game is recommended.
        /// </summary>
        public string GameDescription = "unset";

        public ServerInit( string modDir, string gameDesc )
        {
            ModDir = modDir;
            GameDescription = gameDesc;
        }

        /// <summary>
        /// Set the Steam quert port
        /// </summary>
        public ServerInit RandomSteamPort()
        {
            SteamPort = (ushort)new Random().Next( 10000, 60000 );
            return this;
        }

        /// <summary>
        /// If you pass MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE into usQueryPort, then it causes the game server API to use
        /// "GameSocketShare" mode, which means that the game is responsible for sending and receiving UDP packets for the master
        /// server updater.
        ///
        /// More info about this here: https://partner.steamgames.com/doc/api/ISteamGameServer#HandleIncomingPacket
        /// </summary>
        public ServerInit QueryShareGamePort()
        {
            QueryPort = 0xFFFF;
            return this;
        }
    }
}


text:
require 'webmock/rspec'
require 'metriks'
require 'metriks_addons/opentsdb_reporter'

describe "Smoke test" do
  before(:all) do
    stub_request(:any, "http://localhost:4242")
  end

  before(:each) do
    @registry = Metriks::Registry.new
    @reporter = MetriksAddons::OpenTSDBReporter.new(
      'http://localhost:4242',
      {:env => "test"},
      { :registry => @registry })
  end

  after(:each) do
    @reporter.stop
    @registry.stop
  end

  it "meter" do
    @registry.meter('meter.testing').mark
    datapoints = @reporter.get_datapoints
    expect(datapoints.size).to eql(5)
    expect(datapoints[0][:metric]).to eql("meter.testing.count")
    expect(datapoints[0][:value]).to eql(1)
    expect(datapoints[0][:tags]).to include(:env => "test")
    expect(datapoints[0][:timestamp]).not_to be_nil

    expect(datapoints[1][:metric]).to eql("meter.testing.one_minute_rate")
    expect(datapoints[1][:value]).not_to be_nil
    expect(datapoints[1][:tags]).to include(:env => "test")
    expect(datapoints[1][:timestamp]).not_to be_nil

    expect(datapoints[2][:metric]).to eql("meter.testing.five_minute_rate")
    expect(datapoints[2][:value]).to eql(0.0)
    expect(datapoints[2][:tags]).to include(:env => "test")
    expect(datapoints[2][:timestamp]).not_to be_nil

    expect(datapoints[3][:metric]).to eql("meter.testing.fifteen_minute_rate")
    expect(datapoints[3][:value]).to eql(0.0)
    expect(datapoints[3][:tags]).to include(:env => "test")
    expect(datapoints[3][:timestamp]).not_to be_nil

    expect(datapoints[4][:metric]).to eql("meter.testing.mean_rate")
    expect(datapoints[4][:value]).not_to be_nil
    expect(datapoints[4][:tags]).to include(:env => "test")
    expect(datapoints[4][:timestamp]).not_to be_nil
  end

  it "counter" do
    @registry.counter('counter.testing').increment
    datapoints = @reporter.get_datapoints
    expect(datapoints.size).to eql(1)
    expect(datapoints[0][:metric]).to eql("counter.testing.count")
    expect(datapoints[0][:value]).to eql(1)
    expect(datapoints[0][:tags]).to include(:env => "test")
    expect(datapoints[0][:timestamp]).not_to be_nil
  end

  it "timer" do
    @registry.timer('timer.testing').update(1.5)
    datapoints = @reporter.get_datapoints
    expect(datapoints.size).to eql(11)
    expect(datapoints[0][:metric]).to eql("timer.testing.count")
    expect(datapoints[0][:value]).to eql(1)
    expect(datapoints[0][:tags]).to include(:env => "test")
    expect(datapoints[0][:timestamp]).not_to be_nil

    expect(datapoints[1][:metric]).to eql("timer.testing.one_minute_rate")
    expect(datapoints[1][:value]).not_to be_nil
    expect(datapoints[1][:tags]).to include(:env => "test")
    expect(datapoints[1][:timestamp]).not_to be_nil

    expect(datapoints[2][:metric]).to eql("timer.testing.five_minute_rate")
    expect(datapoints[2][:value]).to eql(0.0)
    expect(datapoints[2][:tags]).to include(:env => "test")
    expect(datapoints[2][:timestamp]).not_to be_nil

    expect(datapoints[3][:metric]).to eql("timer.testing.fifteen_minute_rate")
    expect(datapoints[3][:value]).to eql(0.0)
    expect(datapoints[3][:tags]).to include(:env => "test")
    expect(datapoints[3][:timestamp]).not_to be_nil

    expect(datapoints[4][:metric]).to eql("timer.testing.mean_rate")
    expect(datapoints[4][:value]).not_to be_nil
    expect(datapoints[4][:tags]).to include(:env => "test")
    expect(datapoints[4][:timestamp]).not_to be_nil

    expect(datapoints[5][:metric]).to eql("timer.testing.min")
    expect(datapoints[5][:value]).not_to be_nil
    expect(datapoints[5][:tags]).to include(:env => "test")
    expect(datapoints[5][:timestamp]).not_to be_nil

    expect(datapoints[6][:metric]).to eql("timer.testing.max")
    expect(datapoints[6][:value]).not_to be_nil
    expect(datapoints[6][:tags]).to include(:env => "test")
    expect(datapoints[6][:timestamp]).not_to be_nil

    expect(datapoints[7][:metric]).to eql("timer.testing.mean")
    expect(datapoints[7][:value]).not_to be_nil
    expect(datapoints[7][:tags]).to include(:env => "test")
    expect(datapoints[7][:timestamp]).not_to be_nil

    expect(datapoints[8][:metric]).to eql("timer.testing.stddev")
    expect(datapoints[8][:value]).not_to be_nil
    expect(datapoints[8][:tags]).to include(:env => "test")
    expect(datapoints[8][:timestamp]).not_to be_nil

    expect(datapoints[9][:metric]).to eql("timer.testing.median")
    expect(datapoints[9][:value]).not_to be_nil
    expect(datapoints[9][:tags]).to include(:env => "test")
    expect(datapoints[9][:timestamp]).not_to be_nil

    expect(datapoints[10][:metric]).to eql("timer.testing.95th_percentile")
    expect(datapoints[10][:value]).not_to be_nil
    expect(datapoints[10][:tags]).to include(:env => "test")
    expect(datapoints[10][:timestamp]).not_to be_nil
  end

  it "histogram" do
    @registry.histogram('histogram.testing').update(1.5)
    datapoints = @reporter.get_datapoints
    expect(datapoints.size).to eql(7)
    expect(datapoints[0][:metric]).to eql("histogram.testing.count")
    expect(datapoints[0][:value]).to eql(1)
    expect(datapoints[0][:tags]).to include(:env => "test")
    expect(datapoints[0][:timestamp]).not_to be_nil

    expect(datapoints[1][:metric]).to eql("histogram.testing.min")
    expect(datapoints[1][:value]).not_to be_nil
    expect(datapoints[1][:tags]).to include(:env => "test")
    expect(datapoints[1][:timestamp]).not_to be_nil

    expect(datapoints[2][:metric]).to eql("histogram.testing.max")
    expect(datapoints[2][:value]).not_to be_nil
    expect(datapoints[2][:tags]).to include(:env => "test")
    expect(datapoints[2][:timestamp]).not_to be_nil

    expect(datapoints[3][:metric]).to eql("histogram.testing.mean")
    expect(datapoints[3][:value]).not_to be_nil
    expect(datapoints[3][:tags]).to include(:env => "test")
    expect(datapoints[3][:timestamp]).not_to be_nil

    expect(datapoints[4][:metric]).to eql("histogram.testing.stddev")
    expect(datapoints[4][:value]).not_to be_nil
    expect(datapoints[4][:tags]).to include(:env => "test")
    expect(datapoints[4][:timestamp]).not_to be_nil

    expect(datapoints[5][:metric]).to eql("histogram.testing.median")
    expect(datapoints[5][:value]).not_to be_nil
    expect(datapoints[5][:tags]).to include(:env => "test")
    expect(datapoints[5][:timestamp]).not_to be_nil

    expect(datapoints[6][:metric]).to eql("histogram.testing.95th_percentile")
    expect(datapoints[6][:value]).not_to be_nil
    expect(datapoints[6][:tags]).to include(:env => "test")
    expect(datapoints[6][:timestamp]).not_to be_nil
  end

  it "gauge" do
    @registry.gauge('gauge.testing') { 123 }
    datapoints = @reporter.get_datapoints
    expect(datapoints.size).to eql(1)
    expect(datapoints[0][:metric]).to eql("gauge.testing.value")
    expect(datapoints[0][:value]).to eql(123)
    expect(datapoints[0][:tags]).to include(:env => "test")
    expect(datapoints[0][:timestamp]).not_to be_nil
  end
end

describe "Rest Client" do
  before(:each) do
    @registry = Metriks::Registry.new
    @reporter = MetriksAddons::OpenTSDBReporter.new(
      'http://localhost:4242',
      {:env => "test"},
      { :registry => @registry, :batch_size => 3})
    stub_request(:post, "http://localhost:4242/api/put").
      with(:body => /^\[.*\]$/).
      to_return(:status => 200, :body => "", :headers => {})
  end

  it "Send a single metric" do
    @registry.counter('counter.testing').increment
    @reporter.submit @reporter.get_datapoints
    #TODO Also check body
    body = [{
      :metric => "counter.testing",
      :timestamp => 1438446900,
      :value => 1,
      :tags => { :env => "test"}}
    ]
    expect(a_request(:post, "http://localhost:4242/api/put")).to have_been_made
  end

  it "Send a three metric" do
    for i in 0..2 do
      @registry.counter("counter.testing.#{i}").increment
    end
    @reporter.submit @reporter.get_datapoints
    expect(a_request(:post, "http://localhost:4242/api/put")).to have_been_made
  end

  it "Send a four metric" do
    for i in 0..3 do
      @registry.counter("counter.testing.#{i}").increment
    end
    @reporter.submit @reporter.get_datapoints
    expect(a_request(:post, "http://localhost:4242/api/put")).to have_been_made.times(2)
  end

  it "Send a five metric" do
    for i in 0..4 do
      @registry.counter("counter.testing.#{i}").increment
    end
    @reporter.submit @reporter.get_datapoints
    expect(a_request(:post, "http://localhost:4242/api/put")).to have_been_made.times(2)
  end

  it "Send a six metric" do
    for i in 0..5 do
      @registry.counter("counter.testing.#{i}").increment
    end
    @reporter.submit @reporter.get_datapoints
    expect(a_request(:post, "http://localhost:4242/api/put")).to have_been_made.times(2)
  end

  it "Send a seven metric" do
    for i in 0..7 do
      @registry.counter("counter.testing.#{i}").increment
    end
    @reporter.submit @reporter.get_datapoints
    expect(a_request(:post, "http://localhost:4242/api/put")).to have_been_made.times(3)
  end
end


text:
package __redirected.org.stagemonitor.dispatcher;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * This class is injected into the bootstrap classpath and is used to share objects between classloaders.
 *
 * <p> The reason why this class is inside the __redirected package is because JBoss' ModuleClassLoader would otherwise
 * not load this class and throw a {@link ClassNotFoundException} when trying to access classes in normal packages from
 * the bootstrap classloader. </p>
 *
 * <p> See also https://github.com/jboss-modules/jboss-modules/blob/master/src/main/java/org/jboss/modules/Module.java#L92
 * </p>
 */
public class Dispatcher {

	private static ConcurrentMap<String, Object> values = new ConcurrentHashMap<String, Object>();

	/**
	 * Add a value to the shared map
	 *
	 * @param key   the key that can be used to retrieve the value via {@link #get(String)}
	 * @param value the object to share
	 */
	public static void put(String key, Object value) {
		values.put(key, value);
	}

	/**
	 * Gets a shared value by it's key
	 *
	 * <p> Automatically casts the value to the desired type </p>
	 *
	 * @param key the key
	 * @param <T> the type of the value
	 * @return the shared value
	 */
	@SuppressWarnings("unchecked")
	public static <T> T get(String key) {
		return (T) values.get(key);
	}

	/**
	 * Gets a shared value by it's key
	 *
	 * <p> Automatically casts the value to the desired type </p>
	 *
	 * @param key        the key
	 * @param valueClass the class of the value
	 * @param <T>        the type of the value
	 * @return the shared value
	 */
	@SuppressWarnings("unchecked")
	public static <T> T get(String key, Class<T> valueClass) {
		return (T) values.get(key);
	}

	/**
	 * Gets a shared value by it's key
	 *
	 * @param key the key
	 * @return the shared value
	 */
	public static Object getObject(String key) {
		return values.get(key);
	}

	/**
	 * Returns the underlying {@link ConcurrentMap}
	 *
	 * @return the underlying {@link ConcurrentMap}
	 */
	public static ConcurrentMap<String, Object> getValues() {
		return values;
	}

	/**
	 * This utility method can be used to check whether a certain object can be loaded by the current thread's context
	 * class loader
	 *
	 * <p> In other words, it check if the following condition returns true: </p>
	 * <pre>{@code
	 * Thread.currentThread().getContextClassLoader().loadClass(o.getClass().getName()) == clazz
	 * }</pre>
	 *
	 * This can be useful to check if the provided object belongs to the current application
	 */
	public static boolean isVisibleToCurrentContextClassLoader(Object o) {
		return isVisibleTo(o, Thread.currentThread().getContextClassLoader());
	}

	public static boolean isVisibleTo(Object o, ClassLoader cl) {
		return o != null && isVisibleTo(o.getClass(), cl);
	}

	public static boolean isVisibleTo(Class<?> clazz, ClassLoader cl) {
		if (cl == null) {
			cl = ClassLoader.getSystemClassLoader();
		}
		try {
			return cl.loadClass(clazz.getName()) == clazz;
		} catch (ClassNotFoundException e) {
			return false;
		}
	}

}


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

using ILRuntime.CLR.Method;

namespace ILRuntime.Runtime.Intepreter.OpCodes
{

    /// <summary>
    /// IL指令
    /// </summary>
    struct OpCode
    {
        /// <summary>
        /// 当前指令
        /// </summary>
        public OpCodeEnum Code;

        /// <summary>
        ///  Int32 操作数
        /// </summary>
        public int TokenInteger;

        /// <summary>
        /// Int64 操作数
        /// </summary>
        public long TokenLong;
    }
}


text:
package ecs

//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
)

// DescribeSnapshotsUsage invokes the ecs.DescribeSnapshotsUsage API synchronously
func (client *Client) DescribeSnapshotsUsage(request *DescribeSnapshotsUsageRequest) (response *DescribeSnapshotsUsageResponse, err error) {
	response = CreateDescribeSnapshotsUsageResponse()
	err = client.DoAction(request, response)
	return
}

// DescribeSnapshotsUsageWithChan invokes the ecs.DescribeSnapshotsUsage API asynchronously
func (client *Client) DescribeSnapshotsUsageWithChan(request *DescribeSnapshotsUsageRequest) (<-chan *DescribeSnapshotsUsageResponse, <-chan error) {
	responseChan := make(chan *DescribeSnapshotsUsageResponse, 1)
	errChan := make(chan error, 1)
	err := client.AddAsyncTask(func() {
		defer close(responseChan)
		defer close(errChan)
		response, err := client.DescribeSnapshotsUsage(request)
		if err != nil {
			errChan <- err
		} else {
			responseChan <- response
		}
	})
	if err != nil {
		errChan <- err
		close(responseChan)
		close(errChan)
	}
	return responseChan, errChan
}

// DescribeSnapshotsUsageWithCallback invokes the ecs.DescribeSnapshotsUsage API asynchronously
func (client *Client) DescribeSnapshotsUsageWithCallback(request *DescribeSnapshotsUsageRequest, callback func(response *DescribeSnapshotsUsageResponse, err error)) <-chan int {
	result := make(chan int, 1)
	err := client.AddAsyncTask(func() {
		var response *DescribeSnapshotsUsageResponse
		var err error
		defer close(result)
		response, err = client.DescribeSnapshotsUsage(request)
		callback(response, err)
		result <- 1
	})
	if err != nil {
		defer close(result)
		callback(nil, err)
		result <- 0
	}
	return result
}

// DescribeSnapshotsUsageRequest is the request struct for api DescribeSnapshotsUsage
type DescribeSnapshotsUsageRequest struct {
	*requests.RpcRequest
	ResourceOwnerId      requests.Integer `position:"Query" name:"ResourceOwnerId"`
	ResourceOwnerAccount string           `position:"Query" name:"ResourceOwnerAccount"`
	OwnerAccount         string           `position:"Query" name:"OwnerAccount"`
	OwnerId              requests.Integer `position:"Query" name:"OwnerId"`
}

// DescribeSnapshotsUsageResponse is the response struct for api DescribeSnapshotsUsage
type DescribeSnapshotsUsageResponse struct {
	*responses.BaseResponse
	SnapshotSize  int64  `json:"SnapshotSize" xml:"SnapshotSize"`
	RequestId     string `json:"RequestId" xml:"RequestId"`
	SnapshotCount int    `json:"SnapshotCount" xml:"SnapshotCount"`
}

// CreateDescribeSnapshotsUsageRequest creates a request to invoke DescribeSnapshotsUsage API
func CreateDescribeSnapshotsUsageRequest() (request *DescribeSnapshotsUsageRequest) {
	request = &DescribeSnapshotsUsageRequest{
		RpcRequest: &requests.RpcRequest{},
	}
	request.InitWithApiInfo("Ecs", "2014-05-26", "DescribeSnapshotsUsage", "ecs", "openAPI")
	request.Method = requests.POST
	return
}

// CreateDescribeSnapshotsUsageResponse creates a response to parse from DescribeSnapshotsUsage response
func CreateDescribeSnapshotsUsageResponse() (response *DescribeSnapshotsUsageResponse) {
	response = &DescribeSnapshotsUsageResponse{
		BaseResponse: &responses.BaseResponse{},
	}
	return
}


text:
var context = new AudioContext();
var request = new XMLHttpRequest();
var audioBuffer;

request.open('GET', '../audio/success.mp3', true);
request.responseType = 'arraybuffer';

request.onload = function () {
    context.decodeAudioData(request.response, function (decodedAudioBuffer) {
        audioBuffer = decodedAudioBuffer;
    });
};

request.send();

var playAudioFile = function () {
    var source = context.createBufferSource();

    source.buffer = audioBuffer;
    source.connect(context.destination);
    source.start(context.currentTime);
};

var myFakeAjaxCall = function (callback) {
    setTimeout(function () {
        callback();
    }, 3000);
};

$('#buy-now-button').click(function () {
    var $btn = $(this).button('loading');

    myFakeAjaxCall(function () {
        playAudioFile();
        $btn.button('complete');
    });
});


text:
package org.bedoing;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class FacadeBoot {

	public static void main(String[] args) {
		SpringApplication.run(FacadeBoot.class, args);
	}
}


text:
Let's define some models (we'll assume we've loaded the vars user, feed, offers):

    Templates.model('user', user);
    Templates.model('feed', feed);
    Templates.model('offers', offers);

then let's define a simplistic view, 'feed':

    {{strings.sitename}} : {{strings.tagline}}

        {{config.privacy_policy_url}}
        {{config.terms_of_service_url}}
        {{config.help_url}}
        {{config.about_url}}

{{strings.feed}}

        {{#models "feed"}}

{{model ":subject"}}

                {{model ":name"}} {{model ":role"}}

                    {{model ":body"}}

        {{/models}}

        {{#models "offers"}}

        {{/models}}

        {{config.privacy_policy_url}}
        {{config.terms_of_service_url}}
        {{config.help_url}}
        {{config.about_url}}

then let's create an instance of that view (assuming we have a 'strings' var and a 'config var') and attach it to the body:

    var common = {string:strings, config:config};
    var view = Template.createView('feed', common, document.body);


text:
class Person < ActiveRecord::Base
  attr_accessible :avatar, :birthDate, :height, :name, :programmer, :objectId

  def objectId
    read_attribute(:id).to_s
  end

  def as_json(options={})
    options.merge!({:except => [:id]})
    result = super.as_json(options)
    resul = result.merge({:objectId => self.objectId})
  end
end


text:
-- MySQL dump 10.13  Distrib 5.1.48, for apple-darwin10.3.0 (i386)
--
-- Host: localhost    Database: mdb
-- ------------------------------------------------------
-- Server version	5.1.48

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `BUCKETING_COLS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `BUCKETING_COLS` (
  `SD_ID` bigint(20) NOT NULL,
  `BUCKET_COL_NAME` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `INTEGER_IDX` int(11) NOT NULL,
  PRIMARY KEY (`SD_ID`,`INTEGER_IDX`),
  KEY `BUCKETING_COLS_N49` (`SD_ID`),
  CONSTRAINT `BUCKETING_COLS_FK1` FOREIGN KEY (`SD_ID`) REFERENCES `SDS` (`SD_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `COLUMNS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `COLUMNS` (
  `SD_ID` bigint(20) NOT NULL,
  `COMMENT` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `COLUMN_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `TYPE_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `INTEGER_IDX` int(11) NOT NULL,
  PRIMARY KEY (`SD_ID`,`COLUMN_NAME`,`TYPE_NAME`),
  KEY `COLUMNS_N49` (`SD_ID`),
  CONSTRAINT `COLUMNS_FK1` FOREIGN KEY (`SD_ID`) REFERENCES `SDS` (`SD_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `PARTITIONS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `PARTITIONS` (
  `PART_ID` bigint(20) NOT NULL,
  `CREATE_TIME` int(11) NOT NULL,
  `LAST_ACCESS_TIME` int(11) NOT NULL,
  `PART_NAME` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `SD_ID` bigint(20) DEFAULT NULL,
  `TBL_ID` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`PART_ID`),
  UNIQUE KEY `UNIQUEPARTITION` (`PART_NAME`,`TBL_ID`),
  KEY `PARTITIONS_N49` (`SD_ID`),
  KEY `PARTITIONS_N50` (`TBL_ID`),
  CONSTRAINT `PARTITIONS_FK2` FOREIGN KEY (`TBL_ID`) REFERENCES `TBLS` (`TBL_ID`),
  CONSTRAINT `PARTITIONS_FK1` FOREIGN KEY (`SD_ID`) REFERENCES `SDS` (`SD_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `PARTITION_KEYS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `PARTITION_KEYS` (
  `TBL_ID` bigint(20) NOT NULL,
  `PKEY_COMMENT` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `PKEY_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `PKEY_TYPE` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `INTEGER_IDX` int(11) NOT NULL,
  PRIMARY KEY (`TBL_ID`,`PKEY_NAME`),
  KEY `PARTITION_KEYS_N49` (`TBL_ID`),
  CONSTRAINT `PARTITION_KEYS_FK1` FOREIGN KEY (`TBL_ID`) REFERENCES `TBLS` (`TBL_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `PARTITION_KEY_VALS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `PARTITION_KEY_VALS` (
  `PART_ID` bigint(20) NOT NULL,
  `PART_KEY_VAL` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `INTEGER_IDX` int(11) NOT NULL,
  PRIMARY KEY (`PART_ID`,`INTEGER_IDX`),
  KEY `PARTITION_KEY_VALS_N49` (`PART_ID`),
  CONSTRAINT `PARTITION_KEY_VALS_FK1` FOREIGN KEY (`PART_ID`) REFERENCES `PARTITIONS` (`PART_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `PARTITION_PARAMS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `PARTITION_PARAMS` (
  `PART_ID` bigint(20) NOT NULL,
  `PARAM_KEY` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `PARAM_VALUE` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`PART_ID`,`PARAM_KEY`),
  KEY `PARTITION_PARAMS_N49` (`PART_ID`),
  CONSTRAINT `PARTITION_PARAMS_FK1` FOREIGN KEY (`PART_ID`) REFERENCES `PARTITIONS` (`PART_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `SDS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `SDS` (
  `SD_ID` bigint(20) NOT NULL,
  `INPUT_FORMAT` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `IS_COMPRESSED` bit(1) NOT NULL,
  `LOCATION` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `NUM_BUCKETS` int(11) NOT NULL,
  `OUTPUT_FORMAT` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `SERDE_ID` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`SD_ID`),
  KEY `SDS_N49` (`SERDE_ID`),
  CONSTRAINT `SDS_FK1` FOREIGN KEY (`SERDE_ID`) REFERENCES `SERDES` (`SERDE_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `SD_PARAMS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `SD_PARAMS` (
  `SD_ID` bigint(20) NOT NULL,
  `PARAM_KEY` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `PARAM_VALUE` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`SD_ID`,`PARAM_KEY`),
  KEY `SD_PARAMS_N49` (`SD_ID`),
  CONSTRAINT `SD_PARAMS_FK1` FOREIGN KEY (`SD_ID`) REFERENCES `SDS` (`SD_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `SERDES`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `SERDES` (
  `SERDE_ID` bigint(20) NOT NULL,
  `NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `SLIB` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`SERDE_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `SERDE_PARAMS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `SERDE_PARAMS` (
  `SERDE_ID` bigint(20) NOT NULL,
  `PARAM_KEY` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `PARAM_VALUE` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`SERDE_ID`,`PARAM_KEY`),
  KEY `SERDE_PARAMS_N49` (`SERDE_ID`),
  CONSTRAINT `SERDE_PARAMS_FK1` FOREIGN KEY (`SERDE_ID`) REFERENCES `SERDES` (`SERDE_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `SORT_COLS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `SORT_COLS` (
  `SD_ID` bigint(20) NOT NULL,
  `COLUMN_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `ORDER` int(11) NOT NULL,
  `INTEGER_IDX` int(11) NOT NULL,
  PRIMARY KEY (`SD_ID`,`INTEGER_IDX`),
  KEY `SORT_COLS_N49` (`SD_ID`),
  CONSTRAINT `SORT_COLS_FK1` FOREIGN KEY (`SD_ID`) REFERENCES `SDS` (`SD_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `TABLE_PARAMS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `TABLE_PARAMS` (
  `TBL_ID` bigint(20) NOT NULL,
  `PARAM_KEY` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `PARAM_VALUE` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`TBL_ID`,`PARAM_KEY`),
  KEY `TABLE_PARAMS_N49` (`TBL_ID`),
  CONSTRAINT `TABLE_PARAMS_FK1` FOREIGN KEY (`TBL_ID`) REFERENCES `TBLS` (`TBL_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `TBLS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `TBLS` (
  `TBL_ID` bigint(20) NOT NULL,
  `CREATE_TIME` int(11) NOT NULL,
  `DB_ID` bigint(20) DEFAULT NULL,
  `LAST_ACCESS_TIME` int(11) NOT NULL,
  `OWNER` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `RETENTION` int(11) NOT NULL,
  `SD_ID` bigint(20) DEFAULT NULL,
  `TBL_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`TBL_ID`),
  UNIQUE KEY `UNIQUETABLE` (`TBL_NAME`,`DB_ID`),
  KEY `TBLS_N50` (`SD_ID`),
  KEY `TBLS_N49` (`DB_ID`),
  CONSTRAINT `TBLS_FK1` FOREIGN KEY (`DB_ID`) REFERENCES `DBS` (`DB_ID`),
  CONSTRAINT `TBLS_FK2` FOREIGN KEY (`SD_ID`) REFERENCES `SDS` (`SD_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `TYPE_FIELDS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `TYPE_FIELDS` (
  `TYPE_NAME` bigint(20) NOT NULL,
  `COMMENT` varchar(256) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `FIELD_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `FIELD_TYPE` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `INTEGER_IDX` int(11) NOT NULL,
  PRIMARY KEY (`TYPE_NAME`,`FIELD_NAME`),
  KEY `TYPE_FIELDS_N49` (`TYPE_NAME`),
  CONSTRAINT `TYPE_FIELDS_FK1` FOREIGN KEY (`TYPE_NAME`) REFERENCES `TYPES` (`TYPES_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `DBS`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `DBS` (
  `DB_ID` bigint(20) NOT NULL,
  `DESC` varchar(767) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`DB_ID`),
  UNIQUE KEY `UNIQUE_DATABASE` (`NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `SEQUENCE_TABLE`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `SEQUENCE_TABLE` (
  `SEQUENCE_NAME` varchar(255) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `NEXT_VAL` bigint(20) NOT NULL,
  PRIMARY KEY (`SEQUENCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `NUCLEUS_TABLES`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `NUCLEUS_TABLES` (
  `CLASS_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `TABLE_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `TYPE` varchar(4) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `OWNER` varchar(2) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `VERSION` varchar(20) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL,
  `INTERFACE_NAME` varchar(255) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`CLASS_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Table structure for table `TYPES`
--

/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE IF NOT EXISTS `TYPES` (
  `TYPES_ID` bigint(20) NOT NULL,
  `TYPE_NAME` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `TYPE1` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  `TYPE2` varchar(128) CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL,
  PRIMARY KEY (`TYPES_ID`),
  UNIQUE KEY `UNIQUE_TYPE` (`TYPE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

-- Dump completed on 2011-03-14 15:30:07


text:
class AddDeliveryTimeToOrders < ActiveRecord::Migration
  def up
    add_column :spree_orders, :delivery_time, :string
  end

  def down
    remove_column :spree_orders, :delivery_time
  end
end


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.jetbrains.idea</groupId>
    <artifactId>parent.eleven.1114</artifactId>
    <version>11.1.4</version>
    <relativePath>../../pom.xml</relativePath>
  </parent>

  <artifactId>xml-openapi</artifactId>

  <name>Maven Integration of xml-openapi modul</name>
  <description>Maven modul for xml-openapi jar</description>

  <dependencies>
    <dependency>
      <groupId>org.jetbrains.idea</groupId>
      <artifactId>lang-api</artifactId>
    </dependency>
  </dependencies>

  <build>
    <sourceDirectory>${idea.home}/xml/openapi/src</sourceDirectory>
  </build>
</project>


text:
#include "mock/tcpci_i2c_mock.h"
#include "task.h"
#include "tcpm/tcpci.h"
#include "test_util.h"
#include "timer.h"
#include "usb_tcpmv2_compliance.h"
#include "usb_tc_sm.h"

/*****************************************************************************
 * TD.PD.LL.E4. Hard Reset Usage
 *
 * Description:
 *	Check that the UUT will issue a Soft Reset after unsuccessful retries,
 *	and that the link can be successfully recovered after that.
 *	Check that the UUT will issue a Hard Reset if the Soft Reset fails,
 *	and that the link can be successfully recovered after that.
 */
static int td_pd_ll_e4(enum pd_data_role data_role)
{
	int retries;

	partner_set_pd_rev(PD_REV20);

	TEST_EQ(tcpci_startup(), EC_SUCCESS, "%d");

	/*
	 * a) Run PROC.PD.E1 Bring-up according to the UUT role.
	 */
	TEST_EQ(proc_pd_e1(data_role, INITIAL_AND_ALREADY_ATTACHED), EC_SUCCESS,
		"%d");

	/*
	 * Make sure we are idle. Reject everything that is pending
	 */
	TEST_EQ(handle_attach_expected_msgs(data_role), EC_SUCCESS, "%d");

	/*
	 * b) Send a Get_Sink_Cap message to the UUT, wait for a reply
	 *    and do not send GoodCrc for nRetryCount + 1 times
	 *    (nRetryCount equals 3 since PD 2.1).
	 */
	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_GET_SINK_CAP, 0, 0, NULL);

	retries = 3;
	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_SOP, 0, PD_DATA_SINK_CAP,
					    retries),
		EC_SUCCESS, "%d");
	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);

	/*
	 * c) Wait the nRetryCount + 1 (four) Soft Resets from the UUT and do
	 *    not reply GoodCrc.
	 */
	retries = 3;
	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET,
					    0, retries),
		EC_SUCCESS, "%d");
	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);
	task_wait_event(1 * MSEC);

	/*
	 * d) Check that the UUT issues a Hard Reset.
	 */
	TEST_EQ(mock_tcpci_get_reg(TCPC_REG_TRANSMIT), TCPCI_MSG_TX_HARD_RESET,
		"%d");
	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS | TCPC_REG_ALERT_TX_FAILED);
	mock_tcpci_set_reg(TCPC_REG_TRANSMIT, 0);
	task_wait_event(1 * MSEC);

	/*
	 * e) Do the bring-up procedure for Link tests and check that the link
	 *    is successfully established.
	 */
	TEST_EQ(proc_pd_e1(data_role, ALREADY_ATTACHED), EC_SUCCESS, "%d");

	return EC_SUCCESS;
}
int test_td_pd_ll_e4_dfp(void)
{
	return td_pd_ll_e4(PD_ROLE_DFP);
}
int test_td_pd_ll_e4_ufp(void)
{
	return td_pd_ll_e4(PD_ROLE_UFP);
}


text:
layout: contato
pageTitle: FILTRO CENTRAL DE ÁGUA |FABRICA |PUREWATER EFLUENTES
title: Filtro Central de Água
subtitle: Filtro de Água Industrial - Fiberglass (PRFV)
---

<img class="img-responsive pull-right" style="max-width: 52%;" src="../../website/images/cyber_tank.jpg" alt="Filtro de Agua em Fiberglass">

### Comprar Filtro de Água, Encontre Aqui.

### Filtro Central de Água

- O cilindro de pressão do filtro central de água **PRFV** é fabricado com alta tecnologia e material composto por fiberglass (PRFV), de enrolamento filamentar e resina polivinilica de alta resistência química e física.

- Todos os tanques de pressão, residenciais e comerciais, são feitos por uma tecnologia de moldagem por completo sem costura.

- Todas as entradas de rosca são feitas de 30% de fibra de vidro e cheio com PP (Polipropileno), oque fornece maior força e resistência a temperatura e pressão.

- Espessura da parede do forro disponível a partir de 3.0 a 7.6 mm, proporcionalmente correspondente ao diâmetro do tanque.

- São fornecidos em diâmetros de tanque de pressão de 6" a 48" de diâmetro e a partir de 10" a 72" de altura.

- Com abertura do bocal superior disponível com medidas de 6 "a 36" de diâmetro.

- Os filtros fabricados em PRFV reforçado possuem um terço do peso dos filtros em aço carbono ou inox.

- Todos os tanques de pressão em PRFV apresentam resistência de 100% à corrosão.

### Dados de Operação do Filtro Central de Água

- Pressão de operação: Máximo 150 psi (10.5 Bar)
- Temperatura maxima de operação: 49ºC

### Elementos de Filtragem disponíveis

O **Filtro de Água Central - Industrial** poderá ser montado nas seguintes configurações de cargas:

- Total de areia quartzo 98% de pureza
- Total de carvão ativado granulado
- Carga mista areia quartzo e carvão ativo
- Zeólito natural (Clinoptilolita é classificada como óxido mineral cristalino de alumínio e sílica), alta eficiência em filtragem.

### Funções e benefícios do Filtro Central de água

- Retém areia, argila, ferrugem e outros sedimentos em suspensão.
- Reduz os excessos de cálcio e alumínio utilizados no tratamento artificial da água.
- Retém também substâncias orgânicas em suspensão (algas mortas).
- Aumenta a vida útil do sistema de aquecimento solar e resistência dos chuveiros.
- Isenta sua água de sabor e odor desagradável, causados pelo tratamento químico.
- Elimina os sedimentos que causam o "amarelamento" das roupas brancas.
- Pode ser utilizado como leito de carvão ativado, atuando assim como declorador.
- Evita a incrustação de substância em suspensão nas paredes da tubulação galvanizada
- Preserva limpos os reservatórios de água.

### Aplicações do Filtro Central de água

- Filtro Central para Filtragem de água de poço
- Filtro Central para Filtragem de água residencial
- Filtro Central Filtragem de água potável
- Filtro Central Filtragem de efluentes indústriais
- Filtragem de água de reuso
- Filtragem de água de chuva
- Filtragem de água de piscina

### Galeria de Fotos Filtro de Água Central

{% include purewater/equipamentos/galeria-filtro-prfv.html %}