text:
"use strict";

(function(app) {
    app.factory("notifierService", function() {
        toastr.options = {
            "debug": false,
            "positionClass": "toast-bottom-right",
            "onclick": null,
            "fadeIn": 300,
            "fadeOut": 1000,
            "timeOut": 3000,
            "extendedTimeOut": 1000
        };

        var notifySuccess = function(message) {
            toastr.success(message);
        };
        var notifyError = function(message) {
            toastr.error(message);
        };
        var notifyWarning = function(message) {
            toastr.warning(message);
        };
        var notifyInfo = function(message) {
            toastr.info(message);
        };

        return {
            notifySuccess: notifySuccess,
            notifyError: notifyError,
            notifyWarning: notifyWarning,
            notifyInfo: notifyInfo
        };
    });
})(_app);


text:
const udify = require('../../../data/udify')

module.exports = async function updateRole (obj
  , { id, input: { name, parent, resources } }
  , { state: { dbPool, loaders } }) {
  if (id < 4 && parent) throw new Error('Default roles can not have a parent')

  await udify.update(dbPool, 'bm_web_roles', { name, parent_role_id: parent || null }, { role_id: id })

  // Do not allow users to change admin role resources in case they lock themselves out
  if (id === 3 || id === '3') return loaders.role.ids.load(id)

  for (const resource of resources) {
    const ids = resource.permissions // @TODO reduce and Promise.all
      .filter(perm => perm.allowed)
      .map(perm => perm.id)

    if (!ids.length) {
      await dbPool.query(`UPDATE bm_web_role_resources
        SET
          value = 0
        WHERE
          role_id = ? AND resource_id = ?
      `, [id, resource.id])
    } else {
      await dbPool.query(`UPDATE bm_web_role_resources
        SET
          value = (SELECT
              SUM(value)
            FROM
              bm_web_resource_permissions
            WHERE
              permission_id IN (?))
        WHERE
          role_id = ? AND resource_id = ?
      `, [ids, id, resource.id])
    }
  }

  return loaders.role.ids.load(id)
}

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using SevenDigital.Api.Schema.Attributes;

namespace SevenDigital.Api.Schema.Translations
{
	[ApiEndpoint("translations")]
	[XmlRoot("translations")]
	[Serializable]
	public class TranslationList : HasPaging
	{
		[XmlElement("translation")]
		public List<Translation> TranslationItems { get; set; }
	}

	public class Translation
	{
		[XmlElement("key")]
		public string Key { get; set; }

		[XmlElement("translatedText")]
		public string TranslatedText { get; set; }
	}
}


text:
package com.johnsnowlabs.ml.tensorflow

import com.johnsnowlabs.ml.tensorflow.sentencepiece.{SentencePieceWrapper, SentencepieceEncoder}
import com.johnsnowlabs.ml.tensorflow.sign.{ModelSignatureConstants, ModelSignatureManager}
import com.johnsnowlabs.nlp.{ActivationFunction, Annotation}
import com.johnsnowlabs.nlp.annotators.common._
import org.tensorflow.ndarray.buffer.IntDataBuffer

import scala.collection.JavaConverters._

/** @param tensorflowWrapper
  *   XLNet Model wrapper with TensorFlow Wrapper
  * @param spp
  *   XLNet SentencePiece model with SentencePieceWrapper
  * @param configProtoBytes
  *   Configuration for TensorFlow session
  * @param tags
  *   labels which model was trained with in order
  * @param signatures
  *   TF v2 signatures in Spark NLP
  */
class TensorflowXlnetClassification(
    val tensorflowWrapper: TensorflowWrapper,
    val spp: SentencePieceWrapper,
    configProtoBytes: Option[Array[Byte]] = None,
    tags: Map[String, Int],
    signatures: Option[Map[String, String]] = None)
    extends Serializable
    with TensorflowForClassification {

  val _tfXlnetSignatures: Map[String, String] =
    signatures.getOrElse(ModelSignatureManager.apply())

  // keys representing the input and output tensors of the XLNet model
  override protected val sentenceStartTokenId: Int = spp.getSppModel.pieceToId("<cls>")
  override protected val sentenceEndTokenId: Int = spp.getSppModel.pieceToId("<sep>")
  override protected val sentencePadTokenId: Int = spp.getSppModel.pieceToId("<pad>")

  private val sentencePieceDelimiterId = spp.getSppModel.pieceToId("▁")

  def tokenizeWithAlignment(
      sentences: Seq[TokenizedSentence],
      maxSeqLength: Int,
      caseSensitive: Boolean): Seq[WordpieceTokenizedSentence] = {

    val encoder =
      new SentencepieceEncoder(spp, caseSensitive, delimiterId = sentencePieceDelimiterId)

    val sentenceTokenPieces = sentences.map { s =>
      val trimmedSentence = s.indexedTokens.take(maxSeqLength - 2)
      val wordpieceTokens =
        trimmedSentence.flatMap(token => encoder.encode(token)).take(maxSeqLength)
      WordpieceTokenizedSentence(wordpieceTokens)
    }
    sentenceTokenPieces
  }

  def tokenizeDocument(
      docs: Seq[Annotation],
      maxSeqLength: Int,
      caseSensitive: Boolean): Seq[WordpieceTokenizedSentence] = {
    Seq.empty[WordpieceTokenizedSentence]
  }

  def tag(batch: Seq[Array[Int]]): Seq[Array[Array[Float]]] = {
    val tensors = new TensorResources()

    val maxSentenceLength = batch.map(encodedSentence => encodedSentence.length).max
    val batchLength = batch.length

    val tokenBuffers: IntDataBuffer = tensors.createIntBuffer(batchLength * maxSentenceLength)
    val maskBuffers: IntDataBuffer = tensors.createIntBuffer(batchLength * maxSentenceLength)
    val segmentBuffers: IntDataBuffer = tensors.createIntBuffer(batchLength * maxSentenceLength)

    // [nb of encoded sentences , maxSentenceLength]
    val shape = Array(batch.length.toLong, maxSentenceLength)

    batch.zipWithIndex
      .foreach { case (sentence, idx) =>
        val offset = idx * maxSentenceLength
        tokenBuffers.offset(offset).write(sentence)
        maskBuffers
          .offset(offset)
          .write(sentence.map(x => if (x == sentencePadTokenId) 0 else 1))
        segmentBuffers.offset(offset).write(Array.fill(maxSentenceLength)(0))
      }

    val runner = tensorflowWrapper
      .getTFSessionWithSignature(configProtoBytes = configProtoBytes, initAllTables = false)
      .runner

    val tokenTensors = tensors.createIntBufferTensor(shape, tokenBuffers)
    val maskTensors = tensors.createIntBufferTensor(shape, maskBuffers)
    val segmentTensors = tensors.createIntBufferTensor(shape, segmentBuffers)

    runner
      .feed(
        _tfXlnetSignatures.getOrElse(
          ModelSignatureConstants.InputIds.key,
          "missing_input_id_key"),
        tokenTensors)
      .feed(
        _tfXlnetSignatures
          .getOrElse(ModelSignatureConstants.AttentionMask.key, "missing_input_mask_key"),
        maskTensors)
      .feed(
        _tfXlnetSignatures
          .getOrElse(ModelSignatureConstants.TokenTypeIds.key, "missing_segment_ids_key"),
        segmentTensors)
      .fetch(_tfXlnetSignatures
        .getOrElse(ModelSignatureConstants.LogitsOutput.key, "missing_logits_key"))

    val outs = runner.run().asScala
    val rawScores = TensorResources.extractFloats(outs.head)

    outs.foreach(_.close())
    tensors.clearSession(outs)
    tensors.clearTensors()
    tokenTensors.close()
    maskTensors.close()
    segmentTensors.close()

    val dim = rawScores.length / (batchLength * maxSentenceLength)
    val batchScores: Array[Array[Array[Float]]] = rawScores
      .grouped(dim)
      .map(scores => calculateSoftmax(scores))
      .toArray
      .grouped(maxSentenceLength)
      .toArray

    batchScores
  }

  def tagSequence(batch: Seq[Array[Int]], activation: String): Array[Array[Float]] = {
    val tensors = new TensorResources()

    val maxSentenceLength = batch.map(encodedSentence => encodedSentence.length).max
    val batchLength = batch.length

    val tokenBuffers: IntDataBuffer = tensors.createIntBuffer(batchLength * maxSentenceLength)
    val maskBuffers: IntDataBuffer = tensors.createIntBuffer(batchLength * maxSentenceLength)
    val segmentBuffers: IntDataBuffer = tensors.createIntBuffer(batchLength * maxSentenceLength)

    // [nb of encoded sentences , maxSentenceLength]
    val shape = Array(batch.length.toLong, maxSentenceLength)

    batch.zipWithIndex
      .foreach { case (sentence, idx) =>
        val offset = idx * maxSentenceLength
        tokenBuffers.offset(offset).write(sentence)
        maskBuffers
          .offset(offset)
          .write(sentence.map(x => if (x == sentencePadTokenId) 0 else 1))
        segmentBuffers.offset(offset).write(Array.fill(maxSentenceLength)(0))
      }

    val runner = tensorflowWrapper
      .getTFSessionWithSignature(configProtoBytes = configProtoBytes, initAllTables = false)
      .runner

    val tokenTensors = tensors.createIntBufferTensor(shape, tokenBuffers)
    val maskTensors = tensors.createIntBufferTensor(shape, maskBuffers)
    val segmentTensors = tensors.createIntBufferTensor(shape, segmentBuffers)

    runner
      .feed(
        _tfXlnetSignatures.getOrElse(
          ModelSignatureConstants.InputIds.key,
          "missing_input_id_key"),
        tokenTensors)
      .feed(
        _tfXlnetSignatures
          .getOrElse(ModelSignatureConstants.AttentionMask.key, "missing_input_mask_key"),
        maskTensors)
      .feed(
        _tfXlnetSignatures
          .getOrElse(ModelSignatureConstants.TokenTypeIds.key, "missing_segment_ids_key"),
        segmentTensors)
      .fetch(_tfXlnetSignatures
        .getOrElse(ModelSignatureConstants.LogitsOutput.key, "missing_logits_key"))

    val outs = runner.run().asScala
    val rawScores = TensorResources.extractFloats(outs.head)

    outs.foreach(_.close())
    tensors.clearSession(outs)
    tensors.clearTensors()
    tokenTensors.close()
    maskTensors.close()
    segmentTensors.close()

    val dim = rawScores.length / batchLength
    val batchScores: Array[Array[Float]] =
      rawScores
        .grouped(dim)
        .map(scores =>
          activation match {
            case ActivationFunction.softmax => calculateSoftmax(scores)
            case ActivationFunction.sigmoid => calculateSigmoid(scores)
            case _ => calculateSoftmax(scores)
          })
        .toArray

    batchScores
  }

  def tagSpan(batch: Seq[Array[Int]]): (Array[Array[Float]], Array[Array[Float]]) = {
    (Array.empty[Array[Float]], Array.empty[Array[Float]])
  }

  def findIndexedToken(
      tokenizedSentences: Seq[TokenizedSentence],
      sentence: (WordpieceTokenizedSentence, Int),
      tokenPiece: TokenPiece): Option[IndexedToken] = {
    tokenizedSentences(sentence._2).indexedTokens.find(p =>
      p.begin == tokenPiece.begin && tokenPiece.isWordStart)
  }

}


text:
class Plane :
	public Surface
{
public:
	Plane(const Material *mat, const Vector &n, const Vector &p);
	Plane(const Material *mat, const Vector &t0, const Vector &t1, const Vector &t2);
	~Plane(void);

	bool intersect(const Ray &r, float &distance) const;
	void getNormalAtPoint(const Vector &point, Vector &normal) const;

	Vector n, p;
};


text:
class Kea < FPM::Cookery::Recipe
  description ""

  name "kea"
  version "0.9.1"
  source "http://ftp.isc.org/isc/kea/#{version}/kea-#{version}.tar.gz"

  build_depends "log4cplus-devel"

  def build
    configure
    make
  end

  def install

  end

end


text:
namespace chromeos {

// Logs an UMA |event| in "Enrollment.*" histogram. Histogram is chosen
// depending on |mode|.
void EnrollmentUMA(policy::MetricEnrollment sample,
                   policy::EnrollmentConfig::Mode mode);

}  // namespace chromeos

#endif  // CHROME_BROWSER_CHROMEOS_LOGIN_ENROLLMENT_ENROLLMENT_UMA_H_


text:
package com.renomad.xenos;

/**
  * Requestoffer_status is the enumeration of requestoffer statuses.
  * It is an immutable object.
  * note that the fields are public, but final.  Once this object
  * gets constructed, there is no changing it.  You have to create a
  * new one.
  */
public class Requestoffer_status {

  public final int status_id;
  public final String status_value;

  public Requestoffer_status ( int status_id, String status_value) {
    this.status_id       =  status_id;
    this.status_value    =  status_value;
  }

}


text:
package org.aries.jndi;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.aries.Assert;

public class JndiContextCache {

    protected static JndiContextCache _instance;

	public static JndiContextCache getInstance() {
		return _instance;
	}

	private Map<String, JndiContext> _map;

	private Object _mutex;

	private JndiContextCache() {
		_instance = this;
		_map = new ConcurrentHashMap<String, JndiContext>();
		_mutex = new Object();
	}

	public JndiContext getContext(String connectionUrl) {
		synchronized (_mutex) {
			Assert.notNull(connectionUrl);
	    	return _map.get(connectionUrl);
		}
	}

	public void addContext(JndiContext jndiContext) {
		synchronized (_mutex) {
			Assert.notNull(jndiContext);
	    	_map.put(jndiContext.getConnectionUrl(), jndiContext);
		}
	}

	public void removeContext(JndiContext jndiContext) {
		synchronized (_mutex) {
			Assert.notNull(jndiContext);
	    	_map.put(jndiContext.getConnectionUrl(), jndiContext);
		}
	}

	public JndiContext createContext(String url, String factory) {
    	JndiProxy jndiContext = new JndiProxy();
    	jndiContext.setConnectionUrl(url);
    	jndiContext.setContextFactory(factory);
    	return jndiContext;
    }

}


text:
/*
Do not change the database path or name variables.
It will be properly coded for build and deployment
This is using sqlcmd variable substitution
*/
ALTER DATABASE [$(DatabaseName)]
	ADD FILE
	(
		NAME = [ncisan]
      , FILENAME = '$(DefaultDataPath)$(DefaultFilePrefix)_ncisan.ndf'
	  , SIZE = 10MB
	  , FILEGROWTH = 10MB
	) TO FILEGROUP [NCISAN]
GO


text:
<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:wikidot="http://www.wikidot.com/rss-namespace">

	<channel>
		<title>Comments for page "Stoke the Fire"</title>
		<link>http://bvs.wikidot.com/forum/t-203888/stoke-the-fire</link>
		<description>Posts in the discussion thread "Stoke the Fire"</description>
				<copyright></copyright>
		<lastBuildDate>Sun, 10 Jul 2022 03:42:37 +0000</lastBuildDate>

				</channel>
</rss>


text: package scootapi


text:
class ICvar;
class IProcessUtils;

//-----------------------------------------------------------------------------
// These tier1 libraries must be set by any users of this library.
// They can be set by calling ConnectTier1Libraries.
// It is hoped that setting this, and using this library will be the common mechanism for
// allowing link libraries to access tier1 library interfaces
//-----------------------------------------------------------------------------

// These are marked DLL_EXPORT for Linux.
DLL_EXPORT ICvar *cvar;
DLL_EXPORT ICvar *g_pCVar;
extern IProcessUtils *g_pProcessUtils;

//-----------------------------------------------------------------------------
// Call this to connect to/disconnect from all tier 1 libraries.
// It's up to the caller to check the globals it cares about to see if ones are missing
//-----------------------------------------------------------------------------
void ConnectTier1Libraries( CreateInterfaceFn *pFactoryList, int nFactoryCount );
void DisconnectTier1Libraries();

//-----------------------------------------------------------------------------
// Helper empty implementation of an IAppSystem for tier2 libraries
//-----------------------------------------------------------------------------
template< class IInterface, int ConVarFlag = 0 >
class CTier1AppSystem : public CTier0AppSystem< IInterface >
{
	typedef CTier0AppSystem< IInterface > BaseClass;

public:
	CTier1AppSystem( bool bIsPrimaryAppSystem = true ) : BaseClass(	bIsPrimaryAppSystem )
	{
	}

	virtual bool Connect( CreateInterfaceFn factory )
	{
		if ( !BaseClass::Connect( factory ) )
			return false;

		if ( IsPrimaryAppSystem() )
		{
			ConnectTier1Libraries( &factory, 1 );
		}
		return true;
	}

	virtual void Disconnect()
	{
		if ( IsPrimaryAppSystem() )
		{
			DisconnectTier1Libraries();
		}
		BaseClass::Disconnect();
	}

	virtual InitReturnVal_t Init()
	{
		InitReturnVal_t nRetVal = BaseClass::Init();
		if ( nRetVal != INIT_OK )
			return nRetVal;

		if ( g_pCVar && IsPrimaryAppSystem() )
		{
			ConVar_Register( ConVarFlag );
		}
		return INIT_OK;
	}

	virtual void Shutdown()
	{
		if ( g_pCVar && IsPrimaryAppSystem() )
		{
			ConVar_Unregister( );
		}
		BaseClass::Shutdown( );
	}
};

#endif // TIER1_H


text:
package jigg.pipeline

import java.util.concurrent.LinkedBlockingQueue
import java.util.Properties
import scala.annotation.tailrec
import scala.xml._
import scala.sys.process.Process
import jigg.util.PropertiesUtil
import jigg.util.XMLUtil.RichNode

abstract class MecabAnnotator(override val name: String, override val props: Properties)
    extends ExternalProcessSentencesAnnotator { self=>

  def dic: SystemDic

  @Prop(gloss = "Use this command to launch mecab. System dictionary is selected according to the current configuration accessible with '-P' option.") var command = MecabAnnotator.defaultCommand
  readProps()

  localAnnotators // instantiate lazy val here

  override def description = {

    def keyName = makeFullName("command")
    def helpMessage = MecabAnnotator.getHelp(command).map("    " + _).mkString("\n")

    s"""${super.description}

  Tokenize sentence by MeCab.
  Current dictionary is ${dic}.
  You can customize these settings by, e.g, -${keyName} "mecab -d /path/to/dic".

  Original help message:
${helpMessage}
"""
  }

  trait LocalMecabAnnotator extends LocalAnnotator with IOCreator {
    def command = self.command

    override def launchTesters = Seq(
      LaunchTester("EOS", _ == "EOS", _ == "EOS"))
    override def defaultArgs = Seq("-O", "")
    def softwareUrl = "https://taku910.github.io/mecab/"

    val mecab = mkIO()
    override def close() = mecab.close()

    override def newSentenceAnnotation(sentence: Node): Node = {

      def tid(sindex: String, tindex: Int) = sindex + "_tok" + tindex

      val sindex = (sentence \ "@id").toString
      val text = sentence.textElem

      def nextNonspaceIdx(offset: Int) = {
        def isSpace(c: Char) = c == ' ' || c == '\t'
        @tailrec
        def proceed(i: Int): Int =
          if (i < text.size && isSpace(text(i))) proceed(i + 1)
          else i
        proceed(offset)
      }

      var tokenIndex = 0
      var offset = 0

      val tokenNodes = runMecab(text).map { t =>
        val analysis = t.split('\t')
        val form = analysis(0)
        val feats = analysis(1).split(',')

        val span = (offset + "", offset + form.size + "")

        val node = tokenToNode(form, span, feats, tid(sindex, tokenIndex))
        tokenIndex += 1

        offset = nextNonspaceIdx(offset + form.size)

        node
      }

      val tokensAnnotation = <tokens annotators={ name }>{ tokenNodes }</tokens>
      sentence addChild tokensAnnotation
    }

    protected def tokenToNode(
      form: String, span: (String, String), feats: Array[String], id: String): Node

    private def runMecab(text: String): Seq[String] = {
      mecab.safeWriteWithFlush(text)
      mecab.readUntil(_ == "EOS").dropRight(1)
    }
  }

  override def requires = Set(Requirement.Ssplit)
}

class IPAMecabAnnotator(name: String, props: Properties) extends MecabAnnotator(name, props) {
  def dic = SystemDic.ipadic

  def mkLocalAnnotator = new IPALocalMecabAnnotator

  class IPALocalMecabAnnotator extends LocalMecabAnnotator {
    //output form of mecab ipadic
    //表層形\t品詞,品詞細分類1,品詞細分類2,品詞細分類3,活用型,活用形,原形,読み,発音
    //form\tpos,pos1,pos2,pos3,cType,cForm,lemma,yomi,pron
    def tokenToNode(
      form: String, span: (String, String), feats: Array[String], id: String) =
      <token
        id={ id }
        form={ form }
        offsetBegin={ span._1 }
        offsetEnd={ span._2 }
        pos={ feats(0) }
        pos1={ feats(1) }
        pos2={ feats(2) }
        pos3={ feats(3) }
        cType={ feats(4) }
        cForm={ feats(5) }
        lemma={ feats(6) }
        yomi={ if (feats.size > 7) feats(7) else "*" }
        pron={ if (feats.size > 8) Text(feats(8)) else Text("*") }/>
  }

  override def requirementsSatisfied = Set(JaRequirement.TokenizeWithIPA)
}

class JumanDicMecabAnnotator(name: String, props: Properties) extends MecabAnnotator(name, props) {
  def dic = SystemDic.jumandic

  def mkLocalAnnotator = new JumanLocalMecabAnnotator

  class JumanLocalMecabAnnotator extends LocalMecabAnnotator {
    def tokenToNode(
      form: String, span: (String, String), feats: Array[String], id: String) =
      <token
        id={ id }
        form={ form }
        offsetBegin={ span._1 }
        offsetEnd={ span._2 }
        pos={ feats(0) }
        pos1={ feats(1) }
        cType={ feats(2) }
        cForm={ feats(3) }
        lemma={ feats(4) }
        yomi={ feats(5) }
    misc={ feats(6) }/>
  }

  override def requirementsSatisfied = Set(JaRequirement.TokenizeWithJumandic)
}

class UnidicMecabAnnotator(name: String, props: Properties) extends MecabAnnotator(name, props) {
  def dic = SystemDic.unidic

  def mkLocalAnnotator = new UnidicLocalMecabAnnotator

  class UnidicLocalMecabAnnotator extends LocalMecabAnnotator {
    def tokenToNode(
      form: String, span: (String, String), feats: Array[String], id: String) = {

      val feat:Int=>String =
        if (feats.size <= 18) idx => if (idx < feats.size) feats(idx) else "*" // unk token
        else feats(_)

      <token
        id={ id }
        form={ form }
        offsetBegin={ span._1 }
        offsetEnd={ span._2 }
        pos={ feat(0) }
        pos1={ feat(1) }
        pos2={ feat(2) }
        pos3={ feat(3) }
        cType={ feat(4) }
        cForm={ feat(5) }
        lForm={ feat(6) }
        lemma={ feat(7) }
        orth={ feat(8) }
        pron={ feat(9) }
        orthBase={ feat(10) }
        pronBase={ feat(11) }
        goshu={ feat(12) }
        iType={ feat(13) }
        iForm={ feat(14) }
        fType={ feat(15) }
        fForm={ feat(16) }/>
    }
  }

  override def requirementsSatisfied = Set(JaRequirement.TokenizeWithUnidic)
}

object MecabAnnotator extends AnnotatorCompanion[MecabAnnotator] {

  import SystemDic._
  override def fromProps(name: String, props: Properties) = {
    val cmd = currentCommand(name, props)

    currentDictionary(cmd) map {
      case SystemDic.ipadic => new IPAMecabAnnotator(name, props)
      case SystemDic.jumandic => new JumanDicMecabAnnotator(name, props)
      case SystemDic.unidic => new UnidicMecabAnnotator(name, props)
    } getOrElse {
      System.err.println(s"Failed to search dictionary file from the current mecab path: ${cmd}. Assuming ipadic is used...")
      new IPAMecabAnnotator(name, props)
    }
  }

  def defaultCommand = "mecab"

  def currentCommand(name: String, props: Properties): String = {
    val key = name + ".command"
    PropertiesUtil.findProperty(key, props) getOrElse (defaultCommand)
  }

  def currentDictionary(cmd: String): Option[SystemDic] = {
    try {
      val config = getConfig(cmd)
      val dicdirLine = config.find(_.startsWith("dicdir:"))

      dicdirLine map { l => l.drop(l.lastIndexOf('/') + 1) } map {
        // NOTE: we use slice to pick up a variant of ipadic, e.g., mecab-ipadic-neologd.
        // We also assume naist-jdic is a variant of ipadic.
        case dicdir if dicdir.containsSlice("ipadic") || dicdir.containsSlice("naist-jdic") =>
          SystemDic.ipadic
        case dicdir if dicdir.containsSlice("jumandic") => SystemDic.jumandic
        case dicdir if dicdir.containsSlice("unidic") => SystemDic.unidic
      }
    } catch { case e: Throwable => None }
  }

  def getConfig(cmd: String) = Process(cmd + " --dump-config").lineStream_!
  def getHelp(cmd: String) = Process(cmd + " --help").lineStream_!
}


text:
<?php
/**
 * Director2
 *
 * PHP version 5
 *
 * @category Class
 * @package  Kinow\Client
 * @author   Swaagger Codegen team
 * @link     https://github.com/swagger-api/swagger-codegen
 */

/**
 * Server API
 *
 * Reference for Server API (REST/Json)
 *
 * OpenAPI spec version: 1.4.39
 *
 * Generated by: https://github.com/swagger-api/swagger-codegen.git
 *
 */

/**
 * NOTE: This class is auto generated by the swagger code generator program.
 * https://github.com/swagger-api/swagger-codegen
 * Do not edit the class manually.
 */

namespace Kinow\Client\Model;

use \ArrayAccess;

/**
 * Director2 Class Doc Comment
 *
 * @category    Class */
/**
 * @package     Kinow\Client
 * @author      Swagger Codegen team
 * @link        https://github.com/swagger-api/swagger-codegen
 */
class Director2 implements ArrayAccess
{
    const DISCRIMINATOR = null;

    /**
      * The original name of the model.
      * @var string
      */
    protected static $swaggerModelName = 'Director_2';

    /**
      * Array of property to type mappings. Used for (de)serialization
      * @var string[]
      */
    protected static $swaggerTypes = [
        'name' => 'string',
        'description_short' => '\Kinow\Client\Model\I18nField[]',
        'description' => '\Kinow\Client\Model\I18nField[]',
        'meta_title' => '\Kinow\Client\Model\I18nField[]',
        'meta_description' => '\Kinow\Client\Model\I18nField[]',
        'meta_keywords' => '\Kinow\Client\Model\I18nField[]',
        'link_rewrite' => '\Kinow\Client\Model\I18nField[]',
        'active' => 'bool'
    ];

    public static function swaggerTypes()
    {
        return self::$swaggerTypes;
    }

    /**
     * Array of attributes where the key is the local name, and the value is the original name
     * @var string[]
     */
    protected static $attributeMap = [
        'name' => 'name',
        'description_short' => 'description_short',
        'description' => 'description',
        'meta_title' => 'meta_title',
        'meta_description' => 'meta_description',
        'meta_keywords' => 'meta_keywords',
        'link_rewrite' => 'link_rewrite',
        'active' => 'active'
    ];

    /**
     * Array of attributes to setter functions (for deserialization of responses)
     * @var string[]
     */
    protected static $setters = [
        'name' => 'setName',
        'description_short' => 'setDescriptionShort',
        'description' => 'setDescription',
        'meta_title' => 'setMetaTitle',
        'meta_description' => 'setMetaDescription',
        'meta_keywords' => 'setMetaKeywords',
        'link_rewrite' => 'setLinkRewrite',
        'active' => 'setActive'
    ];

    /**
     * Array of attributes to getter functions (for serialization of requests)
     * @var string[]
     */
    protected static $getters = [
        'name' => 'getName',
        'description_short' => 'getDescriptionShort',
        'description' => 'getDescription',
        'meta_title' => 'getMetaTitle',
        'meta_description' => 'getMetaDescription',
        'meta_keywords' => 'getMetaKeywords',
        'link_rewrite' => 'getLinkRewrite',
        'active' => 'getActive'
    ];

    public static function attributeMap()
    {
        return self::$attributeMap;
    }

    public static function setters()
    {
        return self::$setters;
    }

    public static function getters()
    {
        return self::$getters;
    }

    /**
     * Associative array for storing property values
     * @var mixed[]
     */
    protected $container = [];

    /**
     * Constructor
     * @param mixed[] $data Associated array of property values initializing the model
     */
    public function __construct(array $data = null)
    {
        $this->container['name'] = isset($data['name']) ? $data['name'] : null;
        $this->container['description_short'] = isset($data['description_short']) ? $data['description_short'] : null;
        $this->container['description'] = isset($data['description']) ? $data['description'] : null;
        $this->container['meta_title'] = isset($data['meta_title']) ? $data['meta_title'] : null;
        $this->container['meta_description'] = isset($data['meta_description']) ? $data['meta_description'] : null;
        $this->container['meta_keywords'] = isset($data['meta_keywords']) ? $data['meta_keywords'] : null;
        $this->container['link_rewrite'] = isset($data['link_rewrite']) ? $data['link_rewrite'] : null;
        $this->container['active'] = isset($data['active']) ? $data['active'] : null;
    }

    /**
     * show all the invalid properties with reasons.
     *
     * @return array invalid properties with reasons
     */
    public function listInvalidProperties()
    {
        $invalid_properties = [];
        return $invalid_properties;
    }

    /**
     * validate all the properties in the model
     * return true if all passed
     *
     * @return bool True if all properteis are valid
     */
    public function valid()
    {
        return true;
    }

    /**
     * Gets name
     * @return string
     */
    public function getName()
    {
        return $this->container['name'];
    }

    /**
     * Sets name
     * @param string $name Director's name
     * @return $this
     */
    public function setName($name)
    {
        $this->container['name'] = $name;

        return $this;
    }

    /**
     * Gets description_short
     * @return \Kinow\Client\Model\I18nField[]
     */
    public function getDescriptionShort()
    {
        return $this->container['description_short'];
    }

    /**
     * Sets description_short
     * @param \Kinow\Client\Model\I18nField[] $description_short Director's short description
     * @return $this
     */
    public function setDescriptionShort($description_short)
    {
        $this->container['description_short'] = $description_short;

        return $this;
    }

    /**
     * Gets description
     * @return \Kinow\Client\Model\I18nField[]
     */
    public function getDescription()
    {
        return $this->container['description'];
    }

    /**
     * Sets description
     * @param \Kinow\Client\Model\I18nField[] $description Director's description
     * @return $this
     */
    public function setDescription($description)
    {
        $this->container['description'] = $description;

        return $this;
    }

    /**
     * Gets meta_title
     * @return \Kinow\Client\Model\I18nField[]
     */
    public function getMetaTitle()
    {
        return $this->container['meta_title'];
    }

    /**
     * Sets meta_title
     * @param \Kinow\Client\Model\I18nField[] $meta_title Title page for search engines
     * @return $this
     */
    public function setMetaTitle($meta_title)
    {
        $this->container['meta_title'] = $meta_title;

        return $this;
    }

    /**
     * Gets meta_description
     * @return \Kinow\Client\Model\I18nField[]
     */
    public function getMetaDescription()
    {
        return $this->container['meta_description'];
    }

    /**
     * Sets meta_description
     * @param \Kinow\Client\Model\I18nField[] $meta_description Short description for search engines
     * @return $this
     */
    public function setMetaDescription($meta_description)
    {
        $this->container['meta_description'] = $meta_description;

        return $this;
    }

    /**
     * Gets meta_keywords
     * @return \Kinow\Client\Model\I18nField[]
     */
    public function getMetaKeywords()
    {
        return $this->container['meta_keywords'];
    }

    /**
     * Sets meta_keywords
     * @param \Kinow\Client\Model\I18nField[] $meta_keywords List of keywords for search engines
     * @return $this
     */
    public function setMetaKeywords($meta_keywords)
    {
        $this->container['meta_keywords'] = $meta_keywords;

        return $this;
    }

    /**
     * Gets link_rewrite
     * @return \Kinow\Client\Model\I18nField[]
     */
    public function getLinkRewrite()
    {
        return $this->container['link_rewrite'];
    }

    /**
     * Sets link_rewrite
     * @param \Kinow\Client\Model\I18nField[] $link_rewrite Friendly URL used to reach real page
     * @return $this
     */
    public function setLinkRewrite($link_rewrite)
    {
        $this->container['link_rewrite'] = $link_rewrite;

        return $this;
    }

    /**
     * Gets active
     * @return bool
     */
    public function getActive()
    {
        return $this->container['active'];
    }

    /**
     * Sets active
     * @param bool $active Director's status
     * @return $this
     */
    public function setActive($active)
    {
        $this->container['active'] = $active;

        return $this;
    }
    /**
     * Returns true if offset exists. False otherwise.
     * @param  integer $offset Offset
     * @return boolean
     */
    public function offsetExists($offset)
    {
        return isset($this->container[$offset]);
    }

    /**
     * Gets offset.
     * @param  integer $offset Offset
     * @return mixed
     */
    public function offsetGet($offset)
    {
        return isset($this->container[$offset]) ? $this->container[$offset] : null;
    }

    /**
     * Sets value based on offset.
     * @param  integer $offset Offset
     * @param  mixed   $value  Value to be set
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        if (is_null($offset)) {
            $this->container[] = $value;
        } else {
            $this->container[$offset] = $value;
        }
    }

    /**
     * Unsets offset.
     * @param  integer $offset Offset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->container[$offset]);
    }

    /**
     * Gets the string presentation of the object
     * @return string
     */
    public function __toString()
    {
        if (defined('JSON_PRETTY_PRINT')) { // use JSON pretty print
            return json_encode(\Kinow\Client\ObjectSerializer::sanitizeForSerialization($this), JSON_PRETTY_PRINT);
        }

        return json_encode(\Kinow\Client\ObjectSerializer::sanitizeForSerialization($this));
    }
}


text:
module('Options - Attributes');

var Options = require('select2/options');

test('no nesting', function (assert) {
  var $test = $('<select data-test="test"></select>');

  var options = new Options({}, $test);

  assert.equal(options.get('test'), 'test');
});

test('with nesting', function (assert) {
  var $test = $('<select data-first--second="test"></select>');

  var options = new Options({}, $test);

  assert.ok(!(options.get('first-Second')));
  assert.equal(options.get('first').second, 'test');
});

test('overrides initialized data', function (assert) {
  var $test = $('<select data-override="yes" data-data="yes"></select>');

  var options = new Options({
    options: 'yes',
    override: 'no'
  }, $test);

  assert.equal(options.get('options'), 'yes');
  assert.equal(options.get('override'), 'yes');
  assert.equal(options.get('data'), 'yes');
});


text:
package cn.iada_lzu.mobile_science_calculator;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.WebView;

/**
 * Created by hopeful on 16-4-20.
 */
public class HelpFragment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.help, container, false);
        ((WebView)v.findViewById(R.id.wv_help)).loadUrl("file:///android_asset/help.html");
        return v;
    }
}


text:
package gw.lang.function;

@FunctionalInterface
public interface IFunction2<R, P0, P1> {

  R invoke(P0 arg0, P1 arg1);

}


text:
import {Component, NgModule} from '@angular/core';
import {BrowserModule} from '@angular/platform-browser';

import {AsyncObservablePipeComponent, AsyncPromisePipeComponent} from './async_pipe';
import {CurrencyPipeComponent, DeprecatedCurrencyPipeComponent} from './currency_pipe';
import {DatePipeComponent, DeprecatedDatePipeComponent} from './date_pipe';
import {I18nPluralPipeComponent, I18nSelectPipeComponent} from './i18n_pipe';
import {JsonPipeComponent} from './json_pipe';
import {LowerUpperPipeComponent} from './lowerupper_pipe';
import {DeprecatedNumberPipeComponent, NumberPipeComponent} from './number_pipe';
import {DeprecatedPercentPipeComponent, PercentPipeComponent} from './percent_pipe';
import {SlicePipeListComponent, SlicePipeStringComponent} from './slice_pipe';
import {TitleCasePipeComponent} from './titlecase_pipe';

@Component({
  selector: 'example-app',
  template: `

Pipe Example

async

    <async-promise-pipe></async-promise-pipe>
    <async-observable-pipe></async-observable-pipe>

date

    <date-pipe></date-pipe>

json

    <json-pipe></json-pipe>

lower, upper

    <lowerupper-pipe></lowerupper-pipe>

titlecase

    <titlecase-pipe></titlecase-pipe>

number

    <number-pipe></number-pipe>
    <percent-pipe></percent-pipe>
    <currency-pipe></currency-pipe>

slice

    <slice-string-pipe></slice-string-pipe>
    <slice-list-pipe></slice-list-pipe>

i18n

    <i18n-plural-pipe></i18n-plural-pipe>
    <i18n-select-pipe></i18n-select-pipe>
  `
})
export class ExampleAppComponent {
}

@NgModule({
  declarations: [
    AsyncPromisePipeComponent, AsyncObservablePipeComponent, ExampleAppComponent, JsonPipeComponent,
    DatePipeComponent, DeprecatedDatePipeComponent, LowerUpperPipeComponent, TitleCasePipeComponent,
    NumberPipeComponent, PercentPipeComponent, DeprecatedPercentPipeComponent,
    CurrencyPipeComponent, DeprecatedCurrencyPipeComponent, SlicePipeStringComponent,
    SlicePipeListComponent, I18nPluralPipeComponent, I18nSelectPipeComponent
  ],
  imports: [BrowserModule],
  bootstrap: [ExampleAppComponent]
})
export class AppModule {
}


text:
require 'spec_helper'

module Capistrano
  module Template
    module Helpers
      module Unit # protect from other dummy classes
        module DSLSpec
          class Dummy
            include DSL
            attr_accessor :data, :file_exists

            def initialize
              self.file_exists = true
              self.data = {
                templating_paths: ['/tmp'],
              }
            end

            def host
              'localhost'
            end

            def release_path
              '/var/www/app/releases/20140510'
            end

            def pwd_path
              nil
            end

            def fetch(*args)
              data.fetch(*args)
            end

            def _paths_factory
              lambda do |*args|
                PathsLookup.new(*args).tap do |pl|
                  def pl.existence_check(*)
                    file_exists
                  end
                end
              end
            end
          end
        end
      end

      describe DSL do
        subject do
          Unit::DSLSpec::Dummy.new
        end

        let(:template_name) { 'my_template.erb' }

        describe '#template' do
          it 'raises an exception when template does not exists' do
            subject.file_exists = false
            expect { subject.template(template_name) }.to raise_error(ArgumentError, /template #{template_name} not found Paths/)
          end
        end
      end
    end
  end
end


text:
<?php
declare(strict_types=1);

namespace T3v\T3vCore\Utility;

/**
 * The content element utility class.
 *
 * @package T3v\T3vCore\Utility
 */
class ContentElementUtility extends AbstractUtility
{
    /**
     * Gets an identifier from a content element key.
     *
     * @param string $contentElementKey The content element key
     * @return string The content element identifier
     */
    public static function getIdentifier(string $contentElementKey): string
    {
        $contentElementIdentifier = $contentElementKey;

        if (strpos($contentElementIdentifier, '_') ||
            strpos($contentElementIdentifier, '-') ||
            strpos($contentElementIdentifier, ' ')) {
            $contentElementIdentifier = mb_strtolower($contentElementKey);
            $contentElementIdentifier = str_replace(array('_', '-'), ' ', $contentElementIdentifier);
            $contentElementIdentifier = str_replace(' ', '', ucwords($contentElementIdentifier));
        }

        if ($contentElementIdentifier[0]) {
            $contentElementIdentifier[0] = mb_strtoUpper($contentElementIdentifier[0]);
        }

        return $contentElementIdentifier;
    }

    /**
     * Gets an identifier from a content element key.
     *
     * Alias for the `getIdentifier` function.
     *
     * @param string $contentElementKey The content element key
     * @return string The content element identifier
     * @deprecated Use the `getIdentifier` function instead
     */
    public static function identifier(string $contentElementKey): string
    {
        return self::getIdentifier($contentElementKey);
    }

    /**
     * Gets a content element identifier from a content element key.
     *
     * Alias for the `getIdentifier` function.
     *
     * @param string $contentElementKey The content element key
     * @return string The content element identifier
     * @deprecated Use the `getIdentifier` function instead
     */
    public static function contentElementIdentifier(string $contentElementKey): string
    {
        return self::getIdentifier($contentElementKey);
    }

    /**
     * Gets a signature from an extension and content element identifier.
     *
     * @param string $extensionIdentifier The extension identifier
     * @param string $contentElementIdentifier The content element identifier
     * @return string The content element signature
     */
    public static function getSignature(string $extensionIdentifier, string $contentElementIdentifier): string
    {
        return mb_strtolower($extensionIdentifier . '_' . $contentElementIdentifier);
    }

    /**
     * Gets a signature from an extension and content element identifier.
     *
     * Alias for the `getSignature` function.
     *
     * @param string $extensionIdentifier The extension identifier
     * @param string $contentElementIdentifier The content element identifier
     * @return string The content element signature
     * @deprecated Use the `getSignature` function instead
     */
    public static function signature(string $extensionIdentifier, string $contentElementIdentifier): string
    {
        return self::getSignature($extensionIdentifier, $contentElementIdentifier);
    }

    /**
     * Gets a content element signature from an extension and content element identifier.
     *
     * Alias for the `getSignature` function.
     *
     * @param string $extensionIdentifier The extension identifier
     * @param string $contentElementIdentifier The content element identifier
     * @return string The content element signature
     * @deprecated Use the `getSignature` function instead
     */
    public static function contentElementSignature(string $extensionIdentifier, string $contentElementIdentifier): string
    {
        return self::getSignature($extensionIdentifier, $contentElementIdentifier);
    }
}


text:
#ifndef OS_LINUX_VM_OSTHREAD_LINUX_HPP
#define OS_LINUX_VM_OSTHREAD_LINUX_HPP
 public:
  typedef pid_t thread_id_t;

 private:
  int _thread_type;

 public:

  int thread_type() const {
    return _thread_type;
  }
  void set_thread_type(int type) {
    _thread_type = type;
  }

  // _pthread_id is the pthread id, which is used by library calls
  // (e.g. pthread_kill).
  pthread_t _pthread_id;

  sigset_t _caller_sigmask; // Caller's signal mask

 public:

  // Methods to save/restore caller's signal mask
  sigset_t  caller_sigmask() const       { return _caller_sigmask; }
  void    set_caller_sigmask(sigset_t sigmask)  { _caller_sigmask = sigmask; }

#ifndef PRODUCT
  // Used for debugging, return a unique integer for each thread.
  int thread_identifier() const   { return _thread_id; }
#endif
#ifdef ASSERT
  // We expect no reposition failures so kill vm if we get one.
  //
  bool valid_reposition_failure() {
    return false;
  }
#endif // ASSERT
  pthread_t pthread_id() const {
    return _pthread_id;
  }
  void set_pthread_id(pthread_t tid) {
    _pthread_id = tid;
  }

  // ***************************************************************
  // suspension support.
  // ***************************************************************

public:
  // flags that support signal based suspend/resume on Linux are in a
  // separate class to avoid confusion with many flags in OSThread that
  // are used by VM level suspend/resume.
  os::SuspendResume sr;

  // _ucontext and _siginfo are used by SR_handler() to save thread context,
  // and they will later be used to walk the stack or reposition thread PC.
  // If the thread is not suspended in SR_handler() (e.g. self suspend),
  // the value in _ucontext is meaningless, so we must use the last Java
  // frame information as the frame. This will mean that for threads
  // that are parked on a mutex the profiler (and safepoint mechanism)
  // will see the thread as if it were still in the Java frame. This
  // not a problem for the profiler since the Java frame is a close
  // enough result. For the safepoint mechanism when the give it the
  // Java frame we are not at a point where the safepoint needs the
  // frame to that accurate (like for a compiled safepoint) since we
  // should be in a place where we are native and will block ourselves
  // if we transition.
private:
  void* _siginfo;
  ucontext_t* _ucontext;
  int _expanding_stack;                 /* non zero if manually expanding stack */
  address _alt_sig_stack;               /* address of base of alternate signal stack */

public:
  void* siginfo() const                   { return _siginfo;  }
  void set_siginfo(void* ptr)             { _siginfo = ptr;   }
  ucontext_t* ucontext() const            { return _ucontext; }
  void set_ucontext(ucontext_t* ptr)      { _ucontext = ptr;  }
  void set_expanding_stack(void)          { _expanding_stack = 1;  }
  void clear_expanding_stack(void)        { _expanding_stack = 0;  }
  int  expanding_stack(void)              { return _expanding_stack;  }

  void set_alt_sig_stack(address val)     { _alt_sig_stack = val; }
  address alt_sig_stack(void)             { return _alt_sig_stack; }

private:
  Monitor* _startThread_lock;     // sync parent and child in thread creation

public:

  Monitor* startThread_lock() const {
    return _startThread_lock;
  }

  // ***************************************************************
  // Platform dependent initialization and cleanup
  // ***************************************************************

private:

  void pd_initialize();
  void pd_destroy();

// Reconciliation History
// osThread_solaris.hpp 1.24 99/08/27 13:11:54
// End

#endif // OS_LINUX_VM_OSTHREAD_LINUX_HPP


text:
Delete KB Article

<?= validation_errors(); ?>

  <?= form_open('kb/delete/'.$article['_id']) ?>

        Are you sure?
        <input type="checkbox" name="s1" />

        Really sure?
        <input type="checkbox" name="s2" />

        Completely sure?
        <input type="checkbox" name="s3" />

        Do not delete a KB article without first consulting the staff and allowing them to reach a consensus.

        <input id="post" type="submit" value="Delete KB Article">

  </form>


text:
package org.onosproject.intentsync;

import org.onosproject.core.ApplicationId;
import org.onosproject.net.intent.Intent;

/**
 * Submits and withdraws intents to the IntentService from a single point in
 * the cluster at any one time. The provided intents will be synchronized with
 * the IntentService on leadership change.
 *

 * This is a sample utility and not part of the core ONOS API. This means it is
 * subject to change or to be removed. It is recommended to consider using one
 * of the built-in ONOS distributed primitives such as the
 * {@link org.onosproject.store.service.WorkQueue} instead of using this.
 *

 */
public interface IntentSynchronizationService {

    /**
     * Submits and intent to the synchronizer.
     *

     * The intent will be submitted directly to the IntentService if this node
     * is the leader, otherwise it will be stored in the synchronizer for
     * synchronization if this node becomes the leader.
     *

     *
     * @param intent intent to submit
     */
    void submit(Intent intent);

    /**
     * Withdraws an intent from the synchronizer.
     *

     * The intent will be withdrawn directly from the IntentService if this node
     * is the leader. The intent will be removed from the synchronizer's
     * in-memory storage.
     *

     *
     * @param intent intent to withdraw
     */
    void withdraw(Intent intent);

    /**
     * Withdraws intents by app Id.
     *
     * @param applicationId the Id of the application that created the intents
     *                      to be removed
     */
    void removeIntentsByAppId(ApplicationId applicationId);
}


text:
<!--

    Copyright 2004-2014 The Kuali Foundation

    Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php

    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.

-->
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.1.xsd">

	<changeSet id="1" author="yingzhou" context="kpme-client-bootstrap">
		<addForeignKeyConstraint baseTableName="PM_PSTN_CL_QLFCTN_T" baseColumnNames="PM_PSTN_CL_ID"
           referencedTableName="PM_PSTN_CL_T" referencedColumnNames="PM_PSTN_CL_ID"
           constraintName="FK_PSTNCL_QLFCTN" />
	</changeSet>
	<changeSet id="2" author="yingzhou" context="kpme-client-bootstrap">
		<addColumn tableName="PM_PSTN_CL_T">
			<column name="PSTN_TYP" type="VARCHAR(10)">
                <constraints nullable="false" />
            </column>
        </addColumn>
	</changeSet>
	<changeSet id="3" author="yingzhou" context="kpme-client-bootstrap">
		<dropColumn tableName="PM_PSTN_CL_QLFCTN_T" columnName="DSPLY_ORDER"/>
		<dropColumn tableName="PM_PSTN_CL_QLFCTN_T" columnName="EFFDT"/>
		<dropColumn tableName="PM_PSTN_CL_QLFCTN_T" columnName="ACTIVE"/>
    </changeSet>

</databaseChangeLog>


text:
<!DOCTYPE html>

        <meta charset="utf-8"/>
        <title>crossbow::program_options::impl::option< Name, T, Opts > Struct Template Reference$</title>
        <link rel="stylesheet" href="http://yui.yahooapis.com/pure/0.6.0/pure-min.css">
        <link rel="stylesheet" href="http://yui.yahooapis.com/pure/0.6.0/grids-responsive-min.css">
        <link rel="stylesheet" href="http://netdna.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.css">
        <link rel="stylesheet" href="/css/default.css">

<title>Tell: crossbow::program_options::impl::option< Name, T, Opts > Struct Template Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="navtree.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />
<link href="customdoxygen.css" rel="stylesheet" type="text/css"/>

Tell
    0.1

A shared-data database ecosystem

Main Page

Namespaces

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Index

Class Hierarchy

Class Members

Public Types |
Public Member Functions |
Public Attributes |
Static Public Attributes |
List of all members

crossbow::program_options::impl::option< Name, T, Opts > Struct Template Reference

#include <program_options.hpp>

Collaboration diagram for crossbow::program_options::impl::option< Name, T, Opts >:

<map name="crossbow_1_1program__options_1_1impl_1_1option_3_01_name_00_01_t_00_01_opts_01_4_coll__map" id="crossbow_1_1program__options_1_1impl_1_1option_3_01_name_00_01_t_00_01_opts_01_4_coll__map">
<area shape="rect" id="node2" href="structcrossbow_1_1program__options_1_1impl_1_1o__options.html" title="crossbow::program_options\l::impl::o_options\< Opts... \>" alt="" coords="9,5,208,47"/>
<area shape="rect" id="node3" href="classcrossbow_1_1basic__string.html" title="crossbow::basic_string\l\< char \>" alt="" coords="27,71,191,112"/>
<area shape="rect" id="node4" href="structcrossbow_1_1program__options_1_1type__printer.html" title="crossbow::program_options\l::type_printer\< value_type \>" alt="" coords="5,136,212,177"/>
</map>
[legend]

Public Types

using 	my_options = o_options< Opts... >

using 	value_type = typename std::remove_cv< typename std::remove_pointer< T >::type >::type

Public Member Functions

template<class V >

void 	set_value (V &&v)

 	option (const std::string &longoption, value_type *value, Opts...opts)

std::ostream & 	print_help (std::ostream &os) const

Public Attributes

type_printer< value_type > 	tprinter

string 	longoption

value_type * 	value_ptr = nullptr

value_type 	value

my_options 	this_opts

Static Public Attributes

static constexpr bool 	ignore_short = my_options::ignore_short_option

static constexpr bool 	ignore_long = my_options::ignore_long_option

static constexpr char 	name = Name

Detailed Description

template<char Name, class T, class... Opts>

struct crossbow::program_options::impl::option< Name, T, Opts >

Definition at line 166 of file program_options.hpp.

Member Typedef Documentation

template<char Name, class T , class... Opts>

          using crossbow::program_options::impl::option< Name, T, Opts >::my_options =  o_options<Opts...>

Definition at line 167 of file program_options.hpp.

template<char Name, class T , class... Opts>

          using crossbow::program_options::impl::option< Name, T, Opts >::value_type =  typename std::remove_cv<typename std::remove_pointer<T>::type>::type

Definition at line 168 of file program_options.hpp.

Constructor & Destructor Documentation

template<char Name, class T , class... Opts>

          crossbow::program_options::impl::option< Name, T, Opts >::option
          (
          const std::string &
          longoption,

          value_type *
          value,

          Opts...
          opts

          )

inline

Definition at line 185 of file program_options.hpp.

Member Function Documentation

template<char Name, class T , class... Opts>

          std::ostream& crossbow::program_options::impl::option< Name, T, Opts >::print_help
          (
          std::ostream &
          os	)
           const

inline

Definition at line 191 of file program_options.hpp.

template<char Name, class T , class... Opts>

template<class V >

          void crossbow::program_options::impl::option< Name, T, Opts >::set_value
          (
          V &&
          v	)

inline

Definition at line 179 of file program_options.hpp.

Member Data Documentation

template<char Name, class T , class... Opts>

          constexpr bool crossbow::program_options::impl::option< Name, T, Opts >::ignore_long = my_options::ignore_long_option

static

Definition at line 170 of file program_options.hpp.

template<char Name, class T , class... Opts>

          constexpr bool crossbow::program_options::impl::option< Name, T, Opts >::ignore_short = my_options::ignore_short_option

static

Definition at line 169 of file program_options.hpp.

template<char Name, class T , class... Opts>

          string crossbow::program_options::impl::option< Name, T, Opts >::longoption

Definition at line 174 of file program_options.hpp.

template<char Name, class T , class... Opts>

          constexpr char crossbow::program_options::impl::option< Name, T, Opts >::name = Name

static

Definition at line 171 of file program_options.hpp.

template<char Name, class T , class... Opts>

          my_options crossbow::program_options::impl::option< Name, T, Opts >::this_opts

Definition at line 177 of file program_options.hpp.

template<char Name, class T , class... Opts>

          type_printer<value_type> crossbow::program_options::impl::option< Name, T, Opts >::tprinter

Definition at line 172 of file program_options.hpp.

template<char Name, class T , class... Opts>

          value_type crossbow::program_options::impl::option< Name, T, Opts >::value

Definition at line 176 of file program_options.hpp.

template<char Name, class T , class... Opts>

          value_type* crossbow::program_options::impl::option< Name, T, Opts >::value_ptr = nullptr

Definition at line 175 of file program_options.hpp.

The documentation for this struct was generated from the following file:

/home/mpilman/eth/tell/crossbow/crossbow/program_options.hpp

crossbow

program_options

impl

option