text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System.Buffers;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace System.Text.JsonLab
{
    public ref partial struct Utf8JsonWriter2
    {
        public void WriteStringSkipEscape(ReadOnlySpan<byte> propertyName, ReadOnlySpan<byte> value)
        {
            JsonWriterHelper.ValidatePropertyAndValue(ref propertyName, ref value);

            WriteStringSuppressTrue(ref propertyName, ref value);

            _currentDepth |= 1 << 31;
            _tokenType = JsonTokenType.String;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void ValidatePropertyNameAndDepth(ref ReadOnlySpan<char> propertyName)
        {
            // TODO: Use throw helper with proper error messages
            if (propertyName.Length > JsonConstants.MaxCharacterTokenSize || CurrentDepth >= JsonConstants.MaxWriterDepth)
                JsonThrowHelper.ThrowJsonWriterOrArgumentException(propertyName, _currentDepth);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void ValidatePropertyNameAndDepth(ref ReadOnlySpan<byte> propertyName)
        {
            // TODO: Use throw helper with proper error messages
            if (propertyName.Length > JsonConstants.MaxTokenSize || CurrentDepth >= JsonConstants.MaxWriterDepth)
                JsonThrowHelper.ThrowJsonWriterOrArgumentException(propertyName, _currentDepth);
        }

        private void ValidateWritingProperty()
        {
            if (!_inObject)
            {
                Debug.Assert(_tokenType != JsonTokenType.StartObject);
                JsonThrowHelper.ThrowJsonWriterException("Cannot add a property within an array or as the first JSON token.");    //TODO: Add resouce message
            }
        }

        private int WritePropertyNameMinimized(ref ReadOnlySpan<byte> escapedPropertyName)
        {
            int idx = 0;
            if (_currentDepth < 0)
            {
                while (_buffer.Length <= idx)
                {
                    GrowAndEnsure();
                }
                _buffer[idx++] = JsonConstants.ListSeperator;
            }

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            CopyLoop(ref escapedPropertyName, ref idx);

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.KeyValueSeperator;

            return idx;
        }

        private int WritePropertyNameIndented(ref ReadOnlySpan<byte> escapedPropertyName)
        {
            int idx = 0;
            if (_currentDepth < 0)
            {
                while (_buffer.Length <= idx)
                {
                    GrowAndEnsure();
                }
                _buffer[idx++] = JsonConstants.ListSeperator;
            }

            if (_tokenType != JsonTokenType.None)
                WriteNewLine(ref idx);

            int indent = Indentation;
            while (true)
            {
                bool result = JsonWriterHelper.TryWriteIndentation(_buffer.Slice(idx), indent, out int bytesWritten);
                idx += bytesWritten;
                if (result)
                {
                    break;
                }
                indent -= bytesWritten;
                AdvanceAndGrow(idx);
                idx = 0;
            }

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            CopyLoop(ref escapedPropertyName, ref idx);

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.KeyValueSeperator;

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Space;

            return idx;
        }

        private int WritePropertyNameMinimized(ref ReadOnlySpan<char> escapedPropertyName)
        {
            int idx = 0;
            if (_currentDepth < 0)
            {
                while (_buffer.Length <= idx)
                {
                    GrowAndEnsure();
                }
                _buffer[idx++] = JsonConstants.ListSeperator;
            }

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            ReadOnlySpan<byte> byteSpan = MemoryMarshal.AsBytes(escapedPropertyName);
            int partialConsumed = 0;
            while (true)
            {
                OperationStatus status = Buffers.Text.Encodings.Utf16.ToUtf8(byteSpan.Slice(partialConsumed), _buffer.Slice(idx), out int consumed, out int written);
                idx += written;
                if (status == OperationStatus.Done)
                {
                    break;
                }
                partialConsumed += consumed;
                AdvanceAndGrow(idx);
                idx = 0;
            }

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.KeyValueSeperator;

            return idx;
        }

        private int WritePropertyNameIndented(ref ReadOnlySpan<char> escapedPropertyName)
        {
            int idx = 0;
            if (_currentDepth < 0)
            {
                while (_buffer.Length <= idx)
                {
                    GrowAndEnsure();
                }
                _buffer[idx++] = JsonConstants.ListSeperator;
            }

            if (_tokenType != JsonTokenType.None)
                WriteNewLine(ref idx);

            int indent = Indentation;
            while (true)
            {
                bool result = JsonWriterHelper.TryWriteIndentation(_buffer.Slice(idx), indent, out int bytesWritten);
                idx += bytesWritten;
                if (result)
                {
                    break;
                }
                indent -= bytesWritten;
                AdvanceAndGrow(idx);
                idx = 0;
            }

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            ReadOnlySpan<byte> byteSpan = MemoryMarshal.AsBytes(escapedPropertyName);
            int partialConsumed = 0;
            while (true)
            {
                OperationStatus status = Buffers.Text.Encodings.Utf16.ToUtf8(byteSpan.Slice(partialConsumed), _buffer.Slice(idx), out int consumed, out int written);
                idx += written;
                if (status == OperationStatus.Done)
                {
                    break;
                }
                partialConsumed += consumed;
                AdvanceAndGrow(idx);
                idx = 0;
            }

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Quote;

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.KeyValueSeperator;

            while (_buffer.Length <= idx)
            {
                AdvanceAndGrow(idx);
                idx = 0;
            }
            _buffer[idx++] = JsonConstants.Space;

            return idx;
        }
    }
}


text:
r = resources(supervisord_program: 'gogs')
r.directory "#{node['gogs']['install_dir']}/gogs"
r.environment HOME: '/home/git', USER: 'git'

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Threading.Tasks;

namespace Camunda.Api.Client.Job
{
    public class JobResource
    {
        private IJobRestService _api;
        private string _jobId;

        internal JobResource(IJobRestService api, string jobId)
        {
            _api = api;
            _jobId = jobId;
        }

        /// <summary>
        /// Retrieves a single job according to the Job interface in the engine.
        /// </summary>
        public Task<JobInfo> Get() => _api.Get(_jobId);

        /// <summary>
        /// Retrieves the corresponding exception stacktrace to the passed job id.
        /// </summary>
        public async Task<string> GetStacktrace() => await (await _api.GetStacktrace(_jobId)).Content.ReadAsStringAsync();

        /// <summary>
        /// Executes the job. The execution of the job happens synchronously in the same thread.
        /// </summary>
        public Task Execute() => _api.ExecuteJob(_jobId);

        /// <summary>
        /// Updates the due date of a job.
        /// </summary>
        public Task SetDuedate(DateTime duedate) => _api.SetJobDuedate(_jobId, new JobDuedateInfo() { Duedate = duedate });

        /// <summary>
        /// Activate or suspend a given job by id.
        /// </summary>
        public Task UpdateSuspensionState(bool suspended) => _api.UpdateSuspensionStateForId(_jobId, new SuspensionState() { Suspended = suspended });

        /// <summary>
        /// Sets the execution priority of a job.
        /// </summary>
        public Task SetPriority(long priority) => _api.SetJobPriority(_jobId, new PriorityInfo() { Priority = priority });

        /// <summary>
        /// Sets the retries of the job to the given number of retries.
        /// </summary>
        public Task SetRetries(long retries) => _api.SetJobRetries(_jobId, new RetriesInfo() { Retries = retries });

        /// <summary>
        /// Deletes a job.
        /// </summary>
        public Task Delete() => _api.DeleteJob(_jobId);

        public override string ToString() => _jobId;
    }
}


text:
package org.docksidestage.dbflute.cbean.cq.bs;

import java.util.*;

import org.dbflute.cbean.*;
import org.dbflute.cbean.chelper.*;
import org.dbflute.cbean.ckey.*;
import org.dbflute.cbean.coption.*;
import org.dbflute.cbean.cvalue.ConditionValue;
import org.dbflute.cbean.ordering.*;
import org.dbflute.cbean.scoping.*;
import org.dbflute.cbean.sqlclause.SqlClause;
import org.dbflute.dbmeta.DBMetaProvider;
import org.docksidestage.dbflute.allcommon.*;
import org.docksidestage.dbflute.cbean.*;
import org.docksidestage.dbflute.cbean.cq.*;

/**
 * The abstract condition-query of purchase.
 * @author DBFlute(AutoGenerator)
 */
public abstract class AbstractBsPurchaseCQ extends AbstractConditionQuery {

    // ===================================================================================
    //                                                                         Constructor
    //                                                                         ===========
    public AbstractBsPurchaseCQ(ConditionQuery referrerQuery, SqlClause sqlClause, String aliasName, int nestLevel) {
        super(referrerQuery, sqlClause, aliasName, nestLevel);
    }

    // ===================================================================================
    //                                                                             DB Meta
    //                                                                             =======
    @Override
    protected DBMetaProvider xgetDBMetaProvider() {
        return DBMetaInstanceHandler.getProvider();
    }

    public String asTableDbName() {
        return "purchase";
    }

    // ===================================================================================
    //                                                                               Query
    //                                                                               =====
    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseId The value of purchaseId as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseId_Equal(Long purchaseId) {
        doSetPurchaseId_Equal(purchaseId);
    }

    protected void doSetPurchaseId_Equal(Long purchaseId) {
        regPurchaseId(CK_EQ, purchaseId);
    }

    /**
     * NotEqual(<>). And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseId The value of purchaseId as notEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseId_NotEqual(Long purchaseId) {
        doSetPurchaseId_NotEqual(purchaseId);
    }

    protected void doSetPurchaseId_NotEqual(Long purchaseId) {
        regPurchaseId(CK_NES, purchaseId);
    }

    /**
     * GreaterThan(>). And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseId The value of purchaseId as greaterThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseId_GreaterThan(Long purchaseId) {
        regPurchaseId(CK_GT, purchaseId);
    }

    /**
     * LessThan(<). And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseId The value of purchaseId as lessThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseId_LessThan(Long purchaseId) {
        regPurchaseId(CK_LT, purchaseId);
    }

    /**
     * GreaterEqual(>=). And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseId The value of purchaseId as greaterEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseId_GreaterEqual(Long purchaseId) {
        regPurchaseId(CK_GE, purchaseId);
    }

    /**
     * LessEqual(<=). And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseId The value of purchaseId as lessEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseId_LessEqual(Long purchaseId) {
        regPurchaseId(CK_LE, purchaseId);
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param minNumber The min number of purchaseId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of purchaseId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of range-of. (NotNull)
     */
    public void setPurchaseId_RangeOf(Long minNumber, Long maxNumber, ConditionOptionCall<RangeOfOption> opLambda) {
        setPurchaseId_RangeOf(minNumber, maxNumber, xcROOP(opLambda));
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param minNumber The min number of purchaseId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of purchaseId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param rangeOfOption The option of range-of. (NotNull)
     */
    protected void setPurchaseId_RangeOf(Long minNumber, Long maxNumber, RangeOfOption rangeOfOption) {
        regROO(minNumber, maxNumber, xgetCValuePurchaseId(), "PURCHASE_ID", rangeOfOption);
    }

    /**
     * InScope {in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseIdList The collection of purchaseId as inScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPurchaseId_InScope(Collection<Long> purchaseIdList) {
        doSetPurchaseId_InScope(purchaseIdList);
    }

    protected void doSetPurchaseId_InScope(Collection<Long> purchaseIdList) {
        regINS(CK_INS, cTL(purchaseIdList), xgetCValuePurchaseId(), "PURCHASE_ID");
    }

    /**
     * NotInScope {not in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     * @param purchaseIdList The collection of purchaseId as notInScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPurchaseId_NotInScope(Collection<Long> purchaseIdList) {
        doSetPurchaseId_NotInScope(purchaseIdList);
    }

    protected void doSetPurchaseId_NotInScope(Collection<Long> purchaseIdList) {
        regINS(CK_NINS, cTL(purchaseIdList), xgetCValuePurchaseId(), "PURCHASE_ID");
    }

    /**
     * Set up ExistsReferrer (correlated sub-query).

     * {exists (select PURCHASE_ID from purchase_payment where ...)}

     * (購入支払)purchase_payment by PURCHASE_ID, named 'purchasePaymentAsOne'.
     *

     * cb.query().existsPurchasePayment(paymentCB -> {
     *     paymentCB.query().set...
     * });
     *

     * @param subCBLambda The callback for sub-query of PurchasePaymentList for 'exists'. (NotNull)
     */
    public void existsPurchasePayment(SubQuery<PurchasePaymentCB> subCBLambda) {
        assertObjectNotNull("subCBLambda", subCBLambda);
        PurchasePaymentCB cb = new PurchasePaymentCB(); cb.xsetupForExistsReferrer(this);
        lockCall(() -> subCBLambda.query(cb)); String pp = keepPurchaseId_ExistsReferrer_PurchasePaymentList(cb.query());
        registerExistsReferrer(cb.query(), "PURCHASE_ID", "PURCHASE_ID", pp, "purchasePaymentList");
    }
    public abstract String keepPurchaseId_ExistsReferrer_PurchasePaymentList(PurchasePaymentCQ sq);

    /**
     * Set up NotExistsReferrer (correlated sub-query).

     * {not exists (select PURCHASE_ID from purchase_payment where ...)}

     * (購入支払)purchase_payment by PURCHASE_ID, named 'purchasePaymentAsOne'.
     *

     * cb.query().notExistsPurchasePayment(paymentCB -> {
     *     paymentCB.query().set...
     * });
     *

     * @param subCBLambda The callback for sub-query of PurchaseId_NotExistsReferrer_PurchasePaymentList for 'not exists'. (NotNull)
     */
    public void notExistsPurchasePayment(SubQuery<PurchasePaymentCB> subCBLambda) {
        assertObjectNotNull("subCBLambda", subCBLambda);
        PurchasePaymentCB cb = new PurchasePaymentCB(); cb.xsetupForExistsReferrer(this);
        lockCall(() -> subCBLambda.query(cb)); String pp = keepPurchaseId_NotExistsReferrer_PurchasePaymentList(cb.query());
        registerNotExistsReferrer(cb.query(), "PURCHASE_ID", "PURCHASE_ID", pp, "purchasePaymentList");
    }
    public abstract String keepPurchaseId_NotExistsReferrer_PurchasePaymentList(PurchasePaymentCQ sq);

    public void xsderivePurchasePaymentList(String fn, SubQuery<PurchasePaymentCB> sq, String al, DerivedReferrerOption op) {
        assertObjectNotNull("subQuery", sq);
        PurchasePaymentCB cb = new PurchasePaymentCB(); cb.xsetupForDerivedReferrer(this);
        lockCall(() -> sq.query(cb)); String pp = keepPurchaseId_SpecifyDerivedReferrer_PurchasePaymentList(cb.query());
        registerSpecifyDerivedReferrer(fn, cb.query(), "PURCHASE_ID", "PURCHASE_ID", pp, "purchasePaymentList", al, op);
    }
    public abstract String keepPurchaseId_SpecifyDerivedReferrer_PurchasePaymentList(PurchasePaymentCQ sq);

    /**
     * Prepare for (Query)DerivedReferrer (correlated sub-query).

     * {FOO <= (select max(BAR) from purchase_payment where ...)}

     * (購入支払)purchase_payment by PURCHASE_ID, named 'purchasePaymentAsOne'.
     *

     * cb.query().derivedPurchasePayment().max(paymentCB -> {
     *     paymentCB.specify().columnFoo... // derived column by function
     *     paymentCB.query().setBar... // referrer condition
     * }).greaterEqual(123); // condition to derived column
     *

     * @return The object to set up a function for referrer table. (NotNull)
     */
    public HpQDRFunction<PurchasePaymentCB> derivedPurchasePayment() {
        return xcreateQDRFunctionPurchasePaymentList();
    }
    protected HpQDRFunction<PurchasePaymentCB> xcreateQDRFunctionPurchasePaymentList() {
        return xcQDRFunc((fn, sq, rd, vl, op) -> xqderivePurchasePaymentList(fn, sq, rd, vl, op));
    }
    public void xqderivePurchasePaymentList(String fn, SubQuery<PurchasePaymentCB> sq, String rd, Object vl, DerivedReferrerOption op) {
        assertObjectNotNull("subQuery", sq);
        PurchasePaymentCB cb = new PurchasePaymentCB(); cb.xsetupForDerivedReferrer(this);
        lockCall(() -> sq.query(cb)); String sqpp = keepPurchaseId_QueryDerivedReferrer_PurchasePaymentList(cb.query()); String prpp = keepPurchaseId_QueryDerivedReferrer_PurchasePaymentListParameter(vl);
        registerQueryDerivedReferrer(fn, cb.query(), "PURCHASE_ID", "PURCHASE_ID", sqpp, "purchasePaymentList", rd, vl, prpp, op);
    }
    public abstract String keepPurchaseId_QueryDerivedReferrer_PurchasePaymentList(PurchasePaymentCQ sq);
    public abstract String keepPurchaseId_QueryDerivedReferrer_PurchasePaymentListParameter(Object vl);

    /**
     * IsNull {is null}. And OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     */
    public void setPurchaseId_IsNull() { regPurchaseId(CK_ISN, DOBJ); }

    /**
     * IsNotNull {is not null}. And OnlyOnceRegistered.

     * (購入ID)PURCHASE_ID: {PK, ID, NotNull, BIGINT(19)}
     */
    public void setPurchaseId_IsNotNull() { regPurchaseId(CK_ISNN, DOBJ); }

    protected void regPurchaseId(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValuePurchaseId(), "PURCHASE_ID"); }
    protected abstract ConditionValue xgetCValuePurchaseId();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberId The value of memberId as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setMemberId_Equal(Integer memberId) {
        doSetMemberId_Equal(memberId);
    }

    protected void doSetMemberId_Equal(Integer memberId) {
        regMemberId(CK_EQ, memberId);
    }

    /**
     * NotEqual(<>). And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberId The value of memberId as notEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setMemberId_NotEqual(Integer memberId) {
        doSetMemberId_NotEqual(memberId);
    }

    protected void doSetMemberId_NotEqual(Integer memberId) {
        regMemberId(CK_NES, memberId);
    }

    /**
     * GreaterThan(>). And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberId The value of memberId as greaterThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setMemberId_GreaterThan(Integer memberId) {
        regMemberId(CK_GT, memberId);
    }

    /**
     * LessThan(<). And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberId The value of memberId as lessThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setMemberId_LessThan(Integer memberId) {
        regMemberId(CK_LT, memberId);
    }

    /**
     * GreaterEqual(>=). And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberId The value of memberId as greaterEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setMemberId_GreaterEqual(Integer memberId) {
        regMemberId(CK_GE, memberId);
    }

    /**
     * LessEqual(<=). And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberId The value of memberId as lessEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setMemberId_LessEqual(Integer memberId) {
        regMemberId(CK_LE, memberId);
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param minNumber The min number of memberId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of memberId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of range-of. (NotNull)
     */
    public void setMemberId_RangeOf(Integer minNumber, Integer maxNumber, ConditionOptionCall<RangeOfOption> opLambda) {
        setMemberId_RangeOf(minNumber, maxNumber, xcROOP(opLambda));
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param minNumber The min number of memberId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of memberId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param rangeOfOption The option of range-of. (NotNull)
     */
    protected void setMemberId_RangeOf(Integer minNumber, Integer maxNumber, RangeOfOption rangeOfOption) {
        regROO(minNumber, maxNumber, xgetCValueMemberId(), "MEMBER_ID", rangeOfOption);
    }

    /**
     * InScope {in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberIdList The collection of memberId as inScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setMemberId_InScope(Collection<Integer> memberIdList) {
        doSetMemberId_InScope(memberIdList);
    }

    protected void doSetMemberId_InScope(Collection<Integer> memberIdList) {
        regINS(CK_INS, cTL(memberIdList), xgetCValueMemberId(), "MEMBER_ID");
    }

    /**
     * NotInScope {not in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (会員ID)MEMBER_ID: {UQ+, IX+, NotNull, INT(10), FK to member}
     * @param memberIdList The collection of memberId as notInScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setMemberId_NotInScope(Collection<Integer> memberIdList) {
        doSetMemberId_NotInScope(memberIdList);
    }

    protected void doSetMemberId_NotInScope(Collection<Integer> memberIdList) {
        regINS(CK_NINS, cTL(memberIdList), xgetCValueMemberId(), "MEMBER_ID");
    }

    protected void regMemberId(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueMemberId(), "MEMBER_ID"); }
    protected abstract ConditionValue xgetCValueMemberId();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productId The value of productId as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setProductId_Equal(Integer productId) {
        doSetProductId_Equal(productId);
    }

    protected void doSetProductId_Equal(Integer productId) {
        regProductId(CK_EQ, productId);
    }

    /**
     * NotEqual(<>). And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productId The value of productId as notEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setProductId_NotEqual(Integer productId) {
        doSetProductId_NotEqual(productId);
    }

    protected void doSetProductId_NotEqual(Integer productId) {
        regProductId(CK_NES, productId);
    }

    /**
     * GreaterThan(>). And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productId The value of productId as greaterThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setProductId_GreaterThan(Integer productId) {
        regProductId(CK_GT, productId);
    }

    /**
     * LessThan(<). And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productId The value of productId as lessThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setProductId_LessThan(Integer productId) {
        regProductId(CK_LT, productId);
    }

    /**
     * GreaterEqual(>=). And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productId The value of productId as greaterEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setProductId_GreaterEqual(Integer productId) {
        regProductId(CK_GE, productId);
    }

    /**
     * LessEqual(<=). And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productId The value of productId as lessEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setProductId_LessEqual(Integer productId) {
        regProductId(CK_LE, productId);
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param minNumber The min number of productId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of productId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of range-of. (NotNull)
     */
    public void setProductId_RangeOf(Integer minNumber, Integer maxNumber, ConditionOptionCall<RangeOfOption> opLambda) {
        setProductId_RangeOf(minNumber, maxNumber, xcROOP(opLambda));
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param minNumber The min number of productId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of productId. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param rangeOfOption The option of range-of. (NotNull)
     */
    protected void setProductId_RangeOf(Integer minNumber, Integer maxNumber, RangeOfOption rangeOfOption) {
        regROO(minNumber, maxNumber, xgetCValueProductId(), "PRODUCT_ID", rangeOfOption);
    }

    /**
     * InScope {in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productIdList The collection of productId as inScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setProductId_InScope(Collection<Integer> productIdList) {
        doSetProductId_InScope(productIdList);
    }

    protected void doSetProductId_InScope(Collection<Integer> productIdList) {
        regINS(CK_INS, cTL(productIdList), xgetCValueProductId(), "PRODUCT_ID");
    }

    /**
     * NotInScope {not in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (商品ID)PRODUCT_ID: {+UQ, IX+, NotNull, INT(10), FK to product}
     * @param productIdList The collection of productId as notInScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setProductId_NotInScope(Collection<Integer> productIdList) {
        doSetProductId_NotInScope(productIdList);
    }

    protected void doSetProductId_NotInScope(Collection<Integer> productIdList) {
        regINS(CK_NINS, cTL(productIdList), xgetCValueProductId(), "PRODUCT_ID");
    }

    protected void regProductId(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueProductId(), "PRODUCT_ID"); }
    protected abstract ConditionValue xgetCValueProductId();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     * @param purchaseDatetime The value of purchaseDatetime as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseDatetime_Equal(java.time.LocalDateTime purchaseDatetime) {
        regPurchaseDatetime(CK_EQ,  purchaseDatetime);
    }

    /**
     * GreaterThan(>). And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     * @param purchaseDatetime The value of purchaseDatetime as greaterThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseDatetime_GreaterThan(java.time.LocalDateTime purchaseDatetime) {
        regPurchaseDatetime(CK_GT,  purchaseDatetime);
    }

    /**
     * LessThan(<). And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     * @param purchaseDatetime The value of purchaseDatetime as lessThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseDatetime_LessThan(java.time.LocalDateTime purchaseDatetime) {
        regPurchaseDatetime(CK_LT,  purchaseDatetime);
    }

    /**
     * GreaterEqual(>=). And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     * @param purchaseDatetime The value of purchaseDatetime as greaterEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseDatetime_GreaterEqual(java.time.LocalDateTime purchaseDatetime) {
        regPurchaseDatetime(CK_GE,  purchaseDatetime);
    }

    /**
     * LessEqual(<=). And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     * @param purchaseDatetime The value of purchaseDatetime as lessEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseDatetime_LessEqual(java.time.LocalDateTime purchaseDatetime) {
        regPurchaseDatetime(CK_LE, purchaseDatetime);
    }

    /**
     * FromTo with various options. (versatile) {(default) fromDatetime <= column <= toDatetime}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     *
e.g. setPurchaseDatetime_FromTo(fromDate, toDate, op -> op.compareAsDate());

     * @param fromDatetime The from-datetime(yyyy/MM/dd HH:mm:ss.SSS) of purchaseDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param toDatetime The to-datetime(yyyy/MM/dd HH:mm:ss.SSS) of purchaseDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of from-to. (NotNull)
     */
    public void setPurchaseDatetime_FromTo(java.time.LocalDateTime fromDatetime, java.time.LocalDateTime toDatetime, ConditionOptionCall<FromToOption> opLambda) {
        setPurchaseDatetime_FromTo(fromDatetime, toDatetime, xcFTOP(opLambda));
    }

    /**
     * FromTo with various options. (versatile) {(default) fromDatetime <= column <= toDatetime}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入日時)PURCHASE_DATETIME: {+UQ, IX+, NotNull, DATETIME(19)}
     *
e.g. setPurchaseDatetime_FromTo(fromDate, toDate, new FromToOption().compareAsDate());

     * @param fromDatetime The from-datetime(yyyy/MM/dd HH:mm:ss.SSS) of purchaseDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param toDatetime The to-datetime(yyyy/MM/dd HH:mm:ss.SSS) of purchaseDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param fromToOption The option of from-to. (NotNull)
     */
    protected void setPurchaseDatetime_FromTo(java.time.LocalDateTime fromDatetime, java.time.LocalDateTime toDatetime, FromToOption fromToOption) {
        String nm = "PURCHASE_DATETIME"; FromToOption op = fromToOption;
        regFTQ(xfFTHD(fromDatetime, nm, op), xfFTHD(toDatetime, nm, op), xgetCValuePurchaseDatetime(), nm, op);
    }

    protected void regPurchaseDatetime(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValuePurchaseDatetime(), "PURCHASE_DATETIME"); }
    protected abstract ConditionValue xgetCValuePurchaseDatetime();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCount The value of purchaseCount as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseCount_Equal(Integer purchaseCount) {
        doSetPurchaseCount_Equal(purchaseCount);
    }

    protected void doSetPurchaseCount_Equal(Integer purchaseCount) {
        regPurchaseCount(CK_EQ, purchaseCount);
    }

    /**
     * NotEqual(<>). And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCount The value of purchaseCount as notEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseCount_NotEqual(Integer purchaseCount) {
        doSetPurchaseCount_NotEqual(purchaseCount);
    }

    protected void doSetPurchaseCount_NotEqual(Integer purchaseCount) {
        regPurchaseCount(CK_NES, purchaseCount);
    }

    /**
     * GreaterThan(>). And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCount The value of purchaseCount as greaterThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseCount_GreaterThan(Integer purchaseCount) {
        regPurchaseCount(CK_GT, purchaseCount);
    }

    /**
     * LessThan(<). And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCount The value of purchaseCount as lessThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseCount_LessThan(Integer purchaseCount) {
        regPurchaseCount(CK_LT, purchaseCount);
    }

    /**
     * GreaterEqual(>=). And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCount The value of purchaseCount as greaterEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseCount_GreaterEqual(Integer purchaseCount) {
        regPurchaseCount(CK_GE, purchaseCount);
    }

    /**
     * LessEqual(<=). And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCount The value of purchaseCount as lessEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchaseCount_LessEqual(Integer purchaseCount) {
        regPurchaseCount(CK_LE, purchaseCount);
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param minNumber The min number of purchaseCount. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of purchaseCount. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of range-of. (NotNull)
     */
    public void setPurchaseCount_RangeOf(Integer minNumber, Integer maxNumber, ConditionOptionCall<RangeOfOption> opLambda) {
        setPurchaseCount_RangeOf(minNumber, maxNumber, xcROOP(opLambda));
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param minNumber The min number of purchaseCount. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of purchaseCount. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param rangeOfOption The option of range-of. (NotNull)
     */
    protected void setPurchaseCount_RangeOf(Integer minNumber, Integer maxNumber, RangeOfOption rangeOfOption) {
        regROO(minNumber, maxNumber, xgetCValuePurchaseCount(), "PURCHASE_COUNT", rangeOfOption);
    }

    /**
     * InScope {in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCountList The collection of purchaseCount as inScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPurchaseCount_InScope(Collection<Integer> purchaseCountList) {
        doSetPurchaseCount_InScope(purchaseCountList);
    }

    protected void doSetPurchaseCount_InScope(Collection<Integer> purchaseCountList) {
        regINS(CK_INS, cTL(purchaseCountList), xgetCValuePurchaseCount(), "PURCHASE_COUNT");
    }

    /**
     * NotInScope {not in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (購入数量)PURCHASE_COUNT: {NotNull, INT(10)}
     * @param purchaseCountList The collection of purchaseCount as notInScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPurchaseCount_NotInScope(Collection<Integer> purchaseCountList) {
        doSetPurchaseCount_NotInScope(purchaseCountList);
    }

    protected void doSetPurchaseCount_NotInScope(Collection<Integer> purchaseCountList) {
        regINS(CK_NINS, cTL(purchaseCountList), xgetCValuePurchaseCount(), "PURCHASE_COUNT");
    }

    protected void regPurchaseCount(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValuePurchaseCount(), "PURCHASE_COUNT"); }
    protected abstract ConditionValue xgetCValuePurchaseCount();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePrice The value of purchasePrice as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchasePrice_Equal(Integer purchasePrice) {
        doSetPurchasePrice_Equal(purchasePrice);
    }

    protected void doSetPurchasePrice_Equal(Integer purchasePrice) {
        regPurchasePrice(CK_EQ, purchasePrice);
    }

    /**
     * NotEqual(<>). And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePrice The value of purchasePrice as notEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchasePrice_NotEqual(Integer purchasePrice) {
        doSetPurchasePrice_NotEqual(purchasePrice);
    }

    protected void doSetPurchasePrice_NotEqual(Integer purchasePrice) {
        regPurchasePrice(CK_NES, purchasePrice);
    }

    /**
     * GreaterThan(>). And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePrice The value of purchasePrice as greaterThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchasePrice_GreaterThan(Integer purchasePrice) {
        regPurchasePrice(CK_GT, purchasePrice);
    }

    /**
     * LessThan(<). And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePrice The value of purchasePrice as lessThan. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchasePrice_LessThan(Integer purchasePrice) {
        regPurchasePrice(CK_LT, purchasePrice);
    }

    /**
     * GreaterEqual(>=). And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePrice The value of purchasePrice as greaterEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchasePrice_GreaterEqual(Integer purchasePrice) {
        regPurchasePrice(CK_GE, purchasePrice);
    }

    /**
     * LessEqual(<=). And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePrice The value of purchasePrice as lessEqual. (basically NotNull: error as default, or no condition as option)
     */
    public void setPurchasePrice_LessEqual(Integer purchasePrice) {
        regPurchasePrice(CK_LE, purchasePrice);
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param minNumber The min number of purchasePrice. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of purchasePrice. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of range-of. (NotNull)
     */
    public void setPurchasePrice_RangeOf(Integer minNumber, Integer maxNumber, ConditionOptionCall<RangeOfOption> opLambda) {
        setPurchasePrice_RangeOf(minNumber, maxNumber, xcROOP(opLambda));
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param minNumber The min number of purchasePrice. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of purchasePrice. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param rangeOfOption The option of range-of. (NotNull)
     */
    protected void setPurchasePrice_RangeOf(Integer minNumber, Integer maxNumber, RangeOfOption rangeOfOption) {
        regROO(minNumber, maxNumber, xgetCValuePurchasePrice(), "PURCHASE_PRICE", rangeOfOption);
    }

    /**
     * InScope {in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePriceList The collection of purchasePrice as inScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPurchasePrice_InScope(Collection<Integer> purchasePriceList) {
        doSetPurchasePrice_InScope(purchasePriceList);
    }

    protected void doSetPurchasePrice_InScope(Collection<Integer> purchasePriceList) {
        regINS(CK_INS, cTL(purchasePriceList), xgetCValuePurchasePrice(), "PURCHASE_PRICE");
    }

    /**
     * NotInScope {not in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (購入価格)PURCHASE_PRICE: {IX, NotNull, INT(10)}
     * @param purchasePriceList The collection of purchasePrice as notInScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPurchasePrice_NotInScope(Collection<Integer> purchasePriceList) {
        doSetPurchasePrice_NotInScope(purchasePriceList);
    }

    protected void doSetPurchasePrice_NotInScope(Collection<Integer> purchasePriceList) {
        regINS(CK_NINS, cTL(purchasePriceList), xgetCValuePurchasePrice(), "PURCHASE_PRICE");
    }

    protected void regPurchasePrice(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValuePurchasePrice(), "PURCHASE_PRICE"); }
    protected abstract ConditionValue xgetCValuePurchasePrice();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}
     * @param paymentCompleteFlg The value of paymentCompleteFlg as equal. (basically NotNull: error as default, or no condition as option)
     */
    protected void setPaymentCompleteFlg_Equal(Integer paymentCompleteFlg) {
        doSetPaymentCompleteFlg_Equal(paymentCompleteFlg);
    }

    /**
     * Equal(=). As Flg. And NullIgnored, OnlyOnceRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}

     * general boolean classification for every flg-column
     * @param cdef The instance of classification definition (as ENUM type). (basically NotNull: error as default, or no condition as option)
     */
    public void setPaymentCompleteFlg_Equal_AsFlg(CDef.Flg cdef) {
        doSetPaymentCompleteFlg_Equal(cTNum(cdef != null ? cdef.code() : null, Integer.class));
    }

    /**
     * Equal(=). As boolean for Flg.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}

     * general boolean classification for every flg-column
     * @param determination The determination, true or false. (basically NotNull: error as default, or no condition as option)
     */
    public void setPaymentCompleteFlg_Equal_AsBoolean(Boolean determination) {
        setPaymentCompleteFlg_Equal_AsFlg(CDef.Flg.of(determination).get());
    }

    /**
     * Equal(=). As True (1). And NullIgnored, OnlyOnceRegistered.

     * Checked: means yes
     */
    public void setPaymentCompleteFlg_Equal_True() {
        setPaymentCompleteFlg_Equal_AsFlg(CDef.Flg.True);
    }

    /**
     * Equal(=). As False (0). And NullIgnored, OnlyOnceRegistered.

     * Unchecked: means no
     */
    public void setPaymentCompleteFlg_Equal_False() {
        setPaymentCompleteFlg_Equal_AsFlg(CDef.Flg.False);
    }

    protected void doSetPaymentCompleteFlg_Equal(Integer paymentCompleteFlg) {
        regPaymentCompleteFlg(CK_EQ, paymentCompleteFlg);
    }

    /**
     * NotEqual(<>). And NullIgnored, OnlyOnceRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}
     * @param paymentCompleteFlg The value of paymentCompleteFlg as notEqual. (basically NotNull: error as default, or no condition as option)
     */
    protected void setPaymentCompleteFlg_NotEqual(Integer paymentCompleteFlg) {
        doSetPaymentCompleteFlg_NotEqual(paymentCompleteFlg);
    }

    /**
     * NotEqual(<>). As Flg. And NullIgnored, OnlyOnceRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}

     * general boolean classification for every flg-column
     * @param cdef The instance of classification definition (as ENUM type). (basically NotNull: error as default, or no condition as option)
     */
    public void setPaymentCompleteFlg_NotEqual_AsFlg(CDef.Flg cdef) {
        doSetPaymentCompleteFlg_NotEqual(cTNum(cdef != null ? cdef.code() : null, Integer.class));
    }

    /**
     * NotEqual(<>). As True (1). And NullIgnored, OnlyOnceRegistered.

     * Checked: means yes
     */
    public void setPaymentCompleteFlg_NotEqual_True() {
        setPaymentCompleteFlg_NotEqual_AsFlg(CDef.Flg.True);
    }

    /**
     * NotEqual(<>). As False (0). And NullIgnored, OnlyOnceRegistered.

     * Unchecked: means no
     */
    public void setPaymentCompleteFlg_NotEqual_False() {
        setPaymentCompleteFlg_NotEqual_AsFlg(CDef.Flg.False);
    }

    protected void doSetPaymentCompleteFlg_NotEqual(Integer paymentCompleteFlg) {
        regPaymentCompleteFlg(CK_NES, paymentCompleteFlg);
    }

    /**
     * InScope {in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}
     * @param paymentCompleteFlgList The collection of paymentCompleteFlg as inScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    protected void setPaymentCompleteFlg_InScope(Collection<Integer> paymentCompleteFlgList) {
        doSetPaymentCompleteFlg_InScope(paymentCompleteFlgList);
    }

    /**
     * InScope {in (1, 2)}. As Flg. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}

     * general boolean classification for every flg-column
     * @param cdefList The list of classification definition (as ENUM type). (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPaymentCompleteFlg_InScope_AsFlg(Collection<CDef.Flg> cdefList) {
        doSetPaymentCompleteFlg_InScope(cTNumL(cdefList, Integer.class));
    }

    protected void doSetPaymentCompleteFlg_InScope(Collection<Integer> paymentCompleteFlgList) {
        regINS(CK_INS, cTL(paymentCompleteFlgList), xgetCValuePaymentCompleteFlg(), "PAYMENT_COMPLETE_FLG");
    }

    /**
     * NotInScope {not in (1, 2)}. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}
     * @param paymentCompleteFlgList The collection of paymentCompleteFlg as notInScope. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    protected void setPaymentCompleteFlg_NotInScope(Collection<Integer> paymentCompleteFlgList) {
        doSetPaymentCompleteFlg_NotInScope(paymentCompleteFlgList);
    }

    /**
     * NotInScope {not in (1, 2)}. As Flg. And NullIgnored, NullElementIgnored, SeveralRegistered.

     * (支払完了フラグ)PAYMENT_COMPLETE_FLG: {NotNull, INT(10), classification=Flg}

     * general boolean classification for every flg-column
     * @param cdefList The list of classification definition (as ENUM type). (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setPaymentCompleteFlg_NotInScope_AsFlg(Collection<CDef.Flg> cdefList) {
        doSetPaymentCompleteFlg_NotInScope(cTNumL(cdefList, Integer.class));
    }

    protected void doSetPaymentCompleteFlg_NotInScope(Collection<Integer> paymentCompleteFlgList) {
        regINS(CK_NINS, cTL(paymentCompleteFlgList), xgetCValuePaymentCompleteFlg(), "PAYMENT_COMPLETE_FLG");
    }

    protected void regPaymentCompleteFlg(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValuePaymentCompleteFlg(), "PAYMENT_COMPLETE_FLG"); }
    protected abstract ConditionValue xgetCValuePaymentCompleteFlg();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (登録日時)REGISTER_DATETIME: {NotNull, DATETIME(19)}
     * @param registerDatetime The value of registerDatetime as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setRegisterDatetime_Equal(java.time.LocalDateTime registerDatetime) {
        regRegisterDatetime(CK_EQ,  registerDatetime);
    }

    /**
     * FromTo with various options. (versatile) {(default) fromDatetime <= column <= toDatetime}

     * And NullIgnored, OnlyOnceRegistered.

     * (登録日時)REGISTER_DATETIME: {NotNull, DATETIME(19)}
     *
e.g. setRegisterDatetime_FromTo(fromDate, toDate, op -> op.compareAsDate());

     * @param fromDatetime The from-datetime(yyyy/MM/dd HH:mm:ss.SSS) of registerDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param toDatetime The to-datetime(yyyy/MM/dd HH:mm:ss.SSS) of registerDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of from-to. (NotNull)
     */
    public void setRegisterDatetime_FromTo(java.time.LocalDateTime fromDatetime, java.time.LocalDateTime toDatetime, ConditionOptionCall<FromToOption> opLambda) {
        setRegisterDatetime_FromTo(fromDatetime, toDatetime, xcFTOP(opLambda));
    }

    /**
     * FromTo with various options. (versatile) {(default) fromDatetime <= column <= toDatetime}

     * And NullIgnored, OnlyOnceRegistered.

     * (登録日時)REGISTER_DATETIME: {NotNull, DATETIME(19)}
     *
e.g. setRegisterDatetime_FromTo(fromDate, toDate, new FromToOption().compareAsDate());

     * @param fromDatetime The from-datetime(yyyy/MM/dd HH:mm:ss.SSS) of registerDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param toDatetime The to-datetime(yyyy/MM/dd HH:mm:ss.SSS) of registerDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param fromToOption The option of from-to. (NotNull)
     */
    protected void setRegisterDatetime_FromTo(java.time.LocalDateTime fromDatetime, java.time.LocalDateTime toDatetime, FromToOption fromToOption) {
        String nm = "REGISTER_DATETIME"; FromToOption op = fromToOption;
        regFTQ(xfFTHD(fromDatetime, nm, op), xfFTHD(toDatetime, nm, op), xgetCValueRegisterDatetime(), nm, op);
    }

    protected void regRegisterDatetime(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueRegisterDatetime(), "REGISTER_DATETIME"); }
    protected abstract ConditionValue xgetCValueRegisterDatetime();

    /**
     * Equal(=). And NullOrEmptyIgnored, OnlyOnceRegistered.

     * (登録ユーザー)REGISTER_USER: {NotNull, VARCHAR(200)}
     * @param registerUser The value of registerUser as equal. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setRegisterUser_Equal(String registerUser) {
        doSetRegisterUser_Equal(fRES(registerUser));
    }

    protected void doSetRegisterUser_Equal(String registerUser) {
        regRegisterUser(CK_EQ, registerUser);
    }

    protected void regRegisterUser(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueRegisterUser(), "REGISTER_USER"); }
    protected abstract ConditionValue xgetCValueRegisterUser();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (更新日時)UPDATE_DATETIME: {NotNull, DATETIME(19)}
     * @param updateDatetime The value of updateDatetime as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setUpdateDatetime_Equal(java.time.LocalDateTime updateDatetime) {
        regUpdateDatetime(CK_EQ,  updateDatetime);
    }

    /**
     * FromTo with various options. (versatile) {(default) fromDatetime <= column <= toDatetime}

     * And NullIgnored, OnlyOnceRegistered.

     * (更新日時)UPDATE_DATETIME: {NotNull, DATETIME(19)}
     *
e.g. setUpdateDatetime_FromTo(fromDate, toDate, op -> op.compareAsDate());

     * @param fromDatetime The from-datetime(yyyy/MM/dd HH:mm:ss.SSS) of updateDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param toDatetime The to-datetime(yyyy/MM/dd HH:mm:ss.SSS) of updateDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of from-to. (NotNull)
     */
    public void setUpdateDatetime_FromTo(java.time.LocalDateTime fromDatetime, java.time.LocalDateTime toDatetime, ConditionOptionCall<FromToOption> opLambda) {
        setUpdateDatetime_FromTo(fromDatetime, toDatetime, xcFTOP(opLambda));
    }

    /**
     * FromTo with various options. (versatile) {(default) fromDatetime <= column <= toDatetime}

     * And NullIgnored, OnlyOnceRegistered.

     * (更新日時)UPDATE_DATETIME: {NotNull, DATETIME(19)}
     *
e.g. setUpdateDatetime_FromTo(fromDate, toDate, new FromToOption().compareAsDate());

     * @param fromDatetime The from-datetime(yyyy/MM/dd HH:mm:ss.SSS) of updateDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param toDatetime The to-datetime(yyyy/MM/dd HH:mm:ss.SSS) of updateDatetime. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param fromToOption The option of from-to. (NotNull)
     */
    protected void setUpdateDatetime_FromTo(java.time.LocalDateTime fromDatetime, java.time.LocalDateTime toDatetime, FromToOption fromToOption) {
        String nm = "UPDATE_DATETIME"; FromToOption op = fromToOption;
        regFTQ(xfFTHD(fromDatetime, nm, op), xfFTHD(toDatetime, nm, op), xgetCValueUpdateDatetime(), nm, op);
    }

    protected void regUpdateDatetime(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueUpdateDatetime(), "UPDATE_DATETIME"); }
    protected abstract ConditionValue xgetCValueUpdateDatetime();

    /**
     * Equal(=). And NullOrEmptyIgnored, OnlyOnceRegistered.

     * (更新ユーザー)UPDATE_USER: {NotNull, VARCHAR(200)}
     * @param updateUser The value of updateUser as equal. (basically NotNull, NotEmpty: error as default, or no condition as option)
     */
    public void setUpdateUser_Equal(String updateUser) {
        doSetUpdateUser_Equal(fRES(updateUser));
    }

    protected void doSetUpdateUser_Equal(String updateUser) {
        regUpdateUser(CK_EQ, updateUser);
    }

    protected void regUpdateUser(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueUpdateUser(), "UPDATE_USER"); }
    protected abstract ConditionValue xgetCValueUpdateUser();

    /**
     * Equal(=). And NullIgnored, OnlyOnceRegistered.

     * (バージョン番号)VERSION_NO: {NotNull, BIGINT(19)}
     * @param versionNo The value of versionNo as equal. (basically NotNull: error as default, or no condition as option)
     */
    public void setVersionNo_Equal(Long versionNo) {
        doSetVersionNo_Equal(versionNo);
    }

    protected void doSetVersionNo_Equal(Long versionNo) {
        regVersionNo(CK_EQ, versionNo);
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (バージョン番号)VERSION_NO: {NotNull, BIGINT(19)}
     * @param minNumber The min number of versionNo. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of versionNo. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param opLambda The callback for option of range-of. (NotNull)
     */
    public void setVersionNo_RangeOf(Long minNumber, Long maxNumber, ConditionOptionCall<RangeOfOption> opLambda) {
        setVersionNo_RangeOf(minNumber, maxNumber, xcROOP(opLambda));
    }

    /**
     * RangeOf with various options. (versatile)

     * {(default) minNumber <= column <= maxNumber}

     * And NullIgnored, OnlyOnceRegistered.

     * (バージョン番号)VERSION_NO: {NotNull, BIGINT(19)}
     * @param minNumber The min number of versionNo. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param maxNumber The max number of versionNo. (basically NotNull: if op.allowOneSide(), null allowed)
     * @param rangeOfOption The option of range-of. (NotNull)
     */
    protected void setVersionNo_RangeOf(Long minNumber, Long maxNumber, RangeOfOption rangeOfOption) {
        regROO(minNumber, maxNumber, xgetCValueVersionNo(), "VERSION_NO", rangeOfOption);
    }

    protected void regVersionNo(ConditionKey ky, Object vl) { regQ(ky, vl, xgetCValueVersionNo(), "VERSION_NO"); }
    protected abstract ConditionValue xgetCValueVersionNo();

    // ===================================================================================
    //                                                                     ScalarCondition
    //                                                                     ===============
    /**
     * Prepare ScalarCondition as equal.

     * {where FOO = (select max(BAR) from ...)}
     *

     * cb.query().scalar_Equal().avg(purchaseCB -> {
     *     purchaseCB.specify().columnPurchasePrice(); // *Point!
     *     purchaseCB.query().setPaymentCompleteFlg_Equal_True();
     * });
     *

     * @return The object to set up a function. (NotNull)
     */
    public HpSLCFunction<PurchaseCB> scalar_Equal() {
        return xcreateSLCFunction(CK_EQ, PurchaseCB.class);
    }

    /**
     * Prepare ScalarCondition as equal.

     * {where FOO <> (select max(BAR) from ...)}
     *

     * cb.query().scalar_Equal().avg(purchaseCB -> {
     *     purchaseCB.specify().columnPurchasePrice(); // *Point!
     *     purchaseCB.query().setPaymentCompleteFlg_Equal_True();
     * });
     *

     * @return The object to set up a function. (NotNull)
     */
    public HpSLCFunction<PurchaseCB> scalar_NotEqual() {
        return xcreateSLCFunction(CK_NES, PurchaseCB.class);
    }

    /**
     * Prepare ScalarCondition as greaterThan.

     * {where FOO > (select max(BAR) from ...)}
     *

     * cb.query().scalar_Equal().avg(purchaseCB -> {
     *     purchaseCB.specify().columnPurchasePrice(); // *Point!
     *     purchaseCB.query().setPaymentCompleteFlg_Equal_True();
     * });
     *

     * @return The object to set up a function. (NotNull)
     */
    public HpSLCFunction<PurchaseCB> scalar_GreaterThan() {
        return xcreateSLCFunction(CK_GT, PurchaseCB.class);
    }

    /**
     * Prepare ScalarCondition as lessThan.

     * {where FOO < (select max(BAR) from ...)}
     *

     * cb.query().scalar_Equal().avg(purchaseCB -> {
     *     purchaseCB.specify().columnPurchasePrice(); // *Point!
     *     purchaseCB.query().setPaymentCompleteFlg_Equal_True();
     * });
     *

     * @return The object to set up a function. (NotNull)
     */
    public HpSLCFunction<PurchaseCB> scalar_LessThan() {
        return xcreateSLCFunction(CK_LT, PurchaseCB.class);
    }

    /**
     * Prepare ScalarCondition as greaterEqual.

     * {where FOO >= (select max(BAR) from ...)}
     *

     * cb.query().scalar_Equal().avg(purchaseCB -> {
     *     purchaseCB.specify().columnPurchasePrice(); // *Point!
     *     purchaseCB.query().setPaymentCompleteFlg_Equal_True();
     * });
     *

     * @return The object to set up a function. (NotNull)
     */
    public HpSLCFunction<PurchaseCB> scalar_GreaterEqual() {
        return xcreateSLCFunction(CK_GE, PurchaseCB.class);
    }

    /**
     * Prepare ScalarCondition as lessEqual.

     * {where FOO <= (select max(BAR) from ...)}
     *

     * cb.query().scalar_LessEqual().max(new SubQuery<PurchaseCB>() {
     *     public void query(PurchaseCB subCB) {
     *         subCB.specify().setFoo... // derived column for function
     *         subCB.query().setBar...
     *     }
     * });
     *

     * @return The object to set up a function. (NotNull)
     */
    public HpSLCFunction<PurchaseCB> scalar_LessEqual() {
        return xcreateSLCFunction(CK_LE, PurchaseCB.class);
    }

    @SuppressWarnings("unchecked")
    protected <CB extends ConditionBean> void xscalarCondition(String fn, SubQuery<CB> sq, String rd, HpSLCCustomized<CB> cs, ScalarConditionOption op) {
        assertObjectNotNull("subQuery", sq);
        PurchaseCB cb = xcreateScalarConditionCB(); sq.query((CB)cb);
        String pp = keepScalarCondition(cb.query()); // for saving query-value
        cs.setPartitionByCBean((CB)xcreateScalarConditionPartitionByCB()); // for using partition-by
        registerScalarCondition(fn, cb.query(), pp, rd, cs, op);
    }
    public abstract String keepScalarCondition(PurchaseCQ sq);

    protected PurchaseCB xcreateScalarConditionCB() {
        PurchaseCB cb = newMyCB(); cb.xsetupForScalarCondition(this); return cb;
    }

    protected PurchaseCB xcreateScalarConditionPartitionByCB() {
        PurchaseCB cb = newMyCB(); cb.xsetupForScalarConditionPartitionBy(this); return cb;
    }

    // ===================================================================================
    //                                                                       MyselfDerived
    //                                                                       =============
    public void xsmyselfDerive(String fn, SubQuery<PurchaseCB> sq, String al, DerivedReferrerOption op) {
        assertObjectNotNull("subQuery", sq);
        PurchaseCB cb = new PurchaseCB(); cb.xsetupForDerivedReferrer(this);
        lockCall(() -> sq.query(cb)); String pp = keepSpecifyMyselfDerived(cb.query()); String pk = "PURCHASE_ID";
        registerSpecifyMyselfDerived(fn, cb.query(), pk, pk, pp, "myselfDerived", al, op);
    }
    public abstract String keepSpecifyMyselfDerived(PurchaseCQ sq);

    /**
     * Prepare for (Query)MyselfDerived (correlated sub-query).
     * @return The object to set up a function for myself table. (NotNull)
     */
    public HpQDRFunction<PurchaseCB> myselfDerived() {
        return xcreateQDRFunctionMyselfDerived(PurchaseCB.class);
    }
    @SuppressWarnings("unchecked")
    protected <CB extends ConditionBean> void xqderiveMyselfDerived(String fn, SubQuery<CB> sq, String rd, Object vl, DerivedReferrerOption op) {
        assertObjectNotNull("subQuery", sq);
        PurchaseCB cb = new PurchaseCB(); cb.xsetupForDerivedReferrer(this); sq.query((CB)cb);
        String pk = "PURCHASE_ID";
        String sqpp = keepQueryMyselfDerived(cb.query()); // for saving query-value.
        String prpp = keepQueryMyselfDerivedParameter(vl);
        registerQueryMyselfDerived(fn, cb.query(), pk, pk, sqpp, "myselfDerived", rd, vl, prpp, op);
    }
    public abstract String keepQueryMyselfDerived(PurchaseCQ sq);
    public abstract String keepQueryMyselfDerivedParameter(Object vl);

    // ===================================================================================
    //                                                                        MyselfExists
    //                                                                        ============
    /**
     * Prepare for MyselfExists (correlated sub-query).
     * @param subCBLambda The implementation of sub-query. (NotNull)
     */
    public void myselfExists(SubQuery<PurchaseCB> subCBLambda) {
        assertObjectNotNull("subCBLambda", subCBLambda);
        PurchaseCB cb = new PurchaseCB(); cb.xsetupForMyselfExists(this);
        lockCall(() -> subCBLambda.query(cb)); String pp = keepMyselfExists(cb.query());
        registerMyselfExists(cb.query(), pp);
    }
    public abstract String keepMyselfExists(PurchaseCQ sq);

    // ===================================================================================
    //                                                                        Manual Order
    //                                                                        ============
    /**
     * Order along manual ordering information.
     *

     * cb.query().addOrderBy_Birthdate_Asc().withManualOrder(op -> {
     *     op.when_GreaterEqual(priorityDate); // e.g. 2000/01/01
     * });
     * // order by
     * //   case
     * //     when BIRTHDATE >= '2000/01/01' then 0
     * //     else 1
     * //   end asc, ...
     *
     * cb.query().addOrderBy_MemberStatusCode_Asc().withManualOrder(op -> {
     *     op.when_Equal(CDef.MemberStatus.Withdrawal);
     *     op.when_Equal(CDef.MemberStatus.Formalized);
     *     op.when_Equal(CDef.MemberStatus.Provisional);
     * });
     * // order by
     * //   case
     * //     when MEMBER_STATUS_CODE = 'WDL' then 0
     * //     when MEMBER_STATUS_CODE = 'FML' then 1
     * //     when MEMBER_STATUS_CODE = 'PRV' then 2
     * //     else 3
     * //   end asc, ...
     *

     *
This function with Union is unsupported!

     *
The order values are bound (treated as bind parameter).

     * @param opLambda The callback for option of manual-order containing order values. (NotNull)
     */
    public void withManualOrder(ManualOrderOptionCall opLambda) { // is user public!
        xdoWithManualOrder(cMOO(opLambda));
    }

    // ===================================================================================
    //                                                                    Small Adjustment
    //                                                                    ================
    // ===================================================================================
    //                                                                       Very Internal
    //                                                                       =============
    protected PurchaseCB newMyCB() {
        return new PurchaseCB();
    }
    // very internal (for suppressing warn about 'Not Use Import')
    protected String xabUDT() { return Date.class.getName(); }
    protected String xabCQ() { return PurchaseCQ.class.getName(); }
    protected String xabLSO() { return LikeSearchOption.class.getName(); }
    protected String xabSLCS() { return HpSLCSetupper.class.getName(); }
    protected String xabSCP() { return SubQuery.class.getName(); }
}


text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace IOER.My {

    public partial class Authored {

        /// <summary>
        /// ScriptManager1 control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::AjaxControlToolkit.ToolkitScriptManager ScriptManager1;

        /// <summary>
        /// noContentMesssage control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Label noContentMesssage;

        /// <summary>
        /// searchPanel control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Panel searchPanel;

        /// <summary>
        /// search1 control.
        /// </summary>
        /// <remarks>
        /// Auto-generated field.
        /// To modify move field declaration from designer file to code-behind file.
        /// </remarks>
        protected global::IOER.Controls.Content.ContentSearch search1;
    }
}


text:
using namespace std;

namespace HlslToGlsl
{

void WriteHeaderOfGlsl(string& outputGlsl);

bool ConvertHlslToGlslFromFile(const string& filename, const string& entryFunctionName, bool isVertexShader, string& outputGlsl)
{
    outputGlsl = "";

    ifstream inputFile(filename);
    if (!inputFile.is_open())
    {
        return false;
    }

    string inputHlsl;
    inputFile.seekg(0, std::ios::end);
    inputHlsl.reserve((size_t) inputFile.tellg());
    inputHlsl.resize((size_t) inputFile.tellg());
    inputFile.seekg(0, std::ios::beg);

    inputFile.read(&inputHlsl[0], inputHlsl.length());

    return ConvertHlslToGlslFromSource(inputHlsl, entryFunctionName, isVertexShader, outputGlsl);
}

bool ConvertHlslToGlslFromSource(const string& hlslSource, const string& entryFunctionName, bool isVertexShader, string& outputGlsl)
{
    vector<Lexeme> lexemes = ParseIntoLexemes(hlslSource);

    WriteHeaderOfGlsl(outputGlsl);
    ConvertLexemesIntoGlsl(lexemes, entryFunctionName, isVertexShader, outputGlsl);

    return true;
}

void WriteHeaderOfGlsl(string& outputGlsl)
{
    outputGlsl += "#version 420\n";
}

}


text: this is about the motel monthly calculation and payment of the customer


text:
$(document).ready(function () {
    compareSize();
    gridBuilder('1-1', '13-7');
    prepGame();
    // if not using the a minified version of the game.
    if ($('#using_builder').length <= 0) {
        console.log('Loading Scripts');
        addScript('src/Math.js');
        addScript('src/Cell.js');
        addScript('src/Swipe.js');
        addScript('src/Actor.js');
        addScript('src/Enemy.js');
        addScript('src/Assets/Tunes.js');
        addScript('src/Assets/Shaders.js');
        addScript('src/Grid.js');
        addScript('src/Color.js');
        addScript('src/index.js');
        console.log('Loaded Scripts');
    }
    createModeSelector();
});

function prepGame() {
    //Visually prepares the game area
    prepCell('1-1', '13-7');
    $('.gamecont').css({
        'border': border + 'px solid #bbb',
        'width': cellSize * 7,
        'height': cellSize * 13
    });
}

function createGame(callback) {

    //Inject gamemode first value to GameType variable
    GameType = gamemode[0];

    if (GameType === 'PaintStack') {
        indicator = new uiCell(2, '2-1', 'enemies', 'en', function () {
            return Math.floor(actor.markedArea) + '%';
        });
    } else if (GameType === 'Endless') {
        indicator = new uiCell(2, '2-1', 'enemies', 'en', function () {
            return Math.round(timeSinceLevelLoad) + ' s';
        });
    } else {
        indicator = new uiCell(2, '2-1', 'enemies', 'en', function () {
            return SkipStack.CurrentScore;
        });
    }

    //Make a flipcard div spanning 4-1 and 10-7 including areas
    var a = selectComplex('4-1', '10-7', 'SkipStack', ['.preview', '.prev', '.next', '.modeselector']);
    a.children('.back').attr('id', 'SkipStack');
    //Create game object
    game = new Phaser.Game(Editor_Width, Editor_Height, Phaser.AUTO, 'SkipStack', {
        preload: preload,
        create: create,
        update: update,
        maxWidth: 7 * cellSize,
        maxHeight: 7 * cellSize
    });

    var bar = genBar('#SkipStack');

    if (gamemode[0] === 'PaintStack') {
        indicator.refresh = function () {
            if (indicator.rendered) {
                this.text(Math.floor(actor.markedArea) + '%');
            };
        };
    }

    indicator.generate();

    flip(a.not('.SkipStack>*'));
    setTimeout(function () {
        FlipcardtoArea(a);
    }, 500);
    setTimeout(function () {
        indicator.flip();
    }, 300);

    if (callback !== undefined) {
        callback();
    }

    return a;
}

function createPlayButton() {
    createButton('7-4', 'play').click(function () {
        createGame();
    });
}

function createTextCont(span, text) {
    var div = $('<div />');
    div.css({
        'width': (span * cellSize) + 'px',
        //'height': '100%',
        'text-align': 'center',
        'font-size': 0.8 * cellSize + 'px',
        'position': 'fixed',

        'top': '50%',
        'transform': 'translateY(-50%)'
    });
    div.text(text);
    return div;
}

function injectText(text, container) {
    var tl;
    var br;
    if (container.hasClass('back')) {
        tl = container.parent().data('tl');
        br = container.parent().data('br');
    } else {
        tl = container.data('tl');
        br = container.data('br');
    }
    var span = Number(br.split('-')[1]) - Number(tl.split('-')[1]) + 1;
    var div = createTextCont(span, text);
    div.appendTo(container);
    return container;
}

function createModeSelector() {
    var prev = gridToFlipCard('10-1', '10-1', 'prev');
    var next = gridToFlipCard('10-7', '10-7', 'next');

    prev.children('.back').css({
        'box-sizing': 'border-box',
        'background-color': '#ffffff',
        'border': border + 'px solid rgb(0, 0, 0)'
    }).click(function () {
        prevMode();
    });

    next.children('.back').css({
        'box-sizing': 'border-box',
        'background-color': '#ffffff',
        'border': border + 'px solid rgb(0, 0, 0)'
    }).click(function () {
        nextMode();
    });

    var selector = gridToFlipCard('10-2', '10-6', 'modeselector');

    var preview = gridToFlipCard('4-2', '7-6', 'preview');

    selector.children('.back').css({
        'box-sizing': 'border-box',
        'background-color': '#ffffff',
        'border': border + 'px solid rgb(0, 0, 0)'
    });

    injectText('Normal', selector.children('.back'));

    preview.children('.back').css({
        'box-sizing': 'border-box',
        'background-color': '#ffffff',
        'border': border + 'px solid rgb(0, 0, 0)'
    });

    injectText('[Normal preview]', preview.children('.back'));

    setTimeout(function () {
        prev = flip(prev);
    }, 100);
    setTimeout(function () {
        preview = flip(preview);
    }, 200);
    setTimeout(function () {
        next = flip(next);
    }, 100);
    selector = flip(selector);

    setTimeout(function () {
        //doubleSelector(selector)
        selector = FlipcardtoArea(selector, handleGameCreate);
        preview = FlipcardtoArea(preview, handlePreview);
        next = FlipcardtoArea(next);
        prev = FlipcardtoArea(prev);
    }, 1000);

}

function handlePreview() {
    disp = doubleAreaFlipcard(disp, 'preview');
    injectText('disp', disp.children('.back'));
    disp.click(function () {
        createGame();
    });
}

function handleGameCreate() {
    disp = doubleAreaFlipcard(disp, 'modeselector');
    injectText('disp', disp.children('.back'));
    disp.click(function () {
        createGame();
    });
}

function flipSelector(obj, newtext, rot) {
    if (obj.data('face') == 'front') {
        obj.data('face', 'back');
        obj.children('.back > div').text(newtext);
    } else {
        obj.data('face', 'front');
        obj.children('.front > div').text(newtext);
    }
    flip(obj.not('.flipcard > *'), rot);
}

function nextMode() {
    arrayRotate(gamemode, true);
    setTimeout(function () {
        flipSelector($('.preview'), ('[' + gamemode[0] + ' preview]'));

    }, 50);
    flipSelector($('.modeselector'), gamemode[0]);
}

function prevMode() {
    arrayRotate(gamemode);
    setTimeout(function () {
        flipSelector($('.preview'), ('[' + gamemode[0] + ' preview]'), true);
    }, 50);
    flipSelector($('.modeselector'), gamemode[0], true);

}

//========================\\
//       In-game ui       \\
//========================\\

var indicator;


text:
using System;
using System.Collections;
using System.Collections.Generic;
using Xunit;
using TypeLess;

namespace TypeLess.Tests
{
    public class ObjectAssertionTest
    {

        class A {
            public int B { get; set; }
            public int C { get; set; }
        }

        ObjectAssertion CanDelete(A a) {
            return ObjectAssertion.New(
                a.If().IsTrue(x => x.B == 1, "B must not be 1"),
                a.If().IsTrue(x => x.C == 2, "C must not be 2")
            );
        }

        [Fact]
        public void WhenRulesAreValidThenReturnTrue()
        {
            var a = new A() { B = 1, C = 2 }; //values are correct according to the rules of CanDelete

            Assert.Equal(true, CanDelete(a).True);
            int errorCount = 0;
            Assert.Equal(0, errorCount);

            a.B = 2;
            Assert.Equal(false, CanDelete(a).True);

            a.C = 3;
            Assert.Equal(false, CanDelete(a).True);
        }

        [Fact]
        public void WhenRulesAreInvalidThenReturnFalse()
        {
            var a = new A() { B = 1, C = 2 };
            Assert.Equal(false, CanDelete(a).False);

            //Check current error message
            Assert.Equal("B must not be 1 and C must not be 2", CanDelete(a).ToString());

            a.B = 2;
            Assert.Equal(true, CanDelete(a).False);
            Assert.Equal("C must not be 2", CanDelete(a).ToString());

            a.C = 3;
            Assert.Equal(true, CanDelete(a).False);
        }

        ObjectAssertion CanUpdate(A a)
        {
            //this is not testing to see if something is invalid ... its testing validity
            return ObjectAssertion.New(
                a.If().EvalPositive.IsTrue(x => x.B == 1, "B must be 1"),
                a.If().EvalPositive.IsTrue(x => x.C == 2, "C must be 2")
            );
        }

        [Fact]
        public void RulesNotValidCanThrow()
        {
            var a = new A() { B = 2, C = 2 };

            var ex = Assert.Throws<ArgumentException>(() =>
            {
                CanUpdate(a).ThrowIfFalse<ArgumentException>();
            });

            var msg = ex.Message;

            Assert.Equal("B must be 1", msg);

            a.B = 1;

                CanUpdate(a).ThrowIfFalse<ArgumentNullException>();

            a.C = 3;
            ex = Assert.Throws<ArgumentException>(() =>
            {
                CanUpdate(a).ThrowIfFalse<ArgumentException>();
            });

            msg = ex.Message;

            Assert.Equal("C must be 2", msg);

            a.B = 2;
            ex = Assert.Throws<ArgumentException>(() =>
            {
                CanUpdate(a).ThrowIfFalse<ArgumentException>();
            });

            msg = ex.Message;

            Assert.Equal("B must be 1 and C must be 2", msg);

        }

        [Fact]
        public void RulesValidCanNotThrow()
        {

            var a = new A() { B = 1, C = 2 };
            var ex = Assert.Throws<ArgumentException>(() =>
            {
                CanDelete(a).ThrowIfTrue<ArgumentException>();
            });

            var msg = ex.Message;

            Assert.Equal(msg, "B must not be 1 and C must not be 2");

            a.B = 2;

                CanDelete(a).ThrowIfTrue<ArgumentNullException>();

        }
    }
}


text:
class AddAuthStuff < ActiveRecord::Migration
  def self.up
    remove_column :users, :email
    remove_column :users, :login
    change_table :users do |t|
      t.string    :login,               :null => false                # optional, you can use email instead, or both
      t.string    :email,               :null => false                # optional, you can use login instead, or both
      t.string    :crypted_password,    :null => false                # optional, see below
      t.string    :password_salt,       :null => false                # optional, but highly recommended
      t.string    :persistence_token,   :null => false                # required
      t.string    :single_access_token, :null => false                # optional, see Authlogic::Session::Params
      t.string    :perishable_token,    :null => false                # optional, see Authlogic::Session::Perishability

      # Magic columns, just like ActiveRecord's created_at and updated_at. These are automatically maintained by Authlogic if they are present.
      t.integer   :login_count,         :null => false, :default => 0 # optional, see Authlogic::Session::MagicColumns
      t.integer   :failed_login_count,  :null => false, :default => 0 # optional, see Authlogic::Session::MagicColumns
      t.datetime  :last_request_at                                    # optional, see Authlogic::Session::MagicColumns
      t.datetime  :current_login_at                                   # optional, see Authlogic::Session::MagicColumns
      t.datetime  :last_login_at                                      # optional, see Authlogic::Session::MagicColumns
      t.string    :current_login_ip                                   # optional, see Authlogic::Session::MagicColumns
      t.string    :last_login_ip                                      # optional, see Authlogic::Session::MagicColumns
   end
   remove_column :users, :password
  end

  def self.down
    remove_column :users, :crypted_password
    remove_column :users, :password_salt
    remove_column :users, :persistence_token
    remove_column :users, :single_access_token
    remove_column :users, :perishable_token
    remove_column :users, :login_count
    remove_column :users, :faild_login_count
    remove_column :users, :last_request_at
    remove_column :users, :current_login_ip
    remove_column :users, :last_login_ip
  end
end


text:
const commander = require('../');

// option with optional value, no default
describe('option with optional value, no default', () => {
  test('when option not specified then value is undefined', () => {
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type');
    program.parse(['node', 'test']);
    expect(program.opts().cheese).toBeUndefined();
  });

  test('when option specified then value is as specified', () => {
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type');
    const cheeseType = 'blue';
    program.parse(['node', 'test', '--cheese', cheeseType]);
    expect(program.opts().cheese).toBe(cheeseType);
  });

  test('when option specified without value then value is true', () => {
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type');
    program.parse(['node', 'test', '--cheese']);
    expect(program.opts().cheese).toBe(true);
  });

  test('when option specified without value and following option then value is true', () => {
    // optional options do not eat values with dashes
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type')
      .option('--some-option');
    program.parse(['node', 'test', '--cheese', '--some-option']);
    expect(program.opts().cheese).toBe(true);
  });
});

// option with optional value, with default
describe('option with optional value, with default', () => {
  test('when option not specified then value is default', () => {
    const defaultValue = 'default';
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type', defaultValue);
    program.parse(['node', 'test']);
    expect(program.opts().cheese).toBe(defaultValue);
  });

  test('when option specified then value is as specified', () => {
    const defaultValue = 'default';
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type', defaultValue);
    const cheeseType = 'blue';
    program.parse(['node', 'test', '--cheese', cheeseType]);
    expect(program.opts().cheese).toBe(cheeseType);
  });

  test('when option specified without value then value is true', () => {
    const defaultValue = 'default';
    const program = new commander.Command();
    program
      .option('--cheese [type]', 'cheese type', defaultValue);
    program.parse(['node', 'test', '--cheese']);
    expect(program.opts().cheese).toBe(true);
  });

  test('when option specified without value and preset then value is preset', () => {
    const program = new commander.Command();
    program
      .addOption(new commander.Option('--cheese [type]').preset('preset'));
    program.parse(['node', 'test', '--cheese']);
    expect(program.opts().cheese).toBe('preset');
  });
});


text:
package skripteditor.addons.skript.exp;

import skripteditor.expressions.Expression;

public class ExpAmount extends Expression {

	@Override
	public void registerUserFriendyPatterns() {
		registerUserFriendyPattern("(amount|number|size) of %objects%");
	}

	@Override
	public void registerPatterns() {
		registerPattern("(amount|number|size) of %objects%");
	}

	@Override
	public String[] getExamples() {
		return new String[] {
				"message \"There are %number of all players% players online!\""
		};
	}

	@Override
	public String getName() {
		return "Amount";
	}

}