text:
#ifndef sitkMemberFunctionFactoryBase_h
#define sitkMemberFunctionFactoryBase_h

#include "sitkConfigure.h"
#include "sitkPixelIDTypes.h"
#include "sitkPixelIDTypeLists.h"
#include "sitkMacro.h"
#include "sitkNonCopyable.h"

#include "Ancillary/type_list2.h"
#include "Ancillary/FunctionTraits.h"

#include <unordered_map>
#include <functional>
#include <tuple>

namespace itk
{
namespace simple
{

// this namespace is internal and not part of the external simple ITK interface
namespace detail {

// make hash function available in current name space to take priority

template <typename T> struct hash : public std::hash<T>{};

/** A utility function to chain hashes */
template<typename T>
inline void hash_combine(std::size_t& seed, const T& val)
{
  // Code from boost
  // Reciprocal of the golden ratio helps spread entropy
  //     and handles duplicates.
  std::hash<T> hasher;
  seed ^= hasher(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

template<typename S, typename T>
struct hash<std::pair<S, T>>
{
  inline size_t operator()(const std::pair<S, T>& val) const
    {
      size_t seed = 0;
      hash_combine(seed, val.first);
      hash_combine(seed, val.second);
      return seed;
    }
};

template<class... TupleArgs>
struct hash<std::tuple<TupleArgs...>>
{
private:
  // recursive hashing of std::tuple from Sarang Baheti's blog
  // https://www.variadic.xyz/2018/01/15/hashing-stdpair-and-stdtuple/
  template<size_t Idx, typename... TupleTypes>
  inline typename std::enable_if<Idx == sizeof...(TupleTypes), void>::type
  hash_combine_tup(size_t&, const std::tuple<TupleTypes...>&) const {}

  template<size_t Idx, typename... TupleTypes>
  inline typename std::enable_if<Idx < sizeof...(TupleTypes), void>::type
  hash_combine_tup(size_t& seed, const std::tuple<TupleTypes...>& tup) const
    {
      hash_combine(seed, std::get<Idx>(tup));

      //  on to next element
      hash_combine_tup<Idx+1>(seed, tup);
    }

public:
  size_t operator()(std::tuple<TupleArgs...> tupleValue) const
    {
      size_t seed = 0;
      hash_combine_tup<0>(seed, tupleValue);
      return seed;
    }
};

template< typename TMemberFunctionPointer,
          typename TKey,
          unsigned int TArity = ::detail::FunctionTraits<TMemberFunctionPointer>::arity>
class MemberFunctionFactoryBase;

/** \class MemberFunctionFactoryBase
 * \brief A base class for the MemberFunctionFactory
 *
 *  This class is for specialization needed for different arity for
 *  the templated member function pointer
 */
template< typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 0> :
    protected NonCopyable
{
protected:

  using MemberFunctionType = TMemberFunctionPointer;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;

  MemberFunctionFactoryBase( )
    :  m_PFunction( 3*typelist2::length<InstantiatedPixelIDTypeList>::value )
    { }

public:

  /**  the pointer MemberFunctionType redefined ad a tr1::function
   * object */
  using FunctionObjectType = std::function< MemberFunctionResultType ( ) >;

protected:

  using KeyType = TKey;

  /** A function which binds the objectPointer to the calling object
   *  argument in the member function pointer, and returns a function
   *  object.
   */
  static FunctionObjectType  BindObject( MemberFunctionType pfunc, ObjectType *objectPointer)
    {

      // this is really only needed because std::bind1st does not work
      // with tr1::function... that is with tr1::bind, we need to
      // specify the other arguments, and can't just bind the first
      return std::bind( pfunc,objectPointer );
    }

  using FunctionMapType = std::unordered_map< TKey, FunctionObjectType, hash<TKey> >;

  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;

};

/** \class MemberFunctionFactoryBase
 * \brief A base class for the MemberFunctionFactory
 *
 *  This class is for specialization needed for different arity for
 *  the templated member function pointer
 */
template< typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 1> :
    protected NonCopyable
{
protected:

  using MemberFunctionType = TMemberFunctionPointer;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgumentType = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;

  MemberFunctionFactoryBase( )
    :  m_PFunction( 3 * typelist2::length<InstantiatedPixelIDTypeList>::value )
    { }

public:

  /**  the pointer MemberFunctionType redefined ad a tr1::function
   * object */
  using FunctionObjectType = std::function< MemberFunctionResultType ( MemberFunctionArgumentType ) >;

protected:

  using KeyType = TKey;

  /** A function which binds the objectPointer to the calling object
   *  argument in the member function pointer, and returns a function
   *  object.
   */
  static FunctionObjectType  BindObject( MemberFunctionType pfunc, ObjectType *objectPointer)
    {
      // needed for _1 place holder
      using namespace std::placeholders;

      // this is really only needed because std::bind1st does not work
      // with tr1::function... that is with tr1::bind, we need to
      // specify the other arguments, and can't just bind the first
      return std::bind( pfunc,objectPointer, _1 );
    }

  using FunctionMapType = std::unordered_map< TKey, FunctionObjectType, hash<TKey> >;

  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;

};

template< typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 2> :
    protected NonCopyable
{
protected:

  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;

  MemberFunctionFactoryBase( )
    :  m_PFunction( 3 * typelist2::length<InstantiatedPixelIDTypeList>::value )
    { }

public:

  /**  the pointer MemberFunctionType redefined ad a tr1::function
   * object
   */
  using FunctionObjectType = std::function< MemberFunctionResultType ( MemberFunctionArgument0Type,  MemberFunctionArgument1Type) >;

protected:

  using KeyType = TKey;

  /** A function which binds the objectPointer to the calling object
   *  argument in the member function pointer, and returns a function
   *  object
   */
  static FunctionObjectType  BindObject( MemberFunctionType pfunc, ObjectType *objectPointer)
    {
      // needed for _1 place holder
      using namespace std::placeholders;

      // this is really only needed because std::bind1st does not work
      // with tr1::function... that is with tr1::bind, we need to
      // specify the other arguments, and can't just bind the first
      return std::bind( pfunc, objectPointer, _1, _2 );
    }

  using FunctionMapType = std::unordered_map< TKey, FunctionObjectType, hash<TKey> >;

  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;

};

template< typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 3> :
    protected NonCopyable
{
protected:

  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using MemberFunctionArgument2Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument2Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;

  MemberFunctionFactoryBase( )
    :  m_PFunction( 3 * typelist2::length<InstantiatedPixelIDTypeList>::value )
    { }

public:

  /**  the pointer MemberFunctionType redefined ad a tr1::function
   * object */
  using FunctionObjectType = std::function< MemberFunctionResultType ( MemberFunctionArgument0Type, MemberFunctionArgument1Type,  MemberFunctionArgument2Type) >;

protected:

  using KeyType = TKey;

  /** A function which binds the objectPointer to the calling object
   *  argument in the member function pointer, and returns a function
   *  object
   */
  static FunctionObjectType  BindObject( MemberFunctionType pfunc, ObjectType *objectPointer)
    {
      // needed for _1 place holder
      using namespace std::placeholders;

      // this is really only needed because std::bind1st does not work
      // with tr1::function... that is with tr1::bind, we need to
      // specify the other arguments, and can't just bind the first
      return std::bind( pfunc, objectPointer, _1, _2, _3 );
    }

  using FunctionMapType = std::unordered_map< TKey, FunctionObjectType, hash<TKey> >;

  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;

};

template< typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 4> :
    protected NonCopyable
{
protected:

  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using MemberFunctionArgument2Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument2Type;
  using MemberFunctionArgument3Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument3Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;

  MemberFunctionFactoryBase( )
    :  m_PFunction( 3 * typelist2::length<InstantiatedPixelIDTypeList>::value )
    { }

public:

  /**  the pointer MemberFunctionType redefined ad a tr1::function
   * object */
  using FunctionObjectType = std::function< MemberFunctionResultType ( MemberFunctionArgument0Type, MemberFunctionArgument1Type, MemberFunctionArgument2Type,  MemberFunctionArgument3Type) >;

protected:

  using KeyType = TKey;

  /** A function which binds the objectPointer to the calling object
   *  argument in the member function pointer, and returns a function
   *  object
   */
  static FunctionObjectType  BindObject( MemberFunctionType pfunc, ObjectType *objectPointer)
    {
      // needed for _1 place holder
      using namespace std::placeholders;

      // this is really only needed because std::bind1st does not work
      // with tr1::function... that is with tr1::bind, we need to
      // specify the other arguments, and can't just bind the first
      return std::bind( pfunc, objectPointer, _1, _2, _3, _4 );
    }

  using FunctionMapType = std::unordered_map< TKey, FunctionObjectType, hash<TKey> >;

  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;

};

template< typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 5> :
    protected NonCopyable
{
protected:

  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using MemberFunctionArgument2Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument2Type;
  using MemberFunctionArgument3Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument3Type;
  using MemberFunctionArgument4Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument4Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;

  MemberFunctionFactoryBase( )
    :  m_PFunction( 3 * typelist2::length<InstantiatedPixelIDTypeList>::value )
    { }

public:

  /**  the pointer MemberFunctionType redefined ad a tr1::function
   * object */
  typedef std::function< MemberFunctionResultType (
    MemberFunctionArgument0Type,
    MemberFunctionArgument1Type,
    MemberFunctionArgument2Type,
    MemberFunctionArgument3Type,
    MemberFunctionArgument4Type ) >
  FunctionObjectType;

protected:

  using KeyType = TKey;

  /** A function which binds the objectPointer to the calling object
   *  argument in the member function pointer, and returns a function
   *  object
   */
  static FunctionObjectType  BindObject( MemberFunctionType pfunc, ObjectType *objectPointer)
    {
      // needed for _1 place holder
      using namespace std::placeholders;

      // this is really only needed because std::bind1st does not work
      // with tr1::function... that is with tr1::bind, we need to
      // specify the other arguments, and can't just bind the first
      return std::bind( pfunc, objectPointer, _1, _2, _3, _4, _5 );
    }

  using FunctionMapType = std::unordered_map< TKey, FunctionObjectType, hash<TKey> >;

  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;

};

} // end namespace detail
} // end namespace simple
} // end namespace itk

#endif // sitkMemberFunctionFactoryBase_h


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright 2013-2015 microG Project Team
  ~
  ~ 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.
  -->

<manifest
	package="org.microg.nlp.api.sample"
	android:versionCode="1"
	android:versionName="0.0.1"
	xmlns:android="http://schemas.android.com/apk/res/android">

	<uses-sdk
		android:targetSdkVersion="24"
		android:minSdkVersion="9" />
	<application
		android:allowBackup="false"
		android:icon="@drawable/icon"
		android:label="@string/app_name">

		<service
			android:name=".SampleBackendService"
			android:exported="true"
			android:permission="android.permission.ACCESS_COARSE_LOCATION"
			android:label="NLPV2-Sample">
			<intent-filter>
				<action android:name="org.microg.nlp.LOCATION_BACKEND" />
			</intent-filter>
		</service>

		<service
			android:name=".SecondSampleService"
			android:exported="true"
			android:permission="android.permission.ACCESS_COARSE_LOCATION"
			android:label="NLPV2-Second">
			<intent-filter>
				<action android:name="org.microg.nlp.LOCATION_BACKEND" />
			</intent-filter>
			<meta-data
				android:name="org.microg.nlp.BACKEND_SETTINGS_ACTIVITY"
				android:value="org.microg.nlp.api.sample.SecondSettings" />
		</service>

		<activity
			android:name=".SecondSettings"
			android:exported="true"
			android:label="Second Settings Activity" />

		<service
			android:name=".ThirdSampleService"
			android:exported="true"
			android:permission="android.permission.ACCESS_COARSE_LOCATION"
			android:label="NLPV2-Random">
			<intent-filter>
				<action android:name="org.microg.nlp.LOCATION_BACKEND" />
			</intent-filter>
		</service>
	</application>
</manifest>

redpajama_set_name: RedPajamaGithub


text:
package com.telefonica.euro_iaas.paasmanager.exception;

/**
 * Exception thrown when the application type is not found.
 *
 * @author Jesus M. Movilla
 * @version $Id: $
 */
@SuppressWarnings("serial")
public class InvalidMonitoringRequest extends Exception {

    public InvalidMonitoringRequest(String msg) {
        super(msg);
    }

    public InvalidMonitoringRequest(Throwable e) {
        super(e);
    }
}


text:
/// <reference path="../fourslash.ts"/>

// Because the fourslash runner automatically opens the first file with the default setting,
// to test the openFile function, the targeted file cannot be the first one.

// @Filename: dumbFile.ts
//// var x;

// @allowJs: true
// @Filename: test.ts
//// /**
////  * @type {number}
////  */
//// var t;
//// t.

goTo.file("test.ts", /*content*/ undefined, "JS");
goTo.eof();
verify.completionListContains("toExponential");


text:
/* See license.txt for terms of usage */

/************************************************************************************************/
/* Twisties */

.twisty,
.foldableGroup > .groupHeader > .twisty,
.logRow-errorMessage .hasTwisty > .errorTitle,
.logRow-log .objectBox-array.hasTwisty,
.logRow-spy .spyHead .spyTitle,
.logGroup > .logRow,
.memberRow.hasChildren > .memberLabelCell > .memberLabel,
.memberRow.cropped > .memberLabelCell > .memberLabel,
.hasHeaders .netHrefLabel,
.objectBox-stackFrame.hasTwisty,
.objectBox-functionCall.hasTwisty,
.netPageRow > .netCol > .netPageTitle,
.cssComputedHeader > .twisty,
.breakpointHeader > .twisty,
.computedStyle.hasSelectors > .stylePropName,
.cookieRow > .cookieNameCol > .cookieNameLabel {
  background-image: url(chrome://firebug-os/skin/twistyClosed.svg);
  background-repeat: no-repeat;
  background-position: 2px calc(0.5em - 3px);
  min-height: 12px;
}

.foldableGroup.opened > .groupHeader > .twisty,
.logRow-errorMessage .hasTwisty.opened > .errorTitle,
.logRow-log .objectBox-array.hasTwisty.opened,
.logRow-spy.opened .spyHead .spyTitle,
.logGroup.opened > .logRow,
.memberRow.hasChildren.opened > .memberLabelCell > .memberLabel,
.memberRow.cropped.opened > .memberLabelCell > .memberLabel,
.nodeBox.highlightOpen > .nodeLabel > .twisty,
.nodeBox.open > .nodeLabel > .twisty,
.netRow.opened > .netCol > .netHrefLabel,
.netPageRow.opened > .netCol > .netPageTitle,
.netHeadersGroup.opened > .netInfoHeadersGroup > .twisty,
.objectBox-stackFrame.hasTwisty.opened,
.objectBox-functionCall.hasTwisty.opened,
.computedStylesGroup.opened > .cssComputedHeader > .twisty,
.breakpointBlock.opened > .breakpointHeader > .twisty,
.computedStyle.hasSelectors.opened > .stylePropName,
.cookieRow.opened > .cookieNameCol > .cookieNameLabel {
  background-image: url(chrome://firebug-os/skin/twistyOpen.svg);
  background-repeat: no-repeat;
  min-height: 12px;
}

.hasHeaders .netHrefLabel,
.netInfoHeadersTable .netHeader,
.netHrefLabel,
.cookieRow > .cookieNameCol > .cookieNameLabel {
  background-position: 2px 50%;
}

/******************************************************************************/
/* Watch side panel */

.closeButton {
  display: inline-block;
  width: 16px;
  height: 16px;
  background: url(chrome://firebug/skin/win/close.svg) no-repeat 0 0;
}

.closeButton:hover {
  filter: url(resource://firebugui/filters.svg#darken);
}

.closeButton:active {
  filter: url(resource://firebugui/filters.svg#deepDarken);
}


text:
enyo.kind({
	name: "enyo.sample.CanvasPrimitivesSample",
	classes: "enyo-unselectable onyx",
	components: [
		{kind: "enyo.Canvas", components: [
			{kind: "enyo.canvas.Circle", bounds:{t:60, l:60, w:30}, color:"lightcoral", outlineColor:"red"},
			{kind: "enyo.canvas.Rectangle", bounds:{t:110, l:30, w:100, h:50}, color:"lightblue", outlineColor:"blue"},
			{kind: "enyo.canvas.Text", bounds:{t:200, l:30, h:40, w:200}, color:"green", text:"enyo.js", font:"20pt Cooper Black"},
			{kind: "enyo.canvas.Image", bounds:{t:230, l:30, h:32, w:32}, src:"assets/astrologer.png"},
			{kind: "enyo.sample.BlinkyTriangle", bounds:{t:290, l:30, w:60, h:60}, color:"gold", outlineColor:"orange", src:"assets/astrologer.png"}
		]}
	],
	create: function() {
		this.inherited(arguments);
		// Code to monitor image and redraw once loaded
		var img = new Image();
		img.src = this.$.image.src;
		img.onload = enyo.bind(this, function() {
			this.$.canvas.update();
		});
	}
});

enyo.kind({
	name: "enyo.sample.BlinkyTriangle",
	kind: "enyo.canvas.Shape",
	published: {
		highlightColor:"yellow"
	},
	renderSelf: function(ctx) {
		ctx.beginPath();
		ctx.moveTo(this.bounds.l + this.bounds.w/2, this.bounds.t);
		ctx.lineTo(this.bounds.l, this.bounds.t + this.bounds.h);
		ctx.lineTo(this.bounds.l + this.bounds.w, this.bounds.t + this.bounds.h);
		ctx.lineTo(this.bounds.l + this.bounds.w/2, this.bounds.t);
		this.draw(ctx);
	},
	create: function() {
		this.inherited(arguments);
		this.jobName = "blinkMe_" + this.id;
		this.blinkMe();
	},
	destroy: function() {
		enyo.job.stop(this.jobName);
		this.inherited(arguments);
	},
	blinkMe: function() {
		var color = this.color;
		this.color = this.highlightColor;
		this.highlightColor = color;
		this.container.update();
		enyo.job(this.jobName, enyo.bind(this, "blinkMe"), 500);
	}
});


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.skysport.inerfaces.mapper.material.MaterialPositionManageDao">
    <sql id="searchInfoSql">
		id AS id,
		position_id AS natrualkey,
		position_name AS name,
		remark AS remark,
		update_time AS updateTime
	</sql>
    <select id="queryInfo" resultType="MaterialPositionInfo">
        select
        <include refid="searchInfoSql"/>
        FROM t_kf_material_position
        WHERE position_id =#{position_id}
        limit 1
    </select>

    <select id="listInfosCounts" resultType="Integer">
		SELECT COUNT(*) FROM
		t_kf_material_position where del_flag=0
	</select>

    <select id="listFilteredInfosCounts" resultType="Integer">
        SELECT COUNT(*) FROM t_kf_material_position where del_flag=0
        <if test="searchValue !=null and searchValue != ''">
            and (
            position_id like concat('%',#{searchValue},'%') or
            position_name like concat('%',#{searchValue},'%') or
            remark like concat('%',#{searchValue},'%') or
            )
        </if>

    </select>

    <select id="searchInfos" resultType="MaterialPositionInfo">
        SELECT
        <include refid="searchInfoSql"/>
        FROM t_kf_material_position
        WHERE del_flag=0
        <if test="searchValue!=null and searchValue != ''">
            and (
            position_id like concat('%',#{searchValue},'%') or
            position_name like concat('%',#{searchValue},'%') or
            remark like concat('%',#{searchValue},'%') or
            )
        </if>
        <if test="orderColumn!=null and orderColumn != ''">
            ORDER BY ${orderColumn} ${orderDir}
        </if>
        limit #{start} ,#{length}

    </select>

    <update id="updateInfo">
		update t_kf_material_position 	set
		position_name=#{natrualkey},
		remark=#{remark}
		WHERE position_id =#{natrualkey}
	</update>

    <insert id="add">
		insert into
		t_kf_material_position (position_id,position_name,remark)
		values (#{natrualkey},#{name},#{remark})
	</insert>

    <update id="del">
		update t_kf_material_position
		set  del_flag=1
		where position_id =#{natrualkey}
	</update>

    <select id="queryCurrentSeqNo" resultType="String">
		select case when  max(position_id) is NULL then 0 else max(position_id) end from t_kf_material_position
	</select>

    <!--信息下拉列表-->
    <select id="querySelectList" resultType="CommonBean">
        select
        position_id AS natrualkey,
        position_name AS name
        from t_kf_material_position
        where del_flag=0
        <if test="name!=null and name != ''">
            and upper(position_name) like concat('%',#{name},'%')
        </if>
    </select>

</mapper>


text:
class IsaCodeBlock
{
private:
    // The label number of the loop, if any.
    int label_ = kNoLabel;

    // How many times to do the loop, if applicable.
    int iteration_count_ = 1;

    // How many nodes points on me.
    std::vector<Instruction*> instructions_;

    // Next code block.
    IsaCodeBlock* next_ = nullptr;

    // Next code block in case of branch is true. null if point to the upper loop to avoid loops in the graph.
    IsaCodeBlock* true_ = nullptr;

    // Next code block in case of branch is false.
    IsaCodeBlock* false_ = nullptr;

public:
    ~IsaCodeBlock() = default;

    int GetLabel() const {return label_;}
    IsaCodeBlock* GetNext() {return next_;}
    IsaCodeBlock* GetTrue() {return true_;}
    IsaCodeBlock* GetFalse() {return false_;}
    int GetIterationCount() const {return iteration_count_;}
    const std::vector<Instruction*>& GetIsaCodeBlockInstructions() const { return instructions_;}

    void SetNext(IsaCodeBlock* p) { next_ = p; }
    void SetTrue(IsaCodeBlock*  p)  { true_ = p; }
    void SetFalse(IsaCodeBlock* p) { false_ = p; }
    void SetIterationCount(int iteration_count) { iteration_count_ = iteration_count; }

    friend class ISAProgramGraph;
};

// This class is a utility class that can build, destroy, search and traverse ISAProgramGraph.
// The LabelNodeSet is saved as well so finding a label will be efficient
class ISAProgramGraph
{
public:
    enum AnalyzeDataPath
    {
        kCalcAll = 0,
        kCalcTrue = 1,
        kCalcFalse = 2,
        kCalcPathCount = 3,
    };

    // The number of instruction in each category
    struct NumOfInstructionsInCategory
    {
        unsigned int instruction_count_scalar_memory_read = 0;
        unsigned int instruction_count_scalar_memory_write = 0;
        unsigned int instruction_count_scalar_alu = 0;
        unsigned int instruction_count_vector_memory_read = 0;
        unsigned int instruction_count_vector_memory_write = 0;
        unsigned int instruction_count_vector_alu = 0;
        unsigned int instruction_count_lds = 0;
        unsigned int instruction_count_gds = 0;
        unsigned int instruction_count_export = 0;
        unsigned int instruction_count_atomics = 0;
        unsigned int calculated_cycles = 0;
        unsigned int calculated_cycles_per_wavefront = 0;

        NumOfInstructionsInCategory& operator=(const NumOfInstructionsInCategory& original)
        {
            instruction_count_scalar_memory_read = original.instruction_count_scalar_memory_read;
            instruction_count_scalar_memory_write = original.instruction_count_scalar_memory_write;
            instruction_count_scalar_alu = original.instruction_count_scalar_alu;
            instruction_count_vector_memory_read = original.instruction_count_vector_memory_read;
            instruction_count_vector_memory_write = original.instruction_count_vector_memory_write;
            instruction_count_vector_alu = original.instruction_count_vector_alu;
            instruction_count_lds = original.instruction_count_lds;
            instruction_count_gds = original.instruction_count_gds;
            instruction_count_export = original.instruction_count_export;
            instruction_count_atomics = original.instruction_count_atomics;
            calculated_cycles = original.calculated_cycles;
            calculated_cycles_per_wavefront = original.calculated_cycles_per_wavefront;
            return *this;
        };
    };

private:
    class LabelNodeSet
    {
    public:
        int label_;
        int iteration_count_;
        IsaCodeBlock* node_code_block_;

        LabelNodeSet()
        {
            label_ = kNoLabel;
            node_code_block_ = NULL;
            iteration_count_ = 1;
        }
    };

    class LabelNodeSetCompare
    {
    public:
        bool operator()(const LabelNodeSet& lhs, const LabelNodeSet& rhs) const
        {
            if (lhs.label_ < rhs.label_)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    };

private:
    // Head of the entire ISA graph.
    IsaCodeBlock* isa_code_block_;

    // Container for quick node search.
    std::set<LabelNodeSet, LabelNodeSetCompare> node_set_;

    // Fake label for nodes with no original label in the ISA.
    int next_label_;
    int loop_iteration_count_;

    // Internal function that builds the graph out of the instruction vector.
    bool BuildISAProgramStructureInternal(std::vector<Instruction*>& Instructions, std::vector<Instruction*>::const_iterator instIterator, IsaCodeBlock* pHeadIsaNode);

    // Part of ISA program graph. when a loop is discovered update the default num of iteration.
    bool UpdateNumOfIteration(std::vector<Instruction*>& Instructions, IsaCodeBlock* pLoop, const std::vector<Instruction*>::const_iterator iIterator);

    // Internal recursive search.
    void GetInstructionsOfProgramPathInternal(std::set<LabelNodeSet, LabelNodeSetCompare>& PathInstructionsSet, IsaCodeBlock* pHeadISACodeBlock, int iPath, int iNumOfIterations);

    // Create a new node, updates it's label and update the node set.
    IsaCodeBlock* CreateNewNode(int label_);

    // The main function that counts the instruction in the specific ISA graph. this is the main idea of the entire analysis.
    void CountInstructions(std::set<ISAProgramGraph::LabelNodeSet, ISAProgramGraph::LabelNodeSetCompare> PathInstructionsSet, ISAProgramGraph::NumOfInstructionsInCategory& NumOfInstructionsInCategory);

public:
    ISAProgramGraph();
    ~ISAProgramGraph() = default;

    // Go through the instructions parsed in ParseToVector and build the ISA program graph.
    bool BuildISAProgramStructure(std::vector<Instruction*>& Instructions);

     // Destroy ALL the program graph.
    void DestroyISAProgramStructure();

    // Return the node with the desired label
    IsaCodeBlock* LabelSearcher(int label_);

    // Return the vector of instruction in a specific path (all/true/false)
    void GetInstructionsOfProgramPath(std::set<LabelNodeSet, LabelNodeSetCompare>& PathInstructionsSet, int iPath);

    // Save the graph in GRAPHVIZ format.
    void DumpGraph(std::set<ISAProgramGraph::LabelNodeSet, ISAProgramGraph::LabelNodeSetCompare> PathInstructionsSet, std::string sFileName);

    // Traverse through all Graph Paths (ALL/TRUE/FALSE) and count the instructions.
    void GetNumOfInstructionsInCategory(ISAProgramGraph::NumOfInstructionsInCategory NumOfInstructionsInCategory[kCalcPathCount], std::string sDumpGraph);

    void SetNumOfLoopIteration(int iNumOfLoopIteration);
    int GetNumOfLoopIteration();
};

#endif // RGA_RADEONGPUANALYZERBACKEND_SRC_EMULATOR_PARSER_BE_ISA_PROGRAM_GRAPH_H_


text:
namespace vapula
{
	class Library;

	class LibraryHub : Uncopiable
	{
	public:
		LibraryHub();
		~LibraryHub();

	private:
		Lock* _Lock;
		list<Library*> _Libraries;

	public:
		list<Library*>& GetInnerData();

	public:
		int Count();

		Library* Find(pcstr id);

		void Add(Library* library);

		void Remove(Library* library);

		void RemoveAll();
	};
}


text:
<script type="text/javascript">
<!--
function checkConfig()
{
  if (editconnection.confluence_port.value != "" && !isInteger(editconnection.confluence_port.value))
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.ConfPortMustBeAnInteger'))");
    editconnection.confluence_port.focus();
    return false;
  }

  if (editconnection.confluence_host.value != "" && editconnection.confluence_host.value.indexOf("/") != -1)
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.HostMustNotIncludeSlash'))");
    editconnection.confluence_host.focus();
    return false;
  }

  if (editconnection.confluence_path.value != "" && !(editconnection.confluence_path.value.indexOf("/") == 0))
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.PathMustBeginWithASlash'))");
    editconnection.confluence_path.focus();
    return false;
  }

  return true;
}

function checkConfigForSave()
{

  if (editconnection.confluence_host.value == "")
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.HostMustNotBeNull'))");
    SelectTab("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.Server'))");
    editconnection.confluence_host.focus();
    return false;
  }

  if (editconnection.confluence_host.value != "" && editconnection.confluence_host.value.indexOf("/") != -1)
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.HostMustNotIncludeSlash'))");
    SelectTab("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.Server'))");
    editconnection.confluence_host.focus();
    return false;
  }

  if (editconnection.confluence_port.value != "" && !isInteger(editconnection.confluence_port.value))
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.PortMustBeAnInteger'))");
    SelectTab("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.Server'))");
    editconnection.confluence_port.focus();
    return false;
  }

  if (editconnection.confluence_path.value == "")
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.PathMustNotBeNull'))");
    SelectTab("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.Server'))");
    editconnection.confluence_path.focus();
    return false;
  }

  if (editconnection.confluence_path.value != "" && !(editconnection.confluence_path.value.indexOf("/") == 0))
  {
    alert("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.PathMustBeginWithASlash'))");
    SelectTab("$Encoder.bodyJavascriptEscape($ResourceBundle.getString('ConfluenceAuthorityConnector.Server'))");
    editconnection.confluence_path.focus();
    return false;
  }

  return true;
}
//-->
</script>


text:
int main(int argc, char **argv)
{
	std::unique_ptr<EAbstractAnalyticFactory> analyticFactory(new AnalyticFactory);
	std::unique_ptr<EAbstractDataFactory> dataFactory(new DataFactory);
	EAbstractAnalyticFactory::setInstance(move(analyticFactory));
	EAbstractDataFactory::setInstance(move(dataFactory));

	int status {0};
	auto ASSERT_TEST = [&status, argc, argv](QObject* object)
	{
		status |= QTest::qExec(object, argc, argv);
		delete object;
	};

	try
	{
		ASSERT_TEST(new TestClusterMatrix);
		ASSERT_TEST(new TestCorrelationMatrix);
		// ASSERT_TEST(new TestExportCorrelationMatrix);
		// ASSERT_TEST(new TestExportExpressionMatrix);
		ASSERT_TEST(new TestExpressionMatrix);
		// ASSERT_TEST(new TestImportCorrelationMatrix);
		// ASSERT_TEST(new TestImportExpressionMatrix);
		// ASSERT_TEST(new TestRMT);
		// ASSERT_TEST(new TestSimilarity);
	}
	catch ( EException& e )
	{
		QTextStream stream(stdout);
		stream << QObject::tr("CRITICAL ERROR\n\n");
		stream << e.title() << QObject::tr("\n\n");
		stream << e.details() << QObject::tr("\n\n");
		stream << QObject::tr("File: %1\nLine: %2\nFunction: %3\n")
			.arg(e.fileName())
			.arg(e.line())
			.arg(e.functionName());
	}

	return status;
}


text:
/*
The poly symmetry algorithm traverses the topology of a polygon mesh to
calculate the symmetry of its components. It does this by examining pairs of
edges that are known to be symmetrical, walking the vertices of the faces
adjacent to the edges, establishing a symmetry table.

Because an edge may have two adjacent faces, the user must provide starting
data for the algorithm in the form of a pair of symmetrical faces, edges,
and vertices. The edges must be on the faces, and the vertices must be on
the edges.

From this initial condition, we can assume that the other vertices
on the edges are symmetrical. Once an edge, the the vertices on it, and one
of the faces adjacent to it have had their symmetry computed, the rest of the
components on the shell can have their symmetry computed thus:

    > Start on an edge with known symmetry, whose vertices have known
      symmetry, and is on a face with known symmetry.
    > Get the other face connected to the edge - its symmetry is unknown.
    > Starting at either vertex on the edge, walk to its other neighboring
      vertex on the face. A neighboring vertex is a vertex on the same face
      connected by an edge. On the edge that is symmetrical to this edge,
      do the same. These neighboring vertices are symmetrical, as is the edge
      that was traversed to find them.
    > Repeat until all the vertices on the face have had their
      symmetry computed.
    > Repeat the algorithm, starting at each pair of traversed edges, until
      the symmetry of all components on this shell are computed.
*/

// TODO - unintuitive results returned if the mesh does not have a center edge loop whose vertices are symmetrical to themselves.

#include "meshData.h"
#include "polySymmetry.h"
#include "selection.h"
#include "util.h"

#include <algorithm>
#include <queue>
#include <utility>
#include <vector>

#include <maya/MDagPath.h>
#include <maya/MFnMesh.h>

using namespace std;

PolySymmetryData::PolySymmetryData()
{
    MeshData meshData = MeshData();

    examinedEdges = vector<bool>();
    examinedFaces = vector<bool>();
    examinedVertices = vector<bool>();

    vertexSymmetryIndices = vector<int>();
    edgeSymmetryIndices = vector<int>();
    faceSymmetryIndices = vector<int>();

    vertexSides = vector<int>();
    edgeSides = vector<int>();
    faceSides = vector<int>();

    leftSideVertexIndices = vector<int>();
}

PolySymmetryData::~PolySymmetryData()
{
    this->clear();
}

void PolySymmetryData::initialize(MDagPath &mesh)
{
    meshData.unpackMesh(mesh);
    this->reset();
}

void PolySymmetryData::clear()
{
    meshData.clear();
    this->reset();
}

void PolySymmetryData::reset()
{
    examinedEdges.clear();
    examinedFaces.clear();
    examinedVertices.clear();

    edgeSymmetryIndices.clear();
    faceSymmetryIndices.clear();
    vertexSymmetryIndices.clear();

    edgeSides.clear();
    faceSides.clear();
    vertexSides.clear();

    leftSideVertexIndices.clear();

    examinedEdges.resize(meshData.numberOfEdges, false);
    examinedFaces.resize(meshData.numberOfFaces, false);
    examinedVertices.resize(meshData.numberOfVertices, false);

    edgeSymmetryIndices.resize(meshData.numberOfEdges, -1);
    faceSymmetryIndices.resize(meshData.numberOfFaces, -1);
    vertexSymmetryIndices.resize(meshData.numberOfVertices, -1);

    edgeSides.resize(meshData.numberOfEdges, -1);
    faceSides.resize(meshData.numberOfFaces, -1);
    vertexSides.resize(meshData.numberOfVertices, -1);
}

void PolySymmetryData::findSymmetricalVertices(ComponentSelection &selection)
{
    queue<pair<int, int>> symmetricalEdgesQueue = queue<pair<int, int>>();
    symmetricalEdgesQueue.push(selection.edgeIndices);

    if (selection.leftVertexIndex != -1)
    {
        leftSideVertexIndices.push_back(selection.leftVertexIndex);
    }

    this->findFirstSymmetricalVertices(selection);

    while (!symmetricalEdgesQueue.empty())
    {
        pair<int, int> edgePair = symmetricalEdgesQueue.front();
        symmetricalEdgesQueue.pop();

        markSymmetricalEdges(edgePair.first, edgePair.second);

        pair<int, int> facesPair = getUnexaminedFaces(edgePair);

        if (facesPair.first == -1 || facesPair.second == -1)
        {
            continue;
        }

        markSymmetricalFaces(facesPair.first, facesPair.second);

        this->findSymmetricalVerticesOnFace(facesPair);
        this->findSymmetricalEdgesOnFace(symmetricalEdgesQueue, facesPair.first);
    }
}

void PolySymmetryData::findFirstSymmetricalVertices(ComponentSelection &selection)
{
    markSymmetricalVertices(selection.vertexIndices.first, selection.vertexIndices.second);
    markSymmetricalFaces(selection.faceIndices.first, selection.faceIndices.second);

    int vertex0 = meshData.edgeData[selection.edgeIndices.first].connectedVertices[0];
    int vertex1 = meshData.edgeData[selection.edgeIndices.first].connectedVertices[1];

    int nextVertex0 = examinedVertices[vertex0] ? vertex1 : vertex0;

    vertex0 = meshData.edgeData[selection.edgeIndices.second].connectedVertices[0];
    vertex1 = meshData.edgeData[selection.edgeIndices.second].connectedVertices[1];

    int nextVertex1 = examinedVertices[vertex0] ? vertex1 : vertex0;

    markSymmetricalVertices(nextVertex0, nextVertex1);

    this->findSymmetricalVerticesOnFace(selection.faceIndices);
}

pair<int, int> PolySymmetryData::getUnexaminedFaces(pair<int, int> &edgePair)
{
    vector<int> sharedFaces = intersection(
        meshData.edgeData[edgePair.first].connectedFaces,
        meshData.edgeData[edgePair.second].connectedFaces
    );

    int face0 = -1;
    int face1 = -1;

    if (sharedFaces.size() > 0)
    {
        for (int &faceIndex : sharedFaces)
        {
            if (this->examinedFaces[faceIndex])
            {
                continue;
            }

            if (face0 == -1)
            {
                face0 = faceIndex;
                continue;
            }

            if (face1 == -1)
            {
                face1 = faceIndex;
                continue;
            }
        }
    } else {
        face0 = getUnexaminedFace(edgePair.first);
        face1 = getUnexaminedFace(edgePair.second);
    }

    return pair<int, int>(face0, face1);
}

int PolySymmetryData::getUnexaminedFace(int &edgeIndex)
{
    int result = -1;

    for (int &faceIndex : meshData.edgeData[edgeIndex].connectedFaces)
    {
        if (!examinedFaces[faceIndex])
        {
            result = faceIndex;
            break;
        }
    }

    return result;
}

void PolySymmetryData::findSymmetricalVerticesOnFace(pair<int, int> &facePair)
{
    queue<int> faceVerticesQueue = queue<int>();

    for (int &v : meshData.faceData[facePair.first].connectedVertices)
    {
        if (examinedVertices[v])
        {
            faceVerticesQueue.push(v);
        }
    }

    while (!faceVerticesQueue.empty())
    {
        int vertex0 = faceVerticesQueue.front();
        faceVerticesQueue.pop();

        int vertex1 = vertexSymmetryIndices[vertex0];

        int nextVertex0 = getUnexaminedVertexSibling(vertex0, facePair.first);
        int nextVertex1 = getUnexaminedVertexSibling(vertex1, facePair.second);

        if (nextVertex0 == -1 || nextVertex1 == -1)
        {
            continue;
        }

        markSymmetricalVertices(nextVertex0, nextVertex1);

        faceVerticesQueue.push(nextVertex0);
    }
}

void PolySymmetryData::findSymmetricalEdgesOnFace(queue<pair<int, int>> &symmetricalEdgesQueue, int &faceIndex)
{
    int vertex0;
    int vertex1;

    int edgeIndex;

    for (int &e : meshData.faceData[faceIndex].connectedEdges)
    {
        if (examinedEdges[e]) { continue; }

        vertex0 = vertexSymmetryIndices[meshData.edgeData[e].connectedVertices[0]];
        vertex1 = vertexSymmetryIndices[meshData.edgeData[e].connectedVertices[1]];

        if (vertex0 == -1 || vertex1 == -1)
        {
            continue;
        }

        vector<int> sharedEdges = intersection(
            meshData.vertexData[vertex0].connectedEdges,
            meshData.vertexData[vertex1].connectedEdges
        );

        if (sharedEdges.size() != 1) { continue; }

        edgeIndex = sharedEdges[0];

        if (!examinedEdges[edgeIndex])
        {
            symmetricalEdgesQueue.push(pair<int, int>(e, edgeIndex));
        }

        markSymmetricalEdges(e, edgeIndex);

    }
}

int PolySymmetryData::getUnexaminedVertexSibling(int &vertexIndex, int &faceIndex)
{
    int result = -1;

    for (int &v : meshData.vertexData[vertexIndex].faceVertexSiblings[faceIndex])
    {
        if (examinedVertices[v])
        {
            continue;
        }

        result = v;
        break;
    }

    return result;
}

void PolySymmetryData::findVertexSides(vector<int> &leftSideVertexIndices)
{
    int LEFT = 1;
    int RIGHT = -1;
    int CENTER = 0;

    vector<int> visitedVertices(meshData.numberOfVertices, false);
    queue<int> nextVertexQueue = queue<int>();

    vertexSides.clear();
    vertexSides.resize(meshData.numberOfVertices, 0);

    for (int &i : leftSideVertexIndices)
    {
        nextVertexQueue.push(i);
        vertexSides[i] = LEFT;
    }

    int vertexIndex = -1;

    while (!nextVertexQueue.empty())
    {
        vertexIndex = nextVertexQueue.front();
        nextVertexQueue.pop();

        if (visitedVertices[vertexIndex]) { continue; }

        visitedVertices[vertexIndex] = true;

        if (vertexSymmetryIndices[vertexIndex] == vertexIndex)
        {
            vertexSides[vertexIndex] = CENTER;
        } else {
            vertexSides[vertexIndex] = LEFT;

            for (int &i : meshData.vertexData[vertexIndex].connectedVertices)
            {
                if (!visitedVertices[i] && vertexSymmetryIndices[i] != vertexIndex)
                {
                    nextVertexQueue.push(i);
                }
            }
        }
    }

    for (int &i : leftSideVertexIndices)
    {
        nextVertexQueue.push(vertexSymmetryIndices[i]);
        vertexSides[vertexSymmetryIndices[i]] = RIGHT;
    }

    while (!nextVertexQueue.empty())
    {
        vertexIndex = nextVertexQueue.front();
        nextVertexQueue.pop();

        if (visitedVertices[vertexIndex]) { continue; }

        visitedVertices[vertexIndex] = true;

        if (vertexSymmetryIndices[vertexIndex] == vertexIndex)
        {
            vertexSides[vertexIndex] = CENTER;
        } else {
            vertexSides[vertexIndex] = RIGHT;

            for (int &i : meshData.vertexData[vertexIndex].connectedVertices)
            {
                if (!visitedVertices[i])
                {
                    nextVertexQueue.push(i);
                }
            }
        }
    }
}

void PolySymmetryData::markSymmetricalVertices(int &i0, int &i1)
{
    vertexSymmetryIndices[i0] = i1;
    vertexSymmetryIndices[i1] = i0;

    examinedVertices[i0] = true;
    examinedVertices[i1] = true;
}

void PolySymmetryData::markSymmetricalEdges(int &i0, int &i1)
{
    edgeSymmetryIndices[i0] = i1;
    edgeSymmetryIndices[i1] = i0;

    examinedEdges[i0] = true;
    examinedEdges[i1] = true;
}

void PolySymmetryData::markSymmetricalFaces(int &i0, int &i1)
{
    faceSymmetryIndices[i0] = i1;
    faceSymmetryIndices[i1] = i0;

    examinedFaces[i0] = true;
    examinedFaces[i1] = true;
}

void PolySymmetryData::finalizeSymmetry()
{
    int LEFT = 1;
    int RIGHT = -1;
    int CENTER = 0;

    for (int i = 0; i < meshData.numberOfEdges; i++)
    {
        int sv0 = vertexSides[meshData.edgeData[i].connectedVertices[0]];
        int sv1 = vertexSides[meshData.edgeData[i].connectedVertices[1]];

        if (sv0 == CENTER && sv1 == CENTER)
        {
            edgeSides[i] = CENTER;
        } else if (sv0 == RIGHT || sv1 == RIGHT) {
            edgeSides[i] = RIGHT;
        } else if (sv0 == LEFT || sv1 == LEFT) {
            edgeSides[i] = LEFT;
        }
    }

    vector<int> faceVertexSides;

    for (int i = 0; i < meshData.numberOfFaces; i++)
    {
        faceVertexSides.resize(meshData.faceData[i].connectedVertices.size());

        for (int j = 0; j < meshData.faceData[i].connectedVertices.size(); j++)
        {
            faceVertexSides[j] = vertexSides[meshData.faceData[i].connectedVertices[j]];
        }

        bool onTheLeft = contains(faceVertexSides, LEFT);
        bool onTheRight = contains(faceVertexSides, RIGHT);

        faceSides[i] = (onTheLeft ? LEFT : CENTER) + (onTheRight ? RIGHT : CENTER);
    }
}


text:
The `Field` class represents a field value. It is associated (and used by) an instance of the model.

## FieldDescriptor
The `FieldDescriptor` class represents a field meta information. Every `Field` instance has a link to an instance of this class, and instances of this class are referenced by the model class.

At its core, FieldDescriptor contains a minimum amount of information:

* **`name`**. The name of the field. This will be used when creating queries and schemas.
* **`required`**. True if this field is required.
* **`default`**. A default value when the field isn't set. This can be specified when instanciated, or can be updated, or will revert to not being defined if the field is not `required`, or a default default (ie. empty string for string field descriptors).

This class also contains a number of methods to convert from and to queries, values, etc.

## Specifying Fields in Models
When defining a Model, it is important to either use `FieldDescriptor` instances or `Field` classes. No other


text:
  Tourville-sur-Pont-Audemer est
       un village
       géographiquement positionné dans le département de l'Eure en Haute-Normandie. On dénombrait 712 habitants en 2008.

Le nombre d'habitations, à Tourville-sur-Pont-Audemer, se décomposait en 2011 en sept appartements et 308 maisons soit
 un marché relativement équilibré.

La ville compte quelques  aménagements, elle dispose, entre autres, de une boucle de randonnée.

À proximité de Tourville-sur-Pont-Audemer sont positionnées géographiquement les communes de
Triqueville à 4 km, 282 habitants,
Manneville-sur-Risle localisée à 3 km, 1 261 habitants,
Les Préaux à 2 km, 441 habitants,
Toutainville située à 4 km, 1 102 habitants,
Selles à 3 km, 420 habitants,
Campigny à 3 km, 836 habitants,
 entre autres. De plus, Tourville-sur-Pont-Audemer est située à seulement 28 km de Lisieux.

Si vous envisagez de demenager à Tourville-sur-Pont-Audemer, vous pourrez facilement trouver une maison à vendre.

À Tourville-sur-Pont-Audemer, le prix moyen à l'achat d'un appartement s'évalue à zero € du m² en vente. La valeur moyenne d'une maison à l'achat se situe à 1 891 € du m². À la location la valorisation moyenne se situe à 6,64 € du m² par mois.