text:
<?xml version="1.0" encoding="UTF-8"?>
<test-set xmlns="http://www.w3.org/2010/09/qt-fots-catalog"
          name="op-divide-yearMonthDuration">
   <description>Tests for the divide-yearMonthDuration() function</description>
   <link type="spec" document="http://www.w3.org/TR/xpath-functions-30/"
         idref="func-divide-yearMonthDuration"/>
   <test-case name="op-divide-yearMonthDuration2args-1">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration2args-1
Written By: Carmelo Montanez
Date: Tue Apr 12 16:29:08 GMT-05:00 2005
Purpose: Evaluates The "op:divide-yearMonthDuration" operator
 with the arguments set as follows:
$arg1 = xs:yearMonthDuration(lower bound)
$arg2 = xs:double(lower bound)
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2004-12-13"/>
      <test>xs:yearMonthDuration("P0Y0M") div xs:double("-1.7976931348623157E308")</test>
      <result>
         <assert-string-value>P0M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration2args-2">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration2args-2
Written By: Carmelo Montanez
Date: Tue Apr 12 16:29:08 GMT-05:00 2005
Purpose: Evaluates The "op:divide-yearMonthDuration" operator
 with the arguments set as follows:
$arg1 = xs:yearMonthDuration(mid range)
$arg2 = xs:double(lower bound)
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2004-12-13"/>
      <test>xs:yearMonthDuration("P1000Y6M") div xs:double("-1.7976931348623157E308")</test>
      <result>
         <assert-string-value>P0M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration2args-3">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration2args-3
Written By: Carmelo Montanez
Date: Tue Apr 12 16:29:08 GMT-05:00 2005
Purpose: Evaluates The "op:divide-yearMonthDuration" operator
 with the arguments set as follows:
$arg1 = xs:yearMonthDuration(upper bound)
$arg2 = xs:double(lower bound)
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2004-12-13"/>
      <test>xs:yearMonthDuration("P2030Y12M") div xs:double("-1.7976931348623157E308")</test>
      <result>
         <assert-string-value>P0M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration2args-4">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration2args-4
Written By: Carmelo Montanez
Date: Tue Apr 12 16:29:08 GMT-05:00 2005
Purpose: Evaluates The "op:divide-yearMonthDuration" operator
 with the arguments set as follows:
$arg1 = xs:yearMonthDuration(lower bound)
$arg2 = xs:double(mid range)
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2004-12-13"/>
      <test>xs:yearMonthDuration("P0Y0M") div xs:double("0.1")</test>
      <result>
         <assert-string-value>P0M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration2args-5">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration2args-5
Written By: Carmelo Montanez
Date: Tue Apr 12 16:29:08 GMT-05:00 2005
Purpose: Evaluates The "op:divide-yearMonthDuration" operator
 with the arguments set as follows:
$arg1 = xs:yearMonthDuration(lower bound)
$arg2 = xs:double(upper bound)
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2004-12-13"/>
      <test>xs:yearMonthDuration("P0Y0M") div xs:double("1.7976931348623157E308")</test>
      <result>
         <assert-string-value>P0M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-1">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-1
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator
As per example 1 (for this function)of the F&O specs.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P2Y11M") div 1.5)</test>
      <result>
         <assert-string-value>P1Y11M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-2">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-2
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator
used as part of a boolean expression (and operator) and the "fn:false" function.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:string((xs:yearMonthDuration("P10Y11M") div 2.0)) and fn:false()</test>
      <result>
         <assert-false/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-3">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-3
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator as
part of a boolean expression (or operator) and the "fn:boolean" function.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:string((xs:yearMonthDuration("P20Y10M") div 2.0)) or fn:false()</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-4">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-4
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator that
return true and used together with fn:not.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:not(fn:string(xs:yearMonthDuration("P11Y04M") div 2.0))</test>
      <result>
         <assert-false/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-5">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-5
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator that
is used as an argument to the fn:boolean function.
 Apply "fn:string" function to account for new EBV.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:boolean(fn:string(xs:yearMonthDuration("P05Y08M") div 2.0))</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-6">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-6
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator that
is used as an argument to the fn:number function.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:number(xs:yearMonthDuration("P02Y09M") div 2.0)</test>
      <result>
         <assert-string-value>NaN</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-7">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-7
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
as an argument to the "fn:string" function).
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:string(xs:yearMonthDuration("P03Y08M") div 2.0)</test>
      <result>
         <assert-string-value>P1Y10M</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-8">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-8
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator that
returns a negative value.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P10Y01M") div -2.0)</test>
      <result>
         <assert-string-value>-P5Y</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-9">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-9
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
together with and "and" expression.
 Apply "fn:string" function to account for new EBV.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:string((xs:yearMonthDuration("P01Y01M") div 2.0)) and fn:string((xs:yearMonthDuration("P02Y03M") div 2.0))</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-10">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-10
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" opeartor used
together with an "or" expression.
 Apply "fn:string" function to account for new EBV.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:string((xs:yearMonthDuration("P05Y02M") div 2.0)) or fn:string((xs:yearMonthDuration("P05Y03M") div 2.0))</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-11">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-11
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
together with a multiple "div" expressions.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P20Y11M") div 2.0) div (xs:yearMonthDuration("P20Y11M") div 2.0)</test>
      <result>
         <assert-string-value>1</assert-string-value>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-12">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-12
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operators used
with a boolean expression and the "fn:true" function.
 Apply "fn:string" function to account for new EBV.
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>fn:string((xs:yearMonthDuration("P10Y11M") div 2.0)) and (fn:true())</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-13">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-13
Written By: Carmelo Montanez
Date: June 29, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
together with the numeric-equal- operator "eq".
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P23Y11M") div 2.0) eq xs:yearMonthDuration("P23Y11M")</test>
      <result>
         <assert-false/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-14">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-14
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
together with the numeric-equal operator "ne".
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P21Y12M") div 2.0) ne xs:yearMonthDuration("P08Y05M")</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-15">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-15
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
together with the numeric-equal operator "le".
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P10Y01M") div 2.0) le xs:yearMonthDuration("P17Y02M")</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-16">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-16
Written By: Carmelo Montanez
Date: June 30, 2005
Purpose: Evaluates The "divide-yearMonthDuration" operator used
together with the numeric-equal operator "ge".
*******************************************************
</description>
      <created by="Carmelo Montanez" on="2005-06-30"/>
      <test>(xs:yearMonthDuration("P13Y09M") div 2.0) ge xs:yearMonthDuration("P18Y02M")</test>
      <result>
         <assert-false/>
      </result>
   </test-case>
   <test-case name="op-divide-yearMonthDuration-17">
      <description>
*******************************************************
Test: op-divide-yearMonthDuration-17
Written By: Michael Kay
Date: 5 March 2009
Purpose: Tests rounding performed by the "divide-yearMonthDuration" operator
See Erratum FO.E12                           .
*******************************************************
</description>
      <created by="Michael Kay" on="2009-03-05"/>
      <test>for $i in (-2, -4, -10, -50, +50, +10, +4, +2) return (xs:yearMonthDuration("P5M") div $i)</test>
      <result>
         <assert-string-value>-P2M -P1M P0M P0M P0M P1M P1M P3M</assert-string-value>
      </result>
   </test-case>
   <test-case name="K-YearMonthDurationDivide-1">
      <description>
*******************************************************
 Test: K-YearMonthDurationDivide-1
 Written by: Frans Englich
 Date: 2007-11-22T11:31:21+01:00
 Purpose: Simple test of dividing a xs:yearMonthDuration with 3.
*******************************************************
</description>
      <created by="Frans Englich" on="2007-11-26+01:00"/>
      <test>xs:yearMonthDuration("P3Y36M") div 3 eq xs:yearMonthDuration("P2Y")</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="K-YearMonthDurationDivide-2">
      <description>
*******************************************************
 Test: K-YearMonthDurationDivide-2
 Written by: Frans Englich
 Date: 2007-11-22T11:31:21+01:00
 Purpose: Simple test of dividing a xs:yearMonthDuration with xs:double('-INF').
*******************************************************
</description>
      <created by="Frans Englich" on="2007-11-26+01:00"/>
      <test>xs:yearMonthDuration("P3Y36M") div xs:double("-INF") eq xs:yearMonthDuration("P0M")</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="K-YearMonthDurationDivide-3">
      <description>
*******************************************************
 Test: K-YearMonthDurationDivide-3
 Written by: Frans Englich
 Date: 2007-11-22T11:31:21+01:00
 Purpose: Simple test of dividing a xs:yearMonthDuration with xs:double('INF').
*******************************************************
</description>
      <created by="Frans Englich" on="2007-11-26+01:00"/>
      <test>xs:yearMonthDuration("P3Y36M") div xs:double("INF") eq xs:yearMonthDuration("P0M")</test>
      <result>
         <assert-true/>
      </result>
   </test-case>
   <test-case name="K-YearMonthDurationDivide-4">
      <description>
*******************************************************
 Test: K-YearMonthDurationDivide-4
 Written by: Frans Englich
 Date: 2007-11-22T11:31:21+01:00
 Purpose: Simple test of dividing a xs:yearMonthDuration with 0.
*******************************************************
</description>
      <created by="Frans Englich" on="2007-11-26+01:00"/>
      <test>xs:yearMonthDuration("P3Y36M") div 0</test>
      <result>
         <error code="FODT0002"/>
      </result>
   </test-case>
   <test-case name="K-YearMonthDurationDivide-5">
      <description>
*******************************************************
 Test: K-YearMonthDurationDivide-5
 Written by: Frans Englich
 Date: 2007-11-22T11:31:21+01:00
 Purpose: Simple test of dividing a xs:yearMonthDuration with NaN.
*******************************************************
</description>
      <created by="Frans Englich" on="2007-11-26+01:00"/>
      <test>xs:yearMonthDuration("P3Y36M") div xs:double("NaN")</test>
      <result>
         <error code="FOCA0005"/>
      </result>
   </test-case>
   <test-case name="K-YearMonthDurationDivide-6">
      <description>
*******************************************************
 Test: K-YearMonthDurationDivide-6
 Written by: Frans Englich
 Date: 2007-11-22T11:31:21+01:00
 Purpose: Simple test of dividing a xs:yearMonthDuration with xs:double('-0').
*******************************************************
</description>
      <created by="Frans Englich" on="2007-11-26+01:00"/>
      <test>xs:yearMonthDuration("P3Y36M") div xs:double("-0")</test>
      <result>
         <error code="FODT0002"/>
      </result>
   </test-case>

   <test-case name="cbcl-divide-yearMonthDuration-001">
      <description> test division of xs:yearMonthDuration by 0 </description>
      <created by="Tim Mills" on="2008-05-14"/>
      <dependency type="spec" value="XQ10+"/>
      <test>
        declare function local:yearMonthDuration($years as xs:integer) as xs:yearMonthDuration { xs:yearMonthDuration(concat("P", $years, "Y")) };
        local:yearMonthDuration(2) div 0</test>
      <result>
         <error code="FODT0002"/>
      </result>
   </test-case>

   <test-case name="cbcl-divide-yearMonthDuration-002">
      <description> test division of xs:yearMonthDuration by 1 </description>
      <created by="Tim Mills" on="2008-05-14"/>
      <dependency type="spec" value="XQ10+"/>
      <test>
        declare function local:yearMonthDuration($years as xs:integer) as xs:yearMonthDuration { xs:yearMonthDuration(concat("P", $years, "Y")) };
        local:yearMonthDuration(2) div 1</test>
      <result>
         <assert-string-value>P2Y</assert-string-value>
      </result>
   </test-case>

   <test-case name="cbcl-divide-yearMonthDuration-003">
      <description> test possible overflow in division of xs:yearMonthDuration </description>
      <created by="Tim Mills" on="2008-05-14"/>
      <dependency type="spec" value="XQ10+"/>
      <test>
        declare function local:yearMonthDuration($years as xs:integer) as xs:yearMonthDuration { xs:yearMonthDuration(concat("P", $years, "Y")) };
        local:yearMonthDuration(768614336404564650) div 0.5</test>
      <result>
         <error code="FODT0002"/>
      </result>
   </test-case>
</test-set>


text:
<?php

namespace GL\MainBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * ProcessEventDetail
 *
 * @ORM\Table(name="process_event_detail")
 * @ORM\Entity(repositoryClass="GL\MainBundle\Entity\ProcessEventDetailRepository")
 */
class ProcessEventDetail
{
  /**
   * @var integer
   *
   * @ORM\Column(name="id", type="integer")
   * @ORM\Id
   * @ORM\GeneratedValue(strategy="AUTO")
   */
  private $id;

  /**
   * @ORM\ManyToOne(targetEntity="ProcessEvent", inversedBy="details")
   * @ORM\JoinColumn(name="event_id", referencedColumnName="id")
   */
  private $event;

  /**
   * @var \DateTime
   *
   * @ORM\Column(name="log_date", type="datetime")
   */
  private $log_date;

  /**
   * @var string
   *
   * @ORM\Column(name="data", type="text")
   */
  private $data;

  /**
   * Get id
   *
   * @return integer
   */
  public function getId()
  {
    return $this->id;
  }

  /**
   * Set log_date
   *
   * @param \DateTime $logDate
   * @return ProcessEventDetail
   */
  public function setLogDate($logDate)
  {
    $this->log_date = $logDate;

    return $this;
  }

  /**
   * Get log_date
   *
   * @return \DateTime
   */
  public function getLogDate()
  {
    return $this->log_date;
  }

  /**
   * Set data
   *
   * @param string $data
   * @return ProcessEventDetail
   */
  public function setData($data)
  {
    $this->data = $data;

    return $this;
  }

  /**
   * Get data
   *
   * @return string
   */
  public function getData()
  {
    return $this->data;
  }

  /**
   * Set event
   *
   * @param \GL\MainBundle\Entity\Event $event
   * @return ProcessEventDetail
   */
  public function setEvent(\GL\MainBundle\Entity\ProcessEvent $event = null)
  {
    $this->event = $event;

    return $this;
  }

  /**
   * Get event
   *
   * @return \GL\MainBundle\Entity\Event
   */
  public function getEvent()
  {
    return $this->event;
  }
}

redpajama_set_name: RedPajamaGithub


text:
// @yasinkuyu
// 05/08/2014

using System.Web.Mvc;
using System.Web.Routing;

namespace Insya.Localization.Helpers
{
    public static partial class HtmlHelperExtensions
    {

        ///
        /// MVC Action link localization html helper
        /// Example @Html.ActionLinkLocalization("homepage", "Index", "Home") -> <item id="homepage">Home Page</item>
        /// Output :
        ///
        /// <param id="htmlHelper"></param>
        /// <param id="linkText"></param>
        /// <param id="actionName"></param>
        /// <param id="controllerName"></param>
        /// <param id="routeValues"></param>
        /// <param id="htmlAttributes"></param>
        /// <returns></returns>
        public static MvcHtmlString ActionLinkLocalization(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName, object routeValues = null, object htmlAttributes = null)
        {
            var urlHelper = new UrlHelper(htmlHelper.ViewContext.RequestContext);
            var tagBuilder = new TagBuilder("a") { InnerHtml = Localization.Localize(linkText) };

            tagBuilder.Attributes["href"] = urlHelper.Action(actionName.ToLowerInvariant(), controllerName.ToLowerInvariant(), routeValues);

            tagBuilder.MergeAttributes(new RouteValueDictionary(htmlAttributes));

            return MvcHtmlString.Create(tagBuilder.ToString());
        }
    }
}


text:
#ifndef WebSocket_h
#define WebSocket_h

#include "../platform/WebCommon.h"
#include "../platform/WebPrivatePtr.h"

namespace WebCore { class WebSocketChannel; }

namespace WebKit {

class WebArrayBuffer;
class WebDocument;
class WebString;
class WebURL;
class WebSocketClient;

class WebSocket {
public:
    enum CloseEventCode {
        CloseEventCodeNotSpecified = -1,
        CloseEventCodeNormalClosure = 1000,
        CloseEventCodeGoingAway = 1001,
        CloseEventCodeProtocolError = 1002,
        CloseEventCodeUnsupportedData = 1003,
        CloseEventCodeFrameTooLarge = 1004,
        CloseEventCodeNoStatusRcvd = 1005,
        CloseEventCodeAbnormalClosure = 1006,
        CloseEventCodeInvalidFramePayloadData = 1007,
        CloseEventCodePolicyViolation = 1008,
        CloseEventCodeMessageTooBig = 1009,
        CloseEventCodeMandatoryExt = 1010,
        CloseEventCodeInternalError = 1011,
        CloseEventCodeTLSHandshake = 1015,
        CloseEventCodeMinimumUserDefined = 3000,
        CloseEventCodeMaximumUserDefined = 4999
    };

    enum BinaryType {
        BinaryTypeBlob = 0,
        BinaryTypeArrayBuffer = 1
    };

    WEBKIT_EXPORT static WebSocket* create(const WebDocument&, WebSocketClient*);
    virtual ~WebSocket() { }

    // These functions come from binaryType attribute of the WebSocket API
    // specification. It specifies binary object type for receiving binary
    // frames representation. Receiving text frames are always mapped to
    // WebString type regardless of this attribute.
    // Default type is BinaryTypeBlob. But currently it is not supported.
    // Set BinaryTypeArrayBuffer here ahead of using binary communication.
    // See also, The WebSocket API - http://www.w3.org/TR/websockets/ .
    virtual BinaryType binaryType() const = 0;
    virtual bool setBinaryType(BinaryType) = 0;

    virtual void connect(const WebURL&, const WebString& protocol) = 0;
    virtual WebString subprotocol() = 0;
    virtual WebString extensions() = 0;
    virtual bool sendText(const WebString&) = 0;
    virtual bool sendArrayBuffer(const WebArrayBuffer&) = 0;
    virtual unsigned long bufferedAmount() const = 0;
    virtual void close(int code, const WebString& reason) = 0;
    virtual void fail(const WebString& reason) = 0;
    virtual void disconnect() = 0;
};

} // namespace WebKit

#endif // WebSocket_h


text:
// GenModelInterface.cpp : Defines the initialization routines for the DLL.
//

#include "GenModelInterface.h"

#ifdef CPLEX_MODULE
#include "GenModelCplex.h"
#endif

#ifdef GUROBI_MODULE
#include "GenModelGurobi.h"
#endif

#ifdef HG_MODULEZ
#include "GenModelHG.h"
#endif

#ifdef GLPK_MODULE
#include "GenModelGlpk.h"
#endif

#ifdef OSI_MODULE
#include "GenModelOsi.h"
#endif

#ifdef SCIP_MODULE
#include "GenModelScip.h"
#endif

#include <vector>
#include <memory.h>

using namespace std;

vector<GenModel*> gmmap;

GENMODEL_EXTERN_C_BEGIN

bool VerifyId(long token)
{
    if(token <0 || token >= long(gmmap.size()))
    {
        throw string("Model id out of bound");
        return false;
    }
    else
        return true;

}

long WriteProblemToLpFile(char* filename, long token)
{
    VerifyId(token);
    return gmmap[token]->WriteProblemToLpFile(string(filename));
}

long WriteSolutionToFile(char* filename, long token)
{
    VerifyId(token);
    return gmmap[token]->WriteSolutionToFile(string(filename));
}

double FindConstraintMaxLhs(long row, long token)
{
    VerifyId(token);
    return gmmap[token]->FindConstraintMaxLhs(row);
}

double FindConstraintMinLhs(long row, long token)
{
    VerifyId(token);
    return gmmap[token]->FindConstraintMinLhs(row);
}

long MakeConstraintFeasible(long row, long token)
{
    VerifyId(token);
    return gmmap[token]->MakeConstraintFeasible(row);
}

long AddConst(char* cname, double rhs, char sense, long token)
{
    VerifyId(token);
    //printf("AddConst : name=%s, rhs=%f, sense=%c, token=%ld\n", cname, rhs, sense, token);
	string cnameAsString(cname);
	return gmmap[token]->AddConst(cnameAsString, rhs, sense);
}

bool AddConstBulk(char* cname, double* rhs, long length, char sense, long token)
{
    VerifyId(token);
	string cnameAsString(cname);
	for (int i = 0; i < length; i++)
	{
		gmmap[token]->AddConst(cnameAsString, rhs[i], sense);
	}
	return true;
}

long AddVar(char* nn, double o, double l, double u, char t, long token)
{
    VerifyId(token);
    //printf("AddVar : name=%s, obj=%f, lower=%f, upper=%f, type=%c, token=%ld\n", nn, o, l, u, t, token);
	string nnAsString(nn);
	return gmmap[token]->AddVar(nnAsString, o, l, u, t);
}

bool AddVarBulk(char* nn, double* o, long length, double l, double u, char t, long token)
{
    VerifyId(token);
	string nnAsString(nn);
	for (int i = 0; i < length; i++)
	{
		gmmap[token]->AddVar(nnAsString, o[i], l, u, t);
	}
	return true;
}

long SetQpCoef(long i, long j, double val, long token)
{
    VerifyId(token);
    return gmmap[token]->vars.SetQpCoef(i, j, val);
}

long AddNz(long row, long col, double val, long token)
{
    VerifyId(token);
	return gmmap[token]->AddNz(row, col, val);
}

long AddNzToLast(long col, double val, long token)
{
    VerifyId(token);
    //printf("AddNzToLast : col=%d, val=%f, token=%ld\n", col, val, token);
	return gmmap[token]->AddNzToLast(col, val);
}

long AddNzBulk(long* rows, long* cols, double* values, long valuesLength, long rowCount, long colCount, long iterations, long token)
{
    VerifyId(token);
	//printf ("AddNzBulk %ld,%ld,%ld,%ld\n",valuesLength, rowCount, colCount, iterations);

	int rowIndex = 0;
	int colIndex = 0;
	for(int iter = 1; iter <= iterations; iter++)
	{
		//printf ("Iter %ld\n",iter);
		for(int i = 0; i < valuesLength; i++)
		{
			//printf ("i ri ci %ld,%ld,%ld\n",i,rows[i] + rowIndex, cols[i] + colIndex);
			gmmap[token]->AddNz(rows[i] + rowIndex, cols[i] + colIndex, values[i]);
		}
		rowIndex += rowCount;
		colIndex += colCount;
		//printf ("ri ci %ld,%ld\n", rowIndex, colIndex);
	}
	return true;
}

long SetNumbers(long token)
{
    VerifyId(token);
	return gmmap[token]->SetNumbers();
}

long SetLongParam(char* param, long val, long token)
{
    VerifyId(token);
	string paramAsString(param);
	return gmmap[token]->SetLongParam(paramAsString, val);
}

long SetDblParam(char* param, double val, long token)
{
    VerifyId(token);
	string paramAsString(param);
	return gmmap[token]->SetDblParam(paramAsString, val);
}

long SetBoolParam(char* param, bool val, long token)
{
    VerifyId(token);
    //printf("SetBoolParam : param=%s, val=%d, token=%ld\n", param, val, token);
	string paramAsString(param);
	return gmmap[token]->SetBoolParam(paramAsString, val);
}

long SetStrParam(char* param, char* val, long token)
{
    VerifyId(token);
	string paramAsString(param);
	string valueAsString(val);
	return gmmap[token]->SetStrParam(paramAsString, valueAsString);
}

long CreateNewModel(char type, char* name = NULL)
{
	long ret = gmmap.size();
    switch (type) {
        case 'C':
            (CPLEX_EXIST ? CPLEX_CREATE : (GLPK_EXIST ? GLPK_CREATE : throw "Neither Cplex nor Glpk (deafault fallback solver) are available"));
            break;
        case 'G':
            (GUROBI_EXIST ? GUROBI_CREATE : (GLPK_EXIST ? GLPK_CREATE : throw "Neither Gurobi nor Glpk (deafault fallback solver) are available"));
            break;
        case 'H':
            (HG_EXIST ? HG_CREATE : (GLPK_EXIST ? GLPK_CREATE : throw "Neither Hypergraph nor Glpk (deafault fallback solver) are available"));
            break;
        case 'K':
            (GLPK_EXIST ? GLPK_CREATE : throw "Glpk (deafault fallback solver) is not available");
            break;
        case 'S':
            (SCIP_EXIST ? SCIP_CREATE : (GLPK_EXIST ? GLPK_CREATE : throw "Neither Scip nor Glpk (deafault fallback solver) are available"));
            break;
        case 'O':
            (OSI_EXIST ? OSI_CREATE : (GLPK_EXIST ? GLPK_CREATE : throw "Neither Osi nor Glpk (deafault fallback solver) are available"));
            break;
        default:
            throw string("Unknown solver");
            return 1;
    }
	if(long(gmmap.size()) == ret)
        return 1;
	gmmap[ret]->name = "DefaultGenModel";
    if(name != NULL)
        gmmap[ret]->name = string(name);

    return ret;
}

bool IsSolverAvailable(char type)
{
    switch (type) {
        case 'C':
            return CPLEX_EXIST;
            break;
        case 'G':
            return GUROBI_EXIST;
            break;
        case 'H':
            return HG_EXIST;
            break;
        case 'K':
            return GLPK_EXIST;
            break;
        case 'S':
            return SCIP_EXIST;
            break;
        case 'O':
            return OSI_EXIST;
            break;
        default:
            return false;
    }
	return false;
}

long CopyOrder(long token, int count, int* ind, int* weight)
{
    VerifyId(token);
#ifdef CPLEX_SOLVER
	CplexData* d = static_cast<CplexData*>(gmmap[token]->solverdata);
	CPXcopyorder(d->env, d->lp, count, ind, weight, NULL);
#else
	throw "Not implemented for your solver";
#endif
	return 0;
}

long DeleteModel(long token)
{
    VerifyId(token);
	delete gmmap[token];
	return 0;
}

long CreateModel(long token)
{
    VerifyId(token);
	gmmap[token]->SetNumbers();
	gmmap[token]->Init(gmmap[token]->name);
	gmmap[token]->CreateModel();
	return 0;
}

long SolveModel(long token)
{
    VerifyId(token);
	gmmap[token]->Solve();
	gmmap[token]->SetSol();
    /*for(int i = 0; i < gmmap[token]->nc; i++)
     {
     printf("%s: %f\n", gmmap[token]->vars.name[i].c_str(), gmmap[token]->vars.sol[i]);	// Solution des variables
     }*/
	return long(gmmap[token]->solstat);
}

bool HasSolution(long token)
{
    VerifyId(token);
	return gmmap[token]->hassolution;
}

bool GetSolVars(double* values, long length, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nc))
		throw string("Wrong length : GetSolVars()");

	for(int i = 0; i < long(gmmap[token]->nc); i++)
		values[i] = gmmap[token]->vars.sol[i];

	return true;
}

bool GetDualPrices(double* values, long length, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nr))
		throw string("Wrong length : GetDualPrices()");

	for(int i = 0; i < long(gmmap[token]->nr); i++)
		values[i] = gmmap[token]->consts[i].dual;

	return true;
}

bool GetSlacks(double* values, long length, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nr))
		throw string("Wrong length : GetSlacks()");

	for(int i = 0; i < long(gmmap[token]->nr); i++)
		values[i] = gmmap[token]->consts[i].slack;

    return true;
}

bool GetReducedCosts(double* values, long length, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nc))
		throw string("Wrong length : GetReducedCosts()");

	for(int i = 0; i < long(gmmap[token]->nc); i++)
		values[i] = gmmap[token]->vars.rc[i];

	return true;
}

bool GetRowValues(double* values, long length, long rowIndex, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nc) || rowIndex >= long(gmmap[token]->nr))
	{
		return false;
	}

	memset(values, 0, sizeof(double)*length);
	for(int i = 0; i < int(gmmap[token]->consts[rowIndex].cols.size()); i++)
		values[gmmap[token]->consts[rowIndex].cols[i]] = gmmap[token]->consts[rowIndex].coefs[i];

	return true;
}

bool GetObjCoef(double* values, long length, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nc))
	{
		return false;
	}

	for(int i = 0; i < long(gmmap[token]->nc); i++)
	{
		values[i] = gmmap[token]->vars.obj[i];
	}

	return true;
}

bool GetBounds(double* lb, double* ub, long length, long token)
{
    VerifyId(token);
	if (length != long(gmmap[token]->nc))
	{
		return false;
	}

	for(int i = 0; i < long(gmmap[token]->nc); i++)
	{
		lb[i] = gmmap[token]->vars.lb[i];
		ub[i] = gmmap[token]->vars.ub[i];
	}

	return true;
}

double GetLowerBound(long col, long token)
{
    VerifyId(token);
	if (col != long(gmmap[token]->nc) || col < 0)
        return (numeric_limits<double>::has_signaling_NaN ? numeric_limits<double>::signaling_NaN() : numeric_limits<double>::quiet_NaN());

	return gmmap[token]->vars.lb[col];
}

double GetUpperBound(long col, long token)
{
    VerifyId(token);
	if (col != long(gmmap[token]->nc) || col < 0)
        return (numeric_limits<double>::has_signaling_NaN ? numeric_limits<double>::signaling_NaN() : numeric_limits<double>::quiet_NaN());

	return gmmap[token]->vars.ub[col];
}

bool SetLowerBound(long col, double val, long token)
{
    VerifyId(token);
	if (col != long(gmmap[token]->nc) || col < 0)
        return false;
    gmmap[token]->vars.lb[col] = val;
	return true;
}

bool SetUpperBound(long col, double val, long token)
{
    VerifyId(token);
	if (col != long(gmmap[token]->nc) || col < 0)
        return false;
    gmmap[token]->vars.ub[col] = val;
	return true;
}

double GetRHS(long row, long token)
{
    VerifyId(token);
	return gmmap[token]->consts[row].lrhs;
}

bool SetRHS(long row, double val, long token)
{
    VerifyId(token);
	gmmap[token]->consts[row].lrhs = val;
	return true;
}

char GetSense(long row, long token)
{
    VerifyId(token);
	return gmmap[token]->consts[row].sense;
}

bool SetSense(long row, char sense, long token)
{
    VerifyId(token);
	gmmap[token]->consts[row].sense = sense;
	return true;
}

double GetObjVal(long token)
{
    VerifyId(token);
	return gmmap[token]->objval;
}

long ChangeBulkBounds(int count, int* indices, char* types, double* values, long token)
{
    VerifyId(token);
	return gmmap[token]->ChangeBulkBounds(count, indices, types, values);
}

long ChangeBulkObjectives(int count, int* indices, double* values, long token)
{
    VerifyId(token);
	return gmmap[token]->ChangeBulkObjectives(count, indices, values);
}

long DeleteMipStarts(long token)
{
    VerifyId(token);
	return gmmap[token]->DeleteMipStarts();
}

double GetMIPRelativeGap(long token)
{
    VerifyId(token);
	return gmmap[token]->GetMIPRelativeGap();
}

GENMODEL_EXTERN_C_END


text:
namespace LL.MDE.Components.Qvt.Transformation.umlToRdbms
{
	using System;
	using System.Collections.Generic;
	using System.Linq;

	using LL.MDE.Components.Qvt.Common;
	using LL.MDE.DataModels.SimpleRDBMS;
	using LL.MDE.DataModels.SimpleUML;

	public class RelationAttributeToColumn
	{
		private readonly IMetaModelInterface editor;
		private readonly Dictionary<CheckOnlyDomains, EnforceDomains> traceabilityMap = new Dictionary<CheckOnlyDomains, EnforceDomains>();
		private readonly TransformationumlToRdbms transformation;

		public RelationAttributeToColumn(IMetaModelInterface editor , TransformationumlToRdbms transformation )
		{
			this.editor = editor;this.transformation = transformation;
		}

		public EnforceDomains FindPreviousResult(LL.MDE.DataModels.SimpleUML.Class c,string prefix)
		{
			CheckOnlyDomains input = new CheckOnlyDomains(c,prefix);
			return traceabilityMap.ContainsKey(input) ? traceabilityMap[input] : null;
		}

		internal static ISet<CheckResultAttributeToColumn> Check( LL.MDE.DataModels.SimpleUML.Class c,string prefix )
		{
			ISet<CheckResultAttributeToColumn> result = new HashSet<CheckResultAttributeToColumn>();ISet<MatchDomainC> matchDomainCs = CheckDomainC(c);
			foreach (MatchDomainC matchDomainC in matchDomainCs ) {

			CheckResultAttributeToColumn checkonlysMatch = new CheckResultAttributeToColumn () {matchDomainC = matchDomainC,
			};
			result.Add(checkonlysMatch);			} // End foreach
				return result;
		}

		internal static ISet<MatchDomainC> CheckDomainC(LL.MDE.DataModels.SimpleUML.Class c)
		{
			ISet<MatchDomainC> result = new HashSet<MatchDomainC>();
			if (c != null) {
			MatchDomainC match = new MatchDomainC() {
			c = c,
			};
			result.Add(match);
			}

			return result;
		}

		internal void CheckAndEnforce(LL.MDE.DataModels.SimpleUML.Class c,LL.MDE.DataModels.SimpleRDBMS.Table t,string prefix )
		{
			CheckOnlyDomains input = new CheckOnlyDomains(c,prefix);
			EnforceDomains output = new EnforceDomains(t);
			if (traceabilityMap.ContainsKey(input) && !traceabilityMap[input].Equals(output))
			{
				throw new Exception("This relation has already been used with different enforced parameters!");
			}
			if (!traceabilityMap.ContainsKey(input))
			{
				ISet<CheckResultAttributeToColumn> result = Check (c,prefix);
				Enforce(result, t,prefix);
				traceabilityMap[input] = output;
			}
		}

		internal void Enforce(ISet<CheckResultAttributeToColumn> result, LL.MDE.DataModels.SimpleRDBMS.Table t,string prefix )
		{
			foreach (CheckResultAttributeToColumn match in result)
			{
			// Extracting variables binded in source domains
			LL.MDE.DataModels.SimpleUML.Class c = match.matchDomainC.c;

			// Assigning variables binded in the where clause

			// Enforcing each enforced domain
			MatchDomainT targetMatchDomainT = EnforceT(match, t);

			// Retrieving variables binded in the enforced domains

			// Calling other relations as defined in the where clause
			transformation.RelationPrimitiveAttributeToColumn.CheckAndEnforce(c,t,prefix);
				transformation.RelationComplexAttributeToColumn.CheckAndEnforce(c,t,prefix);
				transformation.RelationSuperAttributeToColumn.CheckAndEnforce(c,t,prefix);
				}
		}

		internal MatchDomainT EnforceT(CheckResultAttributeToColumn checkresult, LL.MDE.DataModels.SimpleRDBMS.Table t)
		{
			MatchDomainT match = new MatchDomainT();LL.MDE.DataModels.SimpleUML.Class c = checkresult.matchDomainC.c;

			// Contructing t

				// Return newly binded variables
								match.t  = t;
				return match;
		}

		public class CheckOnlyDomains : Tuple<Class,String>
		{
			public CheckOnlyDomains(Class c,String prefix)
				: base(c,prefix)
			{
			}

			public Class c
			{
				get { return Item1; }
			}

			public String prefix
			{
				get { return Item2; }
			}
		}

		public class EnforceDomains : Tuple<Table>
		{
			public EnforceDomains(Table t)
				: base(t)
			{
			}

			public Table t
			{
				get { return Item1; }
			}
		}

		internal class CheckResultAttributeToColumn
		{
			public MatchDomainC matchDomainC;
		}

		internal class MatchDomainC
		{
			public LL.MDE.DataModels.SimpleUML.Class c;
		}

		internal class MatchDomainT
		{
			public LL.MDE.DataModels.SimpleRDBMS.Table t;
		}
	}
}


text:
from .dprovider import data_provider
from .fixtureman import FixtureManager

__author__ = 'y.gavenchuk aka murminathor'
__all__ = ['data_provider', 'FixtureManager', ]
__version__ = '0.0.3'

VERSION = __version__.split('.')


text:
package com.taobao.weex.ui.view.border;

import android.graphics.PointF;
import android.graphics.RectF;
import android.support.annotation.NonNull;

class TopLeftCorner extends BorderCorner {

  TopLeftCorner(float cornerRadius, float preBorderWidth, float postBorderWidth, @NonNull RectF borderBox) {
    super(cornerRadius, preBorderWidth, postBorderWidth, borderBox);
  }

  @Override
  protected float getAngleBisectorDegree() {
    return 225;
  }

  @NonNull
  @Override
  protected RectF getOvalIfInnerCornerExist() {
    return new RectF(getPreBorderWidth() / 2,
                     getPostBorderWidth() / 2,
                     2 * getOuterCornerRadius() - getPreBorderWidth() / 2,
                     2 * getOuterCornerRadius() - getPostBorderWidth() / 2);
  }

  @NonNull
  @Override
  protected RectF getOvalIfInnerCornerNotExist() {
    return new RectF(getOuterCornerRadius()/2,
                     getOuterCornerRadius()/2,
                     getOuterCornerRadius() * 1.5f,
                     getOuterCornerRadius() * 1.5f);
  }

  @NonNull
  @Override
  protected PointF getRoundCornerStart() {
    return new PointF(getPreBorderWidth() / 2, getOuterCornerRadius());
  }

  @NonNull
  @Override
  protected PointF getSharpCornerVertex() {
    return new PointF(getPreBorderWidth() / 2, getPostBorderWidth() / 2);
  }

  @NonNull
  @Override
  protected PointF getSharpCornerStart() {
    PointF pointF=getSharpCornerVertex();
    pointF.x=0;
    return pointF;
  }

  @NonNull
  @Override
  protected PointF getSharpCornerEnd() {
    PointF pointF=getSharpCornerVertex();
    pointF.y=0;
    return pointF;
  }

  @NonNull
  @Override
  protected PointF getRoundCornerEnd() {
    return new PointF(getOuterCornerRadius(), getPostBorderWidth() / 2);
  }
}


text:
package com.google.zxing.datamatrix;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.Writer;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.datamatrix.encoder.DefaultPlacement;
import com.google.zxing.Dimension;
import com.google.zxing.datamatrix.encoder.ErrorCorrection;
import com.google.zxing.datamatrix.encoder.HighLevelEncoder;
import com.google.zxing.datamatrix.encoder.SymbolInfo;
import com.google.zxing.datamatrix.encoder.SymbolShapeHint;
import com.google.zxing.qrcode.encoder.ByteMatrix;

import java.util.Map;

/**
 * This object renders a Data Matrix code as a BitMatrix 2D array of greyscale values.
 *
 * @author dswitkin@google.com (Daniel Switkin)
 * @author Guillaume Le Biller Added to zxing lib.
 */
public final class DataMatrixWriter implements Writer {

  @Override
  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height) {
    return encode(contents, format, width, height, null);
  }

  @Override
  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height, Map<EncodeHintType,?> hints) {

    if (contents.isEmpty()) {
      throw new IllegalArgumentException("Found empty contents");
    }

    if (format != BarcodeFormat.DATA_MATRIX) {
      throw new IllegalArgumentException("Can only encode DATA_MATRIX, but got " + format);
    }

    if (width < 0 || height < 0) {
      throw new IllegalArgumentException("Requested dimensions are too small: " + width + 'x' + height);
    }

    // Try to get force shape & min / max size
    SymbolShapeHint shape = SymbolShapeHint.FORCE_NONE;
    Dimension minSize = null;
    Dimension maxSize = null;
    if (hints != null) {
      SymbolShapeHint requestedShape = (SymbolShapeHint) hints.get(EncodeHintType.DATA_MATRIX_SHAPE);
      if (requestedShape != null) {
        shape = requestedShape;
      }
      @SuppressWarnings("deprecation")
      Dimension requestedMinSize = (Dimension) hints.get(EncodeHintType.MIN_SIZE);
      if (requestedMinSize != null) {
        minSize = requestedMinSize;
      }
      @SuppressWarnings("deprecation")
      Dimension requestedMaxSize = (Dimension) hints.get(EncodeHintType.MAX_SIZE);
      if (requestedMaxSize != null) {
        maxSize = requestedMaxSize;
      }
    }

    //1. step: Data encodation
    String encoded = HighLevelEncoder.encodeHighLevel(contents, shape, minSize, maxSize);

    SymbolInfo symbolInfo = SymbolInfo.lookup(encoded.length(), shape, minSize, maxSize, true);

    //2. step: ECC generation
    String codewords = ErrorCorrection.encodeECC200(encoded, symbolInfo);

    //3. step: Module placement in Matrix
    DefaultPlacement placement =
        new DefaultPlacement(codewords, symbolInfo.getSymbolDataWidth(), symbolInfo.getSymbolDataHeight());
    placement.place();

    //4. step: low-level encoding
    return encodeLowLevel(placement, symbolInfo);
  }

  /**
   * Encode the given symbol info to a bit matrix.
   *
   * @param placement  The DataMatrix placement.
   * @param symbolInfo The symbol info to encode.
   * @return The bit matrix generated.
   */
  private static BitMatrix encodeLowLevel(DefaultPlacement placement, SymbolInfo symbolInfo) {
    int symbolWidth = symbolInfo.getSymbolDataWidth();
    int symbolHeight = symbolInfo.getSymbolDataHeight();

    ByteMatrix matrix = new ByteMatrix(symbolInfo.getSymbolWidth(), symbolInfo.getSymbolHeight());

    int matrixY = 0;

    for (int y = 0; y < symbolHeight; y++) {
      // Fill the top edge with alternate 0 / 1
      int matrixX;
      if ((y % symbolInfo.matrixHeight) == 0) {
        matrixX = 0;
        for (int x = 0; x < symbolInfo.getSymbolWidth(); x++) {
          matrix.set(matrixX, matrixY, (x % 2) == 0);
          matrixX++;
        }
        matrixY++;
      }
      matrixX = 0;
      for (int x = 0; x < symbolWidth; x++) {
        // Fill the right edge with full 1
        if ((x % symbolInfo.matrixWidth) == 0) {
          matrix.set(matrixX, matrixY, true);
          matrixX++;
        }
        matrix.set(matrixX, matrixY, placement.getBit(x, y));
        matrixX++;
        // Fill the right edge with alternate 0 / 1
        if ((x % symbolInfo.matrixWidth) == symbolInfo.matrixWidth - 1) {
          matrix.set(matrixX, matrixY, (y % 2) == 0);
          matrixX++;
        }
      }
      matrixY++;
      // Fill the bottom edge with full 1
      if ((y % symbolInfo.matrixHeight) == symbolInfo.matrixHeight - 1) {
        matrixX = 0;
        for (int x = 0; x < symbolInfo.getSymbolWidth(); x++) {
          matrix.set(matrixX, matrixY, true);
          matrixX++;
        }
        matrixY++;
      }
    }

    return convertByteMatrixToBitMatrix(matrix);
  }

  /**
   * Convert the ByteMatrix to BitMatrix.
   *
   * @param matrix The input matrix.
   * @return The output matrix.
   */
  private static BitMatrix convertByteMatrixToBitMatrix(ByteMatrix matrix) {
    int matrixWidgth = matrix.getWidth();
    int matrixHeight = matrix.getHeight();

    BitMatrix output = new BitMatrix(matrixWidgth, matrixHeight);
    output.clear();
    for (int i = 0; i < matrixWidgth; i++) {
      for (int j = 0; j < matrixHeight; j++) {
        // Zero is white in the bytematrix
        if (matrix.get(i, j) == 1) {
          output.set(i, j);
        }
      }
    }

    return output;
  }

}


text:
public class Logger {

	public Logger() {

	}

	public static void clientOnline(String name){
		System.out.println(name + " is online.");
	}

	public static void clientLeaved(String name){
		System.out.println(name + " leaved the chat.");
	}

	public static void d(String TAG, String message){
		System.out.println(TAG + ": " + message);
	}
}


text:
var exports = {};

var data = {

    getData: function(dataType, direction) {
        return exports[dataType][direction];
    },

    input: function(dataType) {
        return this.getData(dataType, 'input');
    },

    output: function(dataType) {
        return this.getData(dataType, 'output');
    }

};


text:
title: Address
description: Use the Spree Commerce storefront API to access Address data.
---

## Show

Retrieve details about a particular address:

```text
GET /api/v1/orders/1/addresses/1
```

Order addresses through the API will only be visible to admins and the users who own particular orders related to that addresses.
If a user attempts to access an order address that does not belong to him, he
will be met with an authorization error.

Users may pass in the order's token in order to be authorized to view an order address:

```text
GET /api/v1/orders/1/addresses/1?order_token=abcdef123456
```

The `order_token` parameter will work for authorizing any action for an order address within Spree's API.

### Response

<status code="200"></status>
<json sample="address"></json>

## Update

To update an address, make a request like this:

```text
PUT /api/v1/orders/1/addresses/1?address[firstname]=Ryan
```

This request will update the `firstname` field for an address to the value of \"Ryan\"

### Response

<status code="200"></status>
<json sample="address" merge='{"firstname": "Ryan"}'></json>

Valid address fields are:

* firstname
* lastname
* company
* address1
* address2
* city
* zipcode
* phone
* alternative_phone
* country_id
* state_id
* state_name


text:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!--
    JBoss, Home of Professional Open Source
    Copyright 2015, Red Hat, Inc. and/or its affiliates, and individual
    contributors by the @authors tag. See the copyright.txt in the
    distribution for a full listing of individual contributors.

    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.
-->
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.jboss.quickstarts.eap</groupId>
        <artifactId>jboss-app-client</artifactId>
        <version>7.0.0-SNAPSHOT</version>
    </parent>
    <artifactId>jboss-app-client-ejb</artifactId>
    <packaging>ejb</packaging>
    <name>JBoss EAP Quickstart: app-client - ejb</name>
    <url>http://www.jboss.org/products/eap</url>

    <licenses>
        <license>
            <name>Apache License, Version 2.0</name>
            <distribution>repo</distribution>
            <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
        </license>
    </licenses>

    <dependencies>
        <dependency>
            <groupId>org.wildfly</groupId>
            <artifactId>wildfly-ejb-client-bom</artifactId>
            <type>pom</type>
            <scope>provided</scope>
        </dependency>
        <dependency>
          <groupId>org.jboss.spec.javax.interceptor</groupId>
          <artifactId>jboss-interceptors-api_1.2_spec</artifactId>
          <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-ejb-plugin</artifactId>
                <version>${ejb.plugin.version}</version>
                <configuration>
                    <ejbVersion>3.1</ejbVersion>
                    <generateClient>true</generateClient>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>