text:
namespace bdm {

struct TestParamGroup : public ParamGroup {
  BDM_PARAM_GROUP_HEADER(TestParamGroup, 1);

  real_t test_param1 = 3.14;
  uint64_t test_param2 = 42;
  int test_param3 = -1;
};

}  // namespace bdm

#endif  // UNIT_CORE_PARAM_PARAM_TEST_H_


text:
package io.spring.initializr.service.extension;

import io.spring.initializr.generator.ProjectRequest;
import io.spring.initializr.generator.ProjectRequestPostProcessor;
import io.spring.initializr.metadata.Dependency;
import io.spring.initializr.metadata.InitializrMetadata;
import io.spring.initializr.util.Version;

import org.springframework.stereotype.Component;

/**
 * A {@link ProjectRequestPostProcessor} that automatically adds
 * {@code spring-security-test} when Spring Security is selected.
 *
 * @author Stephane Nicoll
 */
@Component
class SpringSecurityTestRequestPostProcessor extends AbstractProjectRequestPostProcessor {

	private static final Version VERSION_1_3_0 = Version.parse("1.3.0.RELEASE");

	static final Dependency SPRING_SECURITY_TEST = Dependency.withId(
			"security-test", "org.springframework.security",
			"spring-security-test", null, Dependency.SCOPE_TEST);

	@Override
	public void postProcessAfterResolution(ProjectRequest request,
			InitializrMetadata metadata) {
		if (hasDependency(request, "security")
				&& isSpringBootVersionAtLeastAfter(request, VERSION_1_3_0)) {
			request.getResolvedDependencies().add(SPRING_SECURITY_TEST);
		}
	}

}

redpajama_set_name: RedPajamaGithub


text:
package org.newdawn.slick.tests.xml;

/**
 * A test example of some object data that can be configured via XML
 *
 * @author kevin
 */
public class Stats {
	/** hit points */
	private int hp;
	/** magic points */
	private int mp;
	/** age in years */
	private float age;
	/** experience points */
	private int exp;

	/**
	 * Dump this object to sysout
	 *
	 * @param prefix The prefix to apply to all lines
	 */
	public void dump(String prefix) {
		System.out.println(prefix+"Stats "+hp+","+mp+","+age+","+exp);
	}
}


text:
PhotoSwipe Fullscreen Demo
==========================

This is a fork of [PhotoSwipe](http://www.photoswipe.com), the awesome piece of JavaScript that helps display photos on small screens as well as large ones.

This a demo. I used this idea for a while on my own photography site, please **update the example images with your own**.

Changes that I made:
--------------------
- Append a counter to the image gallery
- Loads PhotoSwipe right away without showing the thumbnails (we have no need for thumbnails)
- Adds a heading to the gallery that shows and hides with user mouse clicks/taps/timeout

[View the demo](http://jonathanbell.github.io/fullscreen-photoswipe/)

Install This Demo On Your Own Site:
-----------------------------------
- Download or fork this repo
- Number your image files as such: '001.jpg', '002.jpg', '003.jpg' through '999.jpg' and place them in the '/images' folder, replacing the existing 4 jpg's.
- Change the value of the NumberOfImages (at the top of main.js, ~line 4) to how ever many photos you have.
- Optionally, adjust [the {options} object](http://photoswipe.com/documentation/options.html) if you want to.

TLDR;
-----

I made this demo after seeing [this issue](https://github.com/codecomputerlove/PhotoSwipe/issues/51) and [this issue](https://github.com/codecomputerlove/PhotoSwipe/issues/259) on GitHub. I wanted to do the same thing on my website. I thought that this demo might be helpful for others. :)

Demo made using [photoswipe.js](http://www.photoswipe.com), changed with permission via [the MIT Licence](https://github.com/dimsemenov/PhotoSwipe/blob/master/LICENSE).

For more information, see: [https://github.com/dimsemenov/PhotoSwipe](https://github.com/dimsemenov/PhotoSwipe)


text:
package com.straw.samples.activity.recyclerview;

import android.os.Bundle;
import com.straw.library.slide.support.SlideMode;
import com.straw.samples.R;
import com.straw.samples.activity.base.ModeSwitchableSampleActivity;
import com.straw.samples.activity.layout.RecyclerViewSampleLayout;

public class RecyclerViewSampleActivity extends ModeSwitchableSampleActivity {

    protected RecyclerViewSampleLayout mRecyclerLayout;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_recycler_view_sample);
        mRecyclerLayout = (RecyclerViewSampleLayout)
                findViewById(R.id.recycler_view_layout);
    }

    @Override
    public void switchSlideMode(SlideMode mode) {
        mRecyclerLayout.getSlideRecyclerView().setSlideMode(mode);
    }

    public void setFavViewBkgColorResId(int colorResId) {
        mRecyclerLayout.setFavViewBkgColorResId(colorResId);
    }
}


text:
package org.projog.core.predicate.builtin.classify;

import org.projog.core.predicate.AbstractSingleResultPredicate;
import org.projog.core.term.Term;

/* TEST
%TRUE number(1)
%TRUE number(-1)
%TRUE number(0)
%TRUE number(0.0)
%TRUE number(1.0)
%TRUE number(-1.0)
%FAIL number('1')
%FAIL number('1.0')
%FAIL number(1+1)
%FAIL number(a)
%FAIL number(p(1,2,3))
%FAIL number([1,2,3])
%FAIL number([a,b,c])
%FAIL number([])
%FAIL number(X)
%FAIL number(_)
*/
/**
 * number(X) - checks that a term is numeric.
 *

 * number(X) succeeds if X currently stands for a number.
 *

 */
public final class IsNumber extends AbstractSingleResultPredicate {
   @Override
   protected boolean evaluate(Term arg) {
      return arg.getType().isNumeric();
   }
}


text:
' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

Imports System.Composition
Imports System.Threading
Imports Microsoft.CodeAnalysis.SignatureHelp
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Imports Microsoft.CodeAnalysis.VisualBasic.Utilities.IntrinsicOperators

Namespace Microsoft.CodeAnalysis.VisualBasic.SignatureHelp
    <ExportSignatureHelpProvider("MidAssignmentSignatureHelpProvider", LanguageNames.VisualBasic), [Shared]>
    Partial Friend Class MidAssignmentSignatureHelpProvider
        Inherits AbstractIntrinsicOperatorSignatureHelpProvider(Of AssignmentStatementSyntax)

        Protected Overrides Function GetIntrinsicOperatorDocumentation(node As AssignmentStatementSyntax, document As Document, cancellationToken As CancellationToken) As IEnumerable(Of AbstractIntrinsicOperatorDocumentation)
            Return {New MidAssignmentDocumentation()}
        End Function

        Protected Overrides Function IsTriggerToken(token As SyntaxToken) As Boolean
            Return token.IsKind(SyntaxKind.OpenParenToken, SyntaxKind.CommaToken) AndAlso
               token.Parent.Kind = SyntaxKind.ArgumentList AndAlso
               token.Parent.IsParentKind(SyntaxKind.MidExpression) AndAlso
               token.Parent.Parent.IsParentKind(SyntaxKind.MidAssignmentStatement)
        End Function

        Public Overrides Function IsTriggerCharacter(ch As Char) As Boolean
            Return ch = "("c OrElse ch = ","c
        End Function

        Public Overrides Function IsRetriggerCharacter(ch As Char) As Boolean
            Return False
        End Function

        Protected Overrides Function IsArgumentListToken(node As AssignmentStatementSyntax, token As SyntaxToken) As Boolean
            Return node.Left.IsKind(SyntaxKind.MidExpression) AndAlso
                DirectCast(node.Left, MidExpressionSyntax).ArgumentList.Span.Contains(token.SpanStart) AndAlso
                DirectCast(node.Left, MidExpressionSyntax).ArgumentList.CloseParenToken <> token
        End Function

        Protected Overrides Function GetCurrentArgumentStateWorker(node As SyntaxNode, position As Integer) As SignatureHelpState
            Return MyBase.GetCurrentArgumentStateWorker(DirectCast(DirectCast(node, AssignmentStatementSyntax).Left, MidExpressionSyntax).ArgumentList, position)
        End Function
    End Class
End Namespace


text:
<?xml version="1.0" encoding="UTF-8" ?>

<!--L
   Copyright SAIC, Ellumen and RSNA (CTP)

   Distributed under the OSI-approved BSD 3-Clause License.
   See http://ncip.github.com/national-biomedical-image-archive/LICENSE.txt for details.
L-->

<?xml-stylesheet type="text/xsl"
                 href="http://gforge.nci.nih.gov/svnroot/commonlibrary/trunk/ivy-xsl/ivy.xsl"?>

<ivy-module version="1.0">
  <info organisation="ncicb" module="nbia-liquibase" />

  <configurations>
    <conf name="compile" />
  </configurations>

  <publications>
    <artifact name="nbia-liquibase" type="jar" conf="compile" />
  </publications>

  <dependencies>
    <dependency org="org.liquibase"
                name="liquibase-core"
                rev="1.9.3"
                conf="compile->master"/>

    <dependency org="jtools.org"
                name="ant-classloadertask"
                rev="1.0-RC2"
                conf="compile->master"/>
  </dependencies>

</ivy-module>


text:
<<<<<<< HEAD
<<<<<<< HEAD
var test = require("tap").test
var rimraf = require("rimraf")
var path = require("path")
var osenv = require("osenv")
var mr = require("npm-registry-mock")
var spawn = require("child_process").spawn
var npm = require.resolve("../../bin/npm-cli.js")
var node = process.execPath
var pkg = path.resolve(__dirname, "url-dependencies")
var common = require('../common-tap')

var mockRoutes = {
  "get": {
    "/underscore/-/underscore-1.3.1.tgz": [200]
  }
}

test("url-dependencies: download first time", function(t) {
  cleanup()

  performInstall(function(output){
    if(!tarballWasFetched(output)){
      t.fail("Tarball was not fetched")
    }else{
      t.pass("Tarball was fetched")
    }
    t.end()
  })
})

test("url-dependencies: do not download subsequent times", function(t) {
  cleanup()

  performInstall(function(){
    performInstall(function(output){
      if(tarballWasFetched(output)){
        t.fail("Tarball was fetched second time around")
      }else{
        t.pass("Tarball was not fetched")
      }
      t.end()
    })
  })
})

function tarballWasFetched(output){
  return output.indexOf("http GET " + common.registry + "/underscore/-/underscore-1.3.1.tgz") > -1
}

function performInstall (cb) {
  mr({port: common.port, mocks: mockRoutes}, function(s){
    var output = ""
      , child = spawn(node, [npm, "install"], {
          cwd: pkg,
          env: {
            npm_config_registry: common.registry,
            npm_config_cache_lock_stale: 1000,
            npm_config_cache_lock_wait: 1000,
            npm_config_loglevel: "http",
            HOME: process.env.HOME,
            Path: process.env.PATH,
            PATH: process.env.PATH
          }
        })

    child.stderr.on("data", function(data){
      output += data.toString()
    })
    child.on("close", function () {
      s.close()
      cb(output)
    })
  })
}

function cleanup() {
  // windows fix for locked files
  process.chdir(osenv.tmpdir())
  rimraf.sync(path.resolve(pkg, "node_modules"))
}
=======
var test = require("tap").test
var rimraf = require("rimraf")
var path = require("path")
var osenv = require("osenv")
var mr = require("npm-registry-mock")
var spawn = require("child_process").spawn
var npm = require.resolve("../../bin/npm-cli.js")
var node = process.execPath
var pkg = path.resolve(__dirname, "url-dependencies")
var common = require('../common-tap')

var mockRoutes = {
  "get": {
    "/underscore/-/underscore-1.3.1.tgz": [200]
  }
}

test("url-dependencies: download first time", function(t) {
  cleanup()

  performInstall(function(output){
    if(!tarballWasFetched(output)){
      t.fail("Tarball was not fetched")
    }else{
      t.pass("Tarball was fetched")
    }
    t.end()
  })
})

test("url-dependencies: do not download subsequent times", function(t) {
  cleanup()

  performInstall(function(){
    performInstall(function(output){
      if(tarballWasFetched(output)){
        t.fail("Tarball was fetched second time around")
      }else{
        t.pass("Tarball was not fetched")
      }
      t.end()
    })
  })
})

function tarballWasFetched(output){
  return output.indexOf("http GET " + common.registry + "/underscore/-/underscore-1.3.1.tgz") > -1
}

function performInstall (cb) {
  mr({port: common.port, mocks: mockRoutes}, function(s){
    var output = ""
      , child = spawn(node, [npm, "install"], {
          cwd: pkg,
          env: {
            npm_config_registry: common.registry,
            npm_config_cache_lock_stale: 1000,
            npm_config_cache_lock_wait: 1000,
            npm_config_loglevel: "http",
            HOME: process.env.HOME,
            Path: process.env.PATH,
            PATH: process.env.PATH
          }
        })

    child.stderr.on("data", function(data){
      output += data.toString()
    })
    child.on("close", function () {
      s.close()
      cb(output)
    })
  })
}

function cleanup() {
  // windows fix for locked files
  process.chdir(osenv.tmpdir())
  rimraf.sync(path.resolve(pkg, "node_modules"))
}
>>>>>>> b875702c9c06ab5012e52ff4337439b03918f453
=======
var test = require("tap").test
var rimraf = require("rimraf")
var path = require("path")
var osenv = require("osenv")
var mr = require("npm-registry-mock")
var spawn = require("child_process").spawn
var npm = require.resolve("../../bin/npm-cli.js")
var node = process.execPath
var pkg = path.resolve(__dirname, "url-dependencies")
var common = require('../common-tap')

var mockRoutes = {
  "get": {
    "/underscore/-/underscore-1.3.1.tgz": [200]
  }
}

test("url-dependencies: download first time", function(t) {
  cleanup()

  performInstall(function(output){
    if(!tarballWasFetched(output)){
      t.fail("Tarball was not fetched")
    }else{
      t.pass("Tarball was fetched")
    }
    t.end()
  })
})

test("url-dependencies: do not download subsequent times", function(t) {
  cleanup()

  performInstall(function(){
    performInstall(function(output){
      if(tarballWasFetched(output)){
        t.fail("Tarball was fetched second time around")
      }else{
        t.pass("Tarball was not fetched")
      }
      t.end()
    })
  })
})

function tarballWasFetched(output){
  return output.indexOf("http GET " + common.registry + "/underscore/-/underscore-1.3.1.tgz") > -1
}

function performInstall (cb) {
  mr({port: common.port, mocks: mockRoutes}, function(s){
    var output = ""
      , child = spawn(node, [npm, "install"], {
          cwd: pkg,
          env: {
            npm_config_registry: common.registry,
            npm_config_cache_lock_stale: 1000,
            npm_config_cache_lock_wait: 1000,
            npm_config_loglevel: "http",
            HOME: process.env.HOME,
            Path: process.env.PATH,
            PATH: process.env.PATH
          }
        })

    child.stderr.on("data", function(data){
      output += data.toString()
    })
    child.on("close", function () {
      s.close()
      cb(output)
    })
  })
}

function cleanup() {
  // windows fix for locked files
  process.chdir(osenv.tmpdir())
  rimraf.sync(path.resolve(pkg, "node_modules"))
}
>>>>>>> b875702c9c06ab5012e52ff4337439b03918f453


text:
zidecohome-web
==============

A webapp for controlling finances and health... and a learning ground for angular-js and other cool web techs


text:
<?php

namespace App;

use App\Scopes\RecentlySyncedScope;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;

class Connector extends Model
{
    /**
     * Mass assignable properties.
     *
     * @var array
     */
    protected $fillable = [
        'typeid',
        'power',
        'status',
        'position',
        'quantity',
        'synced_at'
    ];

    /**
     * Properties to mutate to Carbon instances.
     *
     * @var array
     */
    protected $dates = [
        'synced_at',
    ];

    /**
     * The charger this connector belongs to.
     *
     * @return \Illuminate\Database\Eloquent\Builder | \Illuminate\Database\Eloquent\Relations\BelongsTo | Charger
     */
    public function charger()
    {
        return $this->belongsTo('App\Charger');
    }

    /**
     * This connector's history.
     *
     * @return \Illuminate\Database\Eloquent\Builder | \Illuminate\Database\Eloquent\Relations\MorphMany | History
     */
    public function history()
    {
        return $this->morphMany('App\History','trackable');
    }

    /**
     * The type of this connector.
     *
     * @return \Illuminate\Database\Eloquent\Builder | \Illuminate\Database\Eloquent\Relations\BelongsToMany | Type
     */
    public function type()
    {
        return $this->belongsToMany('App\Type');
    }

    /**
     * Scope the query for online connectors only.
     *
     * @param $builder
     * @return mixed
     */
    public function scopeOnline($builder)
    {
        return $builder->where('status','online');
    }

    /**
     * Scope the query for online connectors only including occupied.
     *
     * @return mixed
     */
    public function scopeOnlineOrOccupied($builder)
    {
        return $builder->where('status','online')->orWhere('status','occupied');
    }

    /**
     * Scope the query for offline connectors only.
     *
     * @param $builder
     * @return mixed
     */
    public function scopeOffline($builder)
    {
        return $builder->where('status','offline');
    }

    /**
     * Scope the query for occupied connectors only.
     *
     * @param $builder
     * @return mixed
     */
    public function scopeOccupied($builder)
    {
        return $builder->where('status','occupied');
    }

    /**
     * Scope the query for planned connectors only.
     *
     * @param $builder
     * @return mixed
     */
    public function scopePlanned($builder)
    {
        return $builder->where('status','planned');
    }

    /**
     * Scope the query for unknown connectors only.
     *
     * @param $builder
     * @return mixed
     */
    public function scopeUnknown($builder)
    {
        return $builder->where('status','unknown');
    }

    /**
     * Only include connectors that don't have another connector in
     * use on the same charger.
     *
     * @param $query
     */
    public function scopeDoesntHaveConnectorInUse($query)
    {
        $query->whereNotExists( function($query) {
            $query
                ->select('*')
                ->from('connectors')
                ->whereRaw('connectors.charger_id = chargers.id')
                ->whereStatus('occupied');
        });
    }

    /**
     * Scope for recently synced connectors.
     *
     * @param $builder
     * @return mixed
     */
    public function scopeRecentlySynced($builder)
    {
        return $builder->where('connectors.synced_at','>',Carbon::now()->subDay(1));
    }
}


text:
module Google
  module Cloud
    module RecommendationEngine
      module V1beta1
        # Request message for Predict method.
        # @!attribute [rw] name
        #   @return [::String]
        #     Required. Full resource name of the format:
        #     `{name=projects/*/locations/global/catalogs/default_catalog/eventStores/default_event_store/placements/*}`
        #     The id of the recommendation engine placement. This id is used to identify
        #     the set of models that will be used to make the prediction.
        #
        #     We currently support three placements with the following IDs by default:
        #
        #     * `shopping_cart`: Predicts items frequently bought together with one or
        #       more catalog items in the same shopping session. Commonly displayed after
        #       `add-to-cart` events, on product detail pages, or on the shopping cart
        #       page.
        #
        #     * `home_page`: Predicts the next product that a user will most likely
        #       engage with or purchase based on the shopping or viewing history of the
        #       specified `userId` or `visitorId`. For example - Recommendations for you.
        #
        #     * `product_detail`: Predicts the next product that a user will most likely
        #       engage with or purchase. The prediction is based on the shopping or
        #       viewing history of the specified `userId` or `visitorId` and its
        #       relevance to a specified `CatalogItem`. Typically used on product detail
        #       pages. For example - More items like this.
        #
        #     * `recently_viewed_default`: Returns up to 75 items recently viewed by the
        #       specified `userId` or `visitorId`, most recent ones first. Returns
        #       nothing if neither of them has viewed any items yet. For example -
        #       Recently viewed.
        #
        #     The full list of available placements can be seen at
        #     https://console.cloud.google.com/recommendation/datafeeds/default_catalog/dashboard
        # @!attribute [rw] user_event
        #   @return [::Google::Cloud::RecommendationEngine::V1beta1::UserEvent]
        #     Required. Context about the user, what they are looking at and what action
        #     they took to trigger the predict request. Note that this user event detail
        #     won't be ingested to userEvent logs. Thus, a separate userEvent write
        #     request is required for event logging.
        # @!attribute [rw] page_size
        #   @return [::Integer]
        #     Optional. Maximum number of results to return per page. Set this property
        #     to the number of prediction results required. If zero, the service will
        #     choose a reasonable default.
        # @!attribute [rw] page_token
        #   @return [::String]
        #     Optional. The previous PredictResponse.next_page_token.
        # @!attribute [rw] filter
        #   @return [::String]
        #     Optional. Filter for restricting prediction results. Accepts values for
        #     tags and the `filterOutOfStockItems` flag.
        #
        #      * Tag expressions. Restricts predictions to items that match all of the
        #        specified tags. Boolean operators `OR` and `NOT` are supported if the
        #        expression is enclosed in parentheses, and must be separated from the
        #        tag values by a space. `-"tagA"` is also supported and is equivalent to
        #        `NOT "tagA"`. Tag values must be double quoted UTF-8 encoded strings
        #        with a size limit of 1 KiB.
        #
        #      * filterOutOfStockItems. Restricts predictions to items that do not have a
        #        stockState value of OUT_OF_STOCK.
        #
        #     Examples:
        #
        #      * tag=("Red" OR "Blue") tag="New-Arrival" tag=(NOT "promotional")
        #      * filterOutOfStockItems  tag=(-"promotional")
        #      * filterOutOfStockItems
        # @!attribute [rw] dry_run
        #   @return [::Boolean]
        #     Optional. Use dryRun mode for this prediction query. If set to true, a
        #     dummy model will be used that returns arbitrary catalog items.
        #     Note that the dryRun mode should only be used for testing the API, or if
        #     the model is not ready.
        # @!attribute [rw] params
        #   @return [::Google::Protobuf::Map{::String => ::Google::Protobuf::Value}]
        #     Optional. Additional domain specific parameters for the predictions.
        #
        #     Allowed values:
        #
        #     * `returnCatalogItem`: Boolean. If set to true, the associated catalogItem
        #        object will be returned in the
        #       `PredictResponse.PredictionResult.itemMetadata` object in the method
        #        response.
        #     * `returnItemScore`: Boolean. If set to true, the prediction 'score'
        #        corresponding to each returned item will be set in the `metadata`
        #        field in the prediction response. The given 'score' indicates the
        #        probability of an item being clicked/purchased given the user's context
        #        and history.
        # @!attribute [rw] labels
        #   @return [::Google::Protobuf::Map{::String => ::String}]
        #     Optional. The labels for the predict request.
        #
        #      * Label keys can contain lowercase letters, digits and hyphens, must start
        #        with a letter, and must end with a letter or digit.
        #      * Non-zero label values can contain lowercase letters, digits and hyphens,
        #        must start with a letter, and must end with a letter or digit.
        #      * No more than 64 labels can be associated with a given request.
        #
        #     See https://goo.gl/xmQnxf for more information on and examples of labels.
        class PredictRequest
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods

          # @!attribute [rw] key
          #   @return [::String]
          # @!attribute [rw] value
          #   @return [::Google::Protobuf::Value]
          class ParamsEntry
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end

          # @!attribute [rw] key
          #   @return [::String]
          # @!attribute [rw] value
          #   @return [::String]
          class LabelsEntry
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end
        end

        # Response message for predict method.
        # @!attribute [rw] results
        #   @return [::Array<::Google::Cloud::RecommendationEngine::V1beta1::PredictResponse::PredictionResult>]
        #     A list of recommended items. The order represents the ranking (from the
        #     most relevant item to the least).
        # @!attribute [rw] recommendation_token
        #   @return [::String]
        #     A unique recommendation token. This should be included in the user event
        #     logs resulting from this recommendation, which enables accurate attribution
        #     of recommendation model performance.
        # @!attribute [rw] items_missing_in_catalog
        #   @return [::Array<::String>]
        #     IDs of items in the request that were missing from the catalog.
        # @!attribute [rw] dry_run
        #   @return [::Boolean]
        #     True if the dryRun property was set in the request.
        # @!attribute [rw] metadata
        #   @return [::Google::Protobuf::Map{::String => ::Google::Protobuf::Value}]
        #     Additional domain specific prediction response metadata.
        # @!attribute [rw] next_page_token
        #   @return [::String]
        #     If empty, the list is complete. If nonempty, the token to pass to the next
        #     request's PredictRequest.page_token.
        class PredictResponse
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods

          # PredictionResult represents the recommendation prediction results.
          # @!attribute [rw] id
          #   @return [::String]
          #     ID of the recommended catalog item
          # @!attribute [rw] item_metadata
          #   @return [::Google::Protobuf::Map{::String => ::Google::Protobuf::Value}]
          #     Additional item metadata / annotations.
          #
          #     Possible values:
          #
          #     * `catalogItem`: JSON representation of the catalogItem. Will be set if
          #       `returnCatalogItem` is set to true in `PredictRequest.params`.
          #     * `score`: Prediction score in double value. Will be set if
          #       `returnItemScore` is set to true in `PredictRequest.params`.
          class PredictionResult
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # @!attribute [rw] key
            #   @return [::String]
            # @!attribute [rw] value
            #   @return [::Google::Protobuf::Value]
            class ItemMetadataEntry
              include ::Google::Protobuf::MessageExts
              extend ::Google::Protobuf::MessageExts::ClassMethods
            end
          end

          # @!attribute [rw] key
          #   @return [::String]
          # @!attribute [rw] value
          #   @return [::Google::Protobuf::Value]
          class MetadataEntry
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end
        end
      end
    end
  end
end


text:
#include "builtin.h"

#include "perf.h"
#include "util/cache.h"
#include "util/debug.h"
#include "util/exec_cmd.h"
#include "util/header.h"
#include "util/parse-options.h"
#include "util/session.h"
#include "util/tool.h"
#include "util/symbol.h"
#include "util/thread.h"
#include "util/trace-event.h"
#include "util/util.h"
#include "util/evlist.h"
#include "util/evsel.h"
#include "util/sort.h"
#include <linux/bitmap.h>

static char const		*script_name;
static char const		*generate_script_lang;
static bool			debug_mode;
static u64			last_timestamp;
static u64			nr_unordered;
extern const struct option	record_options[];
static bool			no_callchain;
static bool			system_wide;
static const char		*cpu_list;
static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);

enum perf_output_field {
	PERF_OUTPUT_COMM            = 1U << 0,
	PERF_OUTPUT_TID             = 1U << 1,
	PERF_OUTPUT_PID             = 1U << 2,
	PERF_OUTPUT_TIME            = 1U << 3,
	PERF_OUTPUT_CPU             = 1U << 4,
	PERF_OUTPUT_EVNAME          = 1U << 5,
	PERF_OUTPUT_TRACE           = 1U << 6,
	PERF_OUTPUT_IP              = 1U << 7,
	PERF_OUTPUT_SYM             = 1U << 8,
	PERF_OUTPUT_DSO             = 1U << 9,
	PERF_OUTPUT_ADDR            = 1U << 10,
	PERF_OUTPUT_SYMOFFSET       = 1U << 11,
};

struct output_option {
	const char *str;
	enum perf_output_field field;
} all_output_options[] = {
	{.str = "comm",  .field = PERF_OUTPUT_COMM},
	{.str = "tid",   .field = PERF_OUTPUT_TID},
	{.str = "pid",   .field = PERF_OUTPUT_PID},
	{.str = "time",  .field = PERF_OUTPUT_TIME},
	{.str = "cpu",   .field = PERF_OUTPUT_CPU},
	{.str = "event", .field = PERF_OUTPUT_EVNAME},
	{.str = "trace", .field = PERF_OUTPUT_TRACE},
	{.str = "ip",    .field = PERF_OUTPUT_IP},
	{.str = "sym",   .field = PERF_OUTPUT_SYM},
	{.str = "dso",   .field = PERF_OUTPUT_DSO},
	{.str = "addr",  .field = PERF_OUTPUT_ADDR},
	{.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
};

/* default set to maintain compatibility with current format */
static struct {
	bool user_set;
	bool wildcard_set;
	u64 fields;
	u64 invalid_fields;
} output[PERF_TYPE_MAX] = {

	[PERF_TYPE_HARDWARE] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
				  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,

		.invalid_fields = PERF_OUTPUT_TRACE,
	},

	[PERF_TYPE_SOFTWARE] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
				  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,

		.invalid_fields = PERF_OUTPUT_TRACE,
	},

	[PERF_TYPE_TRACEPOINT] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
				  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
				  PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE,
	},

	[PERF_TYPE_RAW] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
				  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,

		.invalid_fields = PERF_OUTPUT_TRACE,
	},
};

static bool output_set_by_user(void)
{
	int j;
	for (j = 0; j < PERF_TYPE_MAX; ++j) {
		if (output[j].user_set)
			return true;
	}
	return false;
}

static const char *output_field2str(enum perf_output_field field)
{
	int i, imax = ARRAY_SIZE(all_output_options);
	const char *str = "";

	for (i = 0; i < imax; ++i) {
		if (all_output_options[i].field == field) {
			str = all_output_options[i].str;
			break;
		}
	}
	return str;
}

#define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)

static int perf_evsel__check_stype(struct perf_evsel *evsel,
				   u64 sample_type, const char *sample_msg,
				   enum perf_output_field field)
{
	struct perf_event_attr *attr = &evsel->attr;
	int type = attr->type;
	const char *evname;

	if (attr->sample_type & sample_type)
		return 0;

	if (output[type].user_set) {
		evname = perf_evsel__name(evsel);
		pr_err("Samples for '%s' event do not have %s attribute set. "
		       "Cannot print '%s' field.\n",
		       evname, sample_msg, output_field2str(field));
		return -1;
	}

	/* user did not ask for it explicitly so remove from the default list */
	output[type].fields &= ~field;
	evname = perf_evsel__name(evsel);
	pr_debug("Samples for '%s' event do not have %s attribute set. "
		 "Skipping '%s' field.\n",
		 evname, sample_msg, output_field2str(field));

	return 0;
}

static int perf_evsel__check_attr(struct perf_evsel *evsel,
				  struct perf_session *session)
{
	struct perf_event_attr *attr = &evsel->attr;

	if (PRINT_FIELD(TRACE) &&
		!perf_session__has_traces(session, "record -R"))
		return -EINVAL;

	if (PRINT_FIELD(IP)) {
		if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP",
					    PERF_OUTPUT_IP))
			return -EINVAL;

		if (!no_callchain &&
		    !(attr->sample_type & PERF_SAMPLE_CALLCHAIN))
			symbol_conf.use_callchain = false;
	}

	if (PRINT_FIELD(ADDR) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR",
					PERF_OUTPUT_ADDR))
		return -EINVAL;

	if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
		pr_err("Display of symbols requested but neither sample IP nor "
			   "sample address\nis selected. Hence, no addresses to convert "
		       "to symbols.\n");
		return -EINVAL;
	}
	if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
		pr_err("Display of offsets requested but symbol is not"
		       "selected.\n");
		return -EINVAL;
	}
	if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
		pr_err("Display of DSO requested but neither sample IP nor "
			   "sample address\nis selected. Hence, no addresses to convert "
		       "to DSO.\n");
		return -EINVAL;
	}

	if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID",
					PERF_OUTPUT_TID|PERF_OUTPUT_PID))
		return -EINVAL;

	if (PRINT_FIELD(TIME) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME",
					PERF_OUTPUT_TIME))
		return -EINVAL;

	if (PRINT_FIELD(CPU) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_CPU, "CPU",
					PERF_OUTPUT_CPU))
		return -EINVAL;

	return 0;
}

/*
 * verify all user requested events exist and the samples
 * have the expected data
 */
static int perf_session__check_output_opt(struct perf_session *session)
{
	int j;
	struct perf_evsel *evsel;

	for (j = 0; j < PERF_TYPE_MAX; ++j) {
		evsel = perf_session__find_first_evtype(session, j);

		/*
		 * even if fields is set to 0 (ie., show nothing) event must
		 * exist if user explicitly includes it on the command line
		 */
		if (!evsel && output[j].user_set && !output[j].wildcard_set) {
			pr_err("%s events do not exist. "
			       "Remove corresponding -f option to proceed.\n",
			       event_type(j));
			return -1;
		}

		if (evsel && output[j].fields &&
			perf_evsel__check_attr(evsel, session))
			return -1;
	}

	return 0;
}

static void print_sample_start(struct perf_sample *sample,
			       struct thread *thread,
			       struct perf_evsel *evsel)
{
	struct perf_event_attr *attr = &evsel->attr;
	const char *evname = NULL;
	unsigned long secs;
	unsigned long usecs;
	unsigned long long nsecs;

	if (PRINT_FIELD(COMM)) {
		if (latency_format)
			printf("%8.8s ", thread->comm);
		else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
			printf("%s ", thread->comm);
		else
			printf("%16s ", thread->comm);
	}

	if (PRINT_FIELD(PID) && PRINT_FIELD(TID))
		printf("%5d/%-5d ", sample->pid, sample->tid);
	else if (PRINT_FIELD(PID))
		printf("%5d ", sample->pid);
	else if (PRINT_FIELD(TID))
		printf("%5d ", sample->tid);

	if (PRINT_FIELD(CPU)) {
		if (latency_format)
			printf("%3d ", sample->cpu);
		else
			printf("[%03d] ", sample->cpu);
	}

	if (PRINT_FIELD(TIME)) {
		nsecs = sample->time;
		secs = nsecs / NSECS_PER_SEC;
		nsecs -= secs * NSECS_PER_SEC;
		usecs = nsecs / NSECS_PER_USEC;
		printf("%5lu.%06lu: ", secs, usecs);
	}

	if (PRINT_FIELD(EVNAME)) {
		evname = perf_evsel__name(evsel);
		printf("%s: ", evname ? evname : "[unknown]");
	}
}

static bool is_bts_event(struct perf_event_attr *attr)
{
	return ((attr->type == PERF_TYPE_HARDWARE) &&
		(attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) &&
		(attr->sample_period == 1));
}

static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
{
	if ((attr->type == PERF_TYPE_SOFTWARE) &&
	    ((attr->config == PERF_COUNT_SW_PAGE_FAULTS) ||
	     (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN) ||
	     (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
		return true;

	if (is_bts_event(attr))
		return true;

	return false;
}

static void print_sample_addr(union perf_event *event,
			  struct perf_sample *sample,
			  struct machine *machine,
			  struct thread *thread,
			  struct perf_event_attr *attr)
{
	struct addr_location al;
	u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;

	printf("%16" PRIx64, sample->addr);

	if (!sample_addr_correlates_sym(attr))
		return;

	thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
			      sample->addr, &al);
	if (!al.map)
		thread__find_addr_map(thread, machine, cpumode, MAP__VARIABLE,
				      sample->addr, &al);

	al.cpu = sample->cpu;
	al.sym = NULL;

	if (al.map)
		al.sym = map__find_symbol(al.map, al.addr, NULL);

	if (PRINT_FIELD(SYM)) {
		printf(" ");
		if (PRINT_FIELD(SYMOFFSET))
			symbol__fprintf_symname_offs(al.sym, &al, stdout);
		else
			symbol__fprintf_symname(al.sym, stdout);
	}

	if (PRINT_FIELD(DSO)) {
		printf(" (");
		map__fprintf_dsoname(al.map, stdout);
		printf(")");
	}
}

static void print_sample_bts(union perf_event *event,
			     struct perf_sample *sample,
			     struct perf_evsel *evsel,
			     struct machine *machine,
			     struct thread *thread)
{
	struct perf_event_attr *attr = &evsel->attr;

	/* print branch_from information */
	if (PRINT_FIELD(IP)) {
		if (!symbol_conf.use_callchain)
			printf(" ");
		else
			printf("\n");
		perf_evsel__print_ip(evsel, event, sample, machine,
				     PRINT_FIELD(SYM), PRINT_FIELD(DSO),
				     PRINT_FIELD(SYMOFFSET));
	}

	printf(" => ");

	/* print branch_to information */
	if (PRINT_FIELD(ADDR))
		print_sample_addr(event, sample, machine, thread, attr);

	printf("\n");
}

static void process_event(union perf_event *event, struct perf_sample *sample,
			  struct perf_evsel *evsel, struct machine *machine,
			  struct addr_location *al)
{
	struct perf_event_attr *attr = &evsel->attr;
	struct thread *thread = al->thread;

	if (output[attr->type].fields == 0)
		return;

	print_sample_start(sample, thread, evsel);

	if (is_bts_event(attr)) {
		print_sample_bts(event, sample, evsel, machine, thread);
		return;
	}

	if (PRINT_FIELD(TRACE))
		event_format__print(evsel->tp_format, sample->cpu,
				    sample->raw_data, sample->raw_size);
	if (PRINT_FIELD(ADDR))
		print_sample_addr(event, sample, machine, thread, attr);

	if (PRINT_FIELD(IP)) {
		if (!symbol_conf.use_callchain)
			printf(" ");
		else
			printf("\n");
		perf_evsel__print_ip(evsel, event, sample, machine,
				     PRINT_FIELD(SYM), PRINT_FIELD(DSO),
				     PRINT_FIELD(SYMOFFSET));
	}

	printf("\n");
}

static int default_start_script(const char *script __maybe_unused,
				int argc __maybe_unused,
				const char **argv __maybe_unused)
{
	return 0;
}

static int default_stop_script(void)
{
	return 0;
}

static int default_generate_script(struct pevent *pevent __maybe_unused,
				   const char *outfile __maybe_unused)
{
	return 0;
}

static struct scripting_ops default_scripting_ops = {
	.start_script		= default_start_script,
	.stop_script		= default_stop_script,
	.process_event		= process_event,
	.generate_script	= default_generate_script,
};

static struct scripting_ops	*scripting_ops;

static void setup_scripting(void)
{
	setup_perl_scripting();
	setup_python_scripting();

	scripting_ops = &default_scripting_ops;
}

static int cleanup_scripting(void)
{
	pr_debug("\nperf script stopped\n");

	return scripting_ops->stop_script();
}

static int process_sample_event(struct perf_tool *tool __maybe_unused,
				union perf_event *event,
				struct perf_sample *sample,
				struct perf_evsel *evsel,
				struct machine *machine)
{
	struct addr_location al;
	struct thread *thread = machine__findnew_thread(machine, event->ip.tid);

	if (thread == NULL) {
		pr_debug("problem processing %d event, skipping it.\n",
			 event->header.type);
		return -1;
	}

	if (debug_mode) {
		if (sample->time < last_timestamp) {
			pr_err("Samples misordered, previous: %" PRIu64
				" this: %" PRIu64 "\n", last_timestamp,
				sample->time);
			nr_unordered++;
		}
		last_timestamp = sample->time;
		return 0;
	}

	if (perf_event__preprocess_sample(event, machine, &al, sample, 0) < 0) {
		pr_err("problem processing %d event, skipping it.\n",
		       event->header.type);
		return -1;
	}

	if (al.filtered)
		return 0;

	if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
		return 0;

	scripting_ops->process_event(event, sample, evsel, machine, &al);

	evsel->hists.stats.total_period += sample->period;
	return 0;
}

static struct perf_tool perf_script = {
	.sample		 = process_sample_event,
	.mmap		 = perf_event__process_mmap,
	.comm		 = perf_event__process_comm,
	.exit		 = perf_event__process_exit,
	.fork		 = perf_event__process_fork,
	.attr		 = perf_event__process_attr,
	.event_type	 = perf_event__process_event_type,
	.tracing_data	 = perf_event__process_tracing_data,
	.build_id	 = perf_event__process_build_id,
	.ordered_samples = true,
	.ordering_requires_timestamps = true,
};

extern volatile int session_done;

static void sig_handler(int sig __maybe_unused)
{
	session_done = 1;
}

static int __cmd_script(struct perf_session *session)
{
	int ret;

	signal(SIGINT, sig_handler);

	ret = perf_session__process_events(session, &perf_script);

	if (debug_mode)
		pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);

	return ret;
}

struct script_spec {
	struct list_head	node;
	struct scripting_ops	*ops;
	char			spec[0];
};

static LIST_HEAD(script_specs);

static struct script_spec *script_spec__new(const char *spec,
					    struct scripting_ops *ops)
{
	struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);

	if (s != NULL) {
		strcpy(s->spec, spec);
		s->ops = ops;
	}

	return s;
}

static void script_spec__add(struct script_spec *s)
{
	list_add_tail(&s->node, &script_specs);
}

static struct script_spec *script_spec__find(const char *spec)
{
	struct script_spec *s;

	list_for_each_entry(s, &script_specs, node)
		if (strcasecmp(s->spec, spec) == 0)
			return s;
	return NULL;
}

static struct script_spec *script_spec__findnew(const char *spec,
						struct scripting_ops *ops)
{
	struct script_spec *s = script_spec__find(spec);

	if (s)
		return s;

	s = script_spec__new(spec, ops);
	if (!s)
		return NULL;

	script_spec__add(s);

	return s;
}

int script_spec_register(const char *spec, struct scripting_ops *ops)
{
	struct script_spec *s;

	s = script_spec__find(spec);
	if (s)
		return -1;

	s = script_spec__findnew(spec, ops);
	if (!s)
		return -1;

	return 0;
}

static struct scripting_ops *script_spec__lookup(const char *spec)
{
	struct script_spec *s = script_spec__find(spec);
	if (!s)
		return NULL;

	return s->ops;
}

static void list_available_languages(void)
{
	struct script_spec *s;

	fprintf(stderr, "\n");
	fprintf(stderr, "Scripting language extensions (used in "
		"perf script -s [spec:]script.[spec]):\n\n");

	list_for_each_entry(s, &script_specs, node)
		fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);

	fprintf(stderr, "\n");
}

static int parse_scriptname(const struct option *opt __maybe_unused,
			    const char *str, int unset __maybe_unused)
{
	char spec[PATH_MAX];
	const char *script, *ext;
	int len;

	if (strcmp(str, "lang") == 0) {
		list_available_languages();
		exit(0);
	}

	script = strchr(str, ':');
	if (script) {
		len = script - str;
		if (len >= PATH_MAX) {
			fprintf(stderr, "invalid language specifier");
			return -1;
		}
		strncpy(spec, str, len);
		spec[len] = '\0';
		scripting_ops = script_spec__lookup(spec);
		if (!scripting_ops) {
			fprintf(stderr, "invalid language specifier");
			return -1;
		}
		script++;
	} else {
		script = str;
		ext = strrchr(script, '.');
		if (!ext) {
			fprintf(stderr, "invalid script extension");
			return -1;
		}
		scripting_ops = script_spec__lookup(++ext);
		if (!scripting_ops) {
			fprintf(stderr, "invalid script extension");
			return -1;
		}
	}

	script_name = strdup(script);

	return 0;
}

static int parse_output_fields(const struct option *opt __maybe_unused,
			    const char *arg, int unset __maybe_unused)
{
	char *tok;
	int i, imax = ARRAY_SIZE(all_output_options);
	int j;
	int rc = 0;
	char *str = strdup(arg);
	int type = -1;

	if (!str)
		return -ENOMEM;

	/* first word can state for which event type the user is specifying
	 * the fields. If no type exists, the specified fields apply to all
	 * event types found in the file minus the invalid fields for a type.
	 */
	tok = strchr(str, ':');
	if (tok) {
		*tok = '\0';
		tok++;
		if (!strcmp(str, "hw"))
			type = PERF_TYPE_HARDWARE;
		else if (!strcmp(str, "sw"))
			type = PERF_TYPE_SOFTWARE;
		else if (!strcmp(str, "trace"))
			type = PERF_TYPE_TRACEPOINT;
		else if (!strcmp(str, "raw"))
			type = PERF_TYPE_RAW;
		else {
			fprintf(stderr, "Invalid event type in field string.\n");
			rc = -EINVAL;
			goto out;
		}

		if (output[type].user_set)
			pr_warning("Overriding previous field request for %s events.\n",
				   event_type(type));

		output[type].fields = 0;
		output[type].user_set = true;
		output[type].wildcard_set = false;

	} else {
		tok = str;
		if (strlen(str) == 0) {
			fprintf(stderr,
				"Cannot set fields to 'none' for all event types.\n");
			rc = -EINVAL;
			goto out;
		}

		if (output_set_by_user())
			pr_warning("Overriding previous field request for all events.\n");

		for (j = 0; j < PERF_TYPE_MAX; ++j) {
			output[j].fields = 0;
			output[j].user_set = true;
			output[j].wildcard_set = true;
		}
	}

	tok = strtok(tok, ",");
	while (tok) {
		for (i = 0; i < imax; ++i) {
			if (strcmp(tok, all_output_options[i].str) == 0)
				break;
		}
		if (i == imax) {
			fprintf(stderr, "Invalid field requested.\n");
			rc = -EINVAL;
			goto out;
		}

		if (type == -1) {
			/* add user option to all events types for
			 * which it is valid
			 */
			for (j = 0; j < PERF_TYPE_MAX; ++j) {
				if (output[j].invalid_fields & all_output_options[i].field) {
					pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
						   all_output_options[i].str, event_type(j));
				} else
					output[j].fields |= all_output_options[i].field;
			}
		} else {
			if (output[type].invalid_fields & all_output_options[i].field) {
				fprintf(stderr, "\'%s\' not valid for %s events.\n",
					 all_output_options[i].str, event_type(type));

				rc = -EINVAL;
				goto out;
			}
			output[type].fields |= all_output_options[i].field;
		}

		tok = strtok(NULL, ",");
	}

	if (type >= 0) {
		if (output[type].fields == 0) {
			pr_debug("No fields requested for %s type. "
				 "Events will not be displayed.\n", event_type(type));
		}
	}

out:
	free(str);
	return rc;
}

/* Helper function for filesystems that return a dent->d_type DT_UNKNOWN */
static int is_directory(const char *base_path, const struct dirent *dent)
{
	char path[PATH_MAX];
	struct stat st;

	sprintf(path, "%s/%s", base_path, dent->d_name);
	if (stat(path, &st))
		return 0;

	return S_ISDIR(st.st_mode);
}

#define for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next)\
	while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) &&	\
	       lang_next)						\
		if ((lang_dirent.d_type == DT_DIR ||			\
		     (lang_dirent.d_type == DT_UNKNOWN &&		\
		      is_directory(scripts_path, &lang_dirent))) &&	\
		    (strcmp(lang_dirent.d_name, ".")) &&		\
		    (strcmp(lang_dirent.d_name, "..")))

#define for_each_script(lang_path, lang_dir, script_dirent, script_next)\
	while (!readdir_r(lang_dir, &script_dirent, &script_next) &&	\
	       script_next)						\
		if (script_dirent.d_type != DT_DIR &&			\
		    (script_dirent.d_type != DT_UNKNOWN ||		\
		     !is_directory(lang_path, &script_dirent)))

#define RECORD_SUFFIX			"-record"
#define REPORT_SUFFIX			"-report"

struct script_desc {
	struct list_head	node;
	char			*name;
	char			*half_liner;
	char			*args;
};

static LIST_HEAD(script_descs);

static struct script_desc *script_desc__new(const char *name)
{
	struct script_desc *s = zalloc(sizeof(*s));

	if (s != NULL && name)
		s->name = strdup(name);

	return s;
}

static void script_desc__delete(struct script_desc *s)
{
	free(s->name);
	free(s->half_liner);
	free(s->args);
	free(s);
}

static void script_desc__add(struct script_desc *s)
{
	list_add_tail(&s->node, &script_descs);
}

static struct script_desc *script_desc__find(const char *name)
{
	struct script_desc *s;

	list_for_each_entry(s, &script_descs, node)
		if (strcasecmp(s->name, name) == 0)
			return s;
	return NULL;
}

static struct script_desc *script_desc__findnew(const char *name)
{
	struct script_desc *s = script_desc__find(name);

	if (s)
		return s;

	s = script_desc__new(name);
	if (!s)
		goto out_delete_desc;

	script_desc__add(s);

	return s;

out_delete_desc:
	script_desc__delete(s);

	return NULL;
}

static const char *ends_with(const char *str, const char *suffix)
{
	size_t suffix_len = strlen(suffix);
	const char *p = str;

	if (strlen(str) > suffix_len) {
		p = str + strlen(str) - suffix_len;
		if (!strncmp(p, suffix, suffix_len))
			return p;
	}

	return NULL;
}

static int read_script_info(struct script_desc *desc, const char *filename)
{
	char line[BUFSIZ], *p;
	FILE *fp;

	fp = fopen(filename, "r");
	if (!fp)
		return -1;

	while (fgets(line, sizeof(line), fp)) {
		p = ltrim(line);
		if (strlen(p) == 0)
			continue;
		if (*p != '#')
			continue;
		p++;
		if (strlen(p) && *p == '!')
			continue;

		p = ltrim(p);
		if (strlen(p) && p[strlen(p) - 1] == '\n')
			p[strlen(p) - 1] = '\0';

		if (!strncmp(p, "description:", strlen("description:"))) {
			p += strlen("description:");
			desc->half_liner = strdup(ltrim(p));
			continue;
		}

		if (!strncmp(p, "args:", strlen("args:"))) {
			p += strlen("args:");
			desc->args = strdup(ltrim(p));
			continue;
		}
	}

	fclose(fp);

	return 0;
}

static char *get_script_root(struct dirent *script_dirent, const char *suffix)
{
	char *script_root, *str;

	script_root = strdup(script_dirent->d_name);
	if (!script_root)
		return NULL;

	str = (char *)ends_with(script_root, suffix);
	if (!str) {
		free(script_root);
		return NULL;
	}

	*str = '\0';
	return script_root;
}

static int list_available_scripts(const struct option *opt __maybe_unused,
				  const char *s __maybe_unused,
				  int unset __maybe_unused)
{
	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
	char scripts_path[MAXPATHLEN];
	DIR *scripts_dir, *lang_dir;
	char script_path[MAXPATHLEN];
	char lang_path[MAXPATHLEN];
	struct script_desc *desc;
	char first_half[BUFSIZ];
	char *script_root;

	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());

	scripts_dir = opendir(scripts_path);
	if (!scripts_dir)
		return -1;

	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
			 lang_dirent.d_name);
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
			script_root = get_script_root(&script_dirent, REPORT_SUFFIX);
			if (script_root) {
				desc = script_desc__findnew(script_root);
				snprintf(script_path, MAXPATHLEN, "%s/%s",
					 lang_path, script_dirent.d_name);
				read_script_info(desc, script_path);
				free(script_root);
			}
		}
	}

	fprintf(stdout, "List of available trace scripts:\n");
	list_for_each_entry(desc, &script_descs, node) {
		sprintf(first_half, "%s %s", desc->name,
			desc->args ? desc->args : "");
		fprintf(stdout, "  %-36s %s\n", first_half,
			desc->half_liner ? desc->half_liner : "");
	}

	exit(0);
}

/*
 * Some scripts specify the required events in their "xxx-record" file,
 * this function will check if the events in perf.data match those
 * mentioned in the "xxx-record".
 *
 * Fixme: All existing "xxx-record" are all in good formats "-e event ",
 * which is covered well now. And new parsing code should be added to
 * cover the future complexing formats like event groups etc.
 */
static int check_ev_match(char *dir_name, char *scriptname,
			struct perf_session *session)
{
	char filename[MAXPATHLEN], evname[128];
	char line[BUFSIZ], *p;
	struct perf_evsel *pos;
	int match, len;
	FILE *fp;

	sprintf(filename, "%s/bin/%s-record", dir_name, scriptname);

	fp = fopen(filename, "r");
	if (!fp)
		return -1;

	while (fgets(line, sizeof(line), fp)) {
		p = ltrim(line);
		if (*p == '#')
			continue;

		while (strlen(p)) {
			p = strstr(p, "-e");
			if (!p)
				break;

			p += 2;
			p = ltrim(p);
			len = strcspn(p, " \t");
			if (!len)
				break;

			snprintf(evname, len + 1, "%s", p);

			match = 0;
			list_for_each_entry(pos,
					&session->evlist->entries, node) {
				if (!strcmp(perf_evsel__name(pos), evname)) {
					match = 1;
					break;
				}
			}

			if (!match) {
				fclose(fp);
				return -1;
			}
		}
	}

	fclose(fp);
	return 0;
}

/*
 * Return -1 if none is found, otherwise the actual scripts number.
 *
 * Currently the only user of this function is the script browser, which
 * will list all statically runnable scripts, select one, execute it and
 * show the output in a perf browser.
 */
int find_scripts(char **scripts_array, char **scripts_path_array)
{
	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
	char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
	DIR *scripts_dir, *lang_dir;
	struct perf_session *session;
	char *temp;
	int i = 0;

	session = perf_session__new(input_name, O_RDONLY, 0, false, NULL);
	if (!session)
		return -1;

	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());

	scripts_dir = opendir(scripts_path);
	if (!scripts_dir) {
		perf_session__delete(session);
		return -1;
	}

	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
		snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
			 lang_dirent.d_name);
#ifdef NO_LIBPERL
		if (strstr(lang_path, "perl"))
			continue;
#endif
#ifdef NO_LIBPYTHON
		if (strstr(lang_path, "python"))
			continue;
#endif

		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
			/* Skip those real time scripts: xxxtop.p[yl] */
			if (strstr(script_dirent.d_name, "top."))
				continue;
			sprintf(scripts_path_array[i], "%s/%s", lang_path,
				script_dirent.d_name);
			temp = strchr(script_dirent.d_name, '.');
			snprintf(scripts_array[i],
				(temp - script_dirent.d_name) + 1,
				"%s", script_dirent.d_name);

			if (check_ev_match(lang_path,
					scripts_array[i], session))
				continue;

			i++;
		}
		closedir(lang_dir);
	}

	closedir(scripts_dir);
	perf_session__delete(session);
	return i;
}

static char *get_script_path(const char *script_root, const char *suffix)
{
	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
	char scripts_path[MAXPATHLEN];
	char script_path[MAXPATHLEN];
	DIR *scripts_dir, *lang_dir;
	char lang_path[MAXPATHLEN];
	char *__script_root;

	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());

	scripts_dir = opendir(scripts_path);
	if (!scripts_dir)
		return NULL;

	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
			 lang_dirent.d_name);
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
			__script_root = get_script_root(&script_dirent, suffix);
			if (__script_root && !strcmp(script_root, __script_root)) {
				free(__script_root);
				closedir(lang_dir);
				closedir(scripts_dir);
				snprintf(script_path, MAXPATHLEN, "%s/%s",
					 lang_path, script_dirent.d_name);
				return strdup(script_path);
			}
			free(__script_root);
		}
		closedir(lang_dir);
	}
	closedir(scripts_dir);

	return NULL;
}

static bool is_top_script(const char *script_path)
{
	return ends_with(script_path, "top") == NULL ? false : true;
}

static int has_required_arg(char *script_path)
{
	struct script_desc *desc;
	int n_args = 0;
	char *p;

	desc = script_desc__new(NULL);

	if (read_script_info(desc, script_path))
		goto out;

	if (!desc->args)
		goto out;

	for (p = desc->args; *p; p++)
		if (*p == '<')
			n_args++;
out:
	script_desc__delete(desc);

	return n_args;
}

static int have_cmd(int argc, const char **argv)
{
	char **__argv = malloc(sizeof(const char *) * argc);

	if (!__argv) {
		pr_err("malloc failed\n");
		return -1;
	}

	memcpy(__argv, argv, sizeof(const char *) * argc);
	argc = parse_options(argc, (const char **)__argv, record_options,
			     NULL, PARSE_OPT_STOP_AT_NON_OPTION);
	free(__argv);

	system_wide = (argc == 0);

	return 0;
}

int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
{
	bool show_full_info = false;
	char *rec_script_path = NULL;
	char *rep_script_path = NULL;
	struct perf_session *session;
	char *script_path = NULL;
	const char **__argv;
	int i, j, err;
	const struct option options[] = {
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
	OPT_INCR('v', "verbose", &verbose,
		 "be more verbose (show symbol address, etc)"),
	OPT_BOOLEAN('L', "Latency", &latency_format,
		    "show latency attributes (irqs/preemption disabled, etc)"),
	OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
			   list_available_scripts),
	OPT_CALLBACK('s', "script", NULL, "name",
		     "script file name (lang:script name, script name, or *)",
		     parse_scriptname),
	OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
		   "generate perf-script.xx script in specified language"),
	OPT_STRING('i', "input", &input_name, "file", "input file name"),
	OPT_BOOLEAN('d', "debug-mode", &debug_mode,
		   "do various checks like samples ordering and lost events"),
	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
		   "file", "kallsyms pathname"),
	OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
		    "When printing symbols do not display call chain"),
	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
		    "Look for files with symbols relative to this directory"),
	OPT_CALLBACK('f', "fields", NULL, "str",
		     "comma separated output fields prepend with 'type:'. "
		     "Valid types: hw,sw,trace,raw. "
		     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
		     "addr,symoff", parse_output_fields),
	OPT_BOOLEAN('a', "all-cpus", &system_wide,
		    "system-wide collection from all CPUs"),
	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
		   "only consider these symbols"),
	OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
	OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
		   "only display events for these comms"),
	OPT_BOOLEAN('I', "show-info", &show_full_info,
		    "display extended information from perf.data file"),
	OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
		    "Show the path of [kernel.kallsyms]"),
	OPT_END()
	};
	const char * const script_usage[] = {
		"perf script [<options>]",
		"perf script [<options>] record <script> [<record-options>] <command>",
		"perf script [<options>] report <script> [script-args]",
		"perf script [<options>] <script> [<record-options>] <command>",
		"perf script [<options>] <top-script> [script-args]",
		NULL
	};

	setup_scripting();

	argc = parse_options(argc, argv, options, script_usage,
			     PARSE_OPT_STOP_AT_NON_OPTION);

	if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
		rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
		if (!rec_script_path)
			return cmd_record(argc, argv, NULL);
	}

	if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
		rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
		if (!rep_script_path) {
			fprintf(stderr,
				"Please specify a valid report script"
				"(see 'perf script -l' for listing)\n");
			return -1;
		}
	}

	/* make sure PERF_EXEC_PATH is set for scripts */
	perf_set_argv_exec_path(perf_exec_path());

	if (argc && !script_name && !rec_script_path && !rep_script_path) {
		int live_pipe[2];
		int rep_args;
		pid_t pid;

		rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
		rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);

		if (!rec_script_path && !rep_script_path) {
			fprintf(stderr, " Couldn't find script %s\n\n See perf"
				" script -l for available scripts.\n", argv[0]);
			usage_with_options(script_usage, options);
		}

		if (is_top_script(argv[0])) {
			rep_args = argc - 1;
		} else {
			int rec_args;

			rep_args = has_required_arg(rep_script_path);
			rec_args = (argc - 1) - rep_args;
			if (rec_args < 0) {
				fprintf(stderr, " %s script requires options."
					"\n\n See perf script -l for available "
					"scripts and options.\n", argv[0]);
				usage_with_options(script_usage, options);
			}
		}

		if (pipe(live_pipe) < 0) {
			perror("failed to create pipe");
			return -1;
		}

		pid = fork();
		if (pid < 0) {
			perror("failed to fork");
			return -1;
		}

		if (!pid) {
			j = 0;

			dup2(live_pipe[1], 1);
			close(live_pipe[0]);

			if (is_top_script(argv[0])) {
				system_wide = true;
			} else if (!system_wide) {
				if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
					err = -1;
					goto out;
				}
			}

			__argv = malloc((argc + 6) * sizeof(const char *));
			if (!__argv) {
				pr_err("malloc failed\n");
				err = -ENOMEM;
				goto out;
			}

			__argv[j++] = "/bin/sh";
			__argv[j++] = rec_script_path;
			if (system_wide)
				__argv[j++] = "-a";
			__argv[j++] = "-q";
			__argv[j++] = "-o";
			__argv[j++] = "-";
			for (i = rep_args + 1; i < argc; i++)
				__argv[j++] = argv[i];
			__argv[j++] = NULL;

			execvp("/bin/sh", (char **)__argv);
			free(__argv);
			exit(-1);
		}

		dup2(live_pipe[0], 0);
		close(live_pipe[1]);

		__argv = malloc((argc + 4) * sizeof(const char *));
		if (!__argv) {
			pr_err("malloc failed\n");
			err = -ENOMEM;
			goto out;
		}

		j = 0;
		__argv[j++] = "/bin/sh";
		__argv[j++] = rep_script_path;
		for (i = 1; i < rep_args + 1; i++)
			__argv[j++] = argv[i];
		__argv[j++] = "-i";
		__argv[j++] = "-";
		__argv[j++] = NULL;

		execvp("/bin/sh", (char **)__argv);
		free(__argv);
		exit(-1);
	}

	if (rec_script_path)
		script_path = rec_script_path;
	if (rep_script_path)
		script_path = rep_script_path;

	if (script_path) {
		j = 0;

		if (!rec_script_path)
			system_wide = false;
		else if (!system_wide) {
			if (have_cmd(argc - 1, &argv[1]) != 0) {
				err = -1;
				goto out;
			}
		}

		__argv = malloc((argc + 2) * sizeof(const char *));
		if (!__argv) {
			pr_err("malloc failed\n");
			err = -ENOMEM;
			goto out;
		}

		__argv[j++] = "/bin/sh";
		__argv[j++] = script_path;
		if (system_wide)
			__argv[j++] = "-a";
		for (i = 2; i < argc; i++)
			__argv[j++] = argv[i];
		__argv[j++] = NULL;

		execvp("/bin/sh", (char **)__argv);
		free(__argv);
		exit(-1);
	}

	if (symbol__init() < 0)
		return -1;
	if (!script_name)
		setup_pager();

	session = perf_session__new(input_name, O_RDONLY, 0, false,
				    &perf_script);
	if (session == NULL)
		return -ENOMEM;

	if (cpu_list) {
		if (perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap))
			return -1;
	}

	if (!script_name && !generate_script_lang)
		perf_session__fprintf_info(session, stdout, show_full_info);

	if (!no_callchain)
		symbol_conf.use_callchain = true;
	else
		symbol_conf.use_callchain = false;

	if (generate_script_lang) {
		struct stat perf_stat;
		int input;

		if (output_set_by_user()) {
			fprintf(stderr,
				"custom fields not supported for generated scripts");
			return -1;
		}

		input = open(session->filename, O_RDONLY);	/* input_name */
		if (input < 0) {
			perror("failed to open file");
			return -1;
		}

		err = fstat(input, &perf_stat);
		if (err < 0) {
			perror("failed to stat file");
			return -1;
		}

		if (!perf_stat.st_size) {
			fprintf(stderr, "zero-sized file, nothing to do!\n");
			return 0;
		}

		scripting_ops = script_spec__lookup(generate_script_lang);
		if (!scripting_ops) {
			fprintf(stderr, "invalid language specifier");
			return -1;
		}

		err = scripting_ops->generate_script(session->pevent,
						     "perf-script");
		goto out;
	}

	if (script_name) {
		err = scripting_ops->start_script(script_name, argc, argv);
		if (err)
			goto out;
		pr_debug("perf script started with script %s\n\n", script_name);
	}

	err = perf_session__check_output_opt(session);
	if (err < 0)
		goto out;

	err = __cmd_script(session);

	perf_session__delete(session);
	cleanup_scripting();
out:
	return err;
}


text:
/* $Id$ */

package ibis.io;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ReadOnlyBufferException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This is a complete implementation of DataInputStream.
 * It is built on top of an InputStream.
 * There is no need to put any buffering inbetween. This implementation
 * does all the buffering needed.
 */
public final class BufferedArrayInputStream extends DataInputStream {

    private static final boolean DEBUG = IOProperties.DEBUG;

    private static final Logger logger = LoggerFactory.getLogger(BufferedArrayInputStream.class);

    /** The buffer size. */
    private final int BUF_SIZE;

    /** The underlying InputStream. */
    private InputStream in;

    /** The buffer. */
    private byte[] buffer;

    private int index, buffered_bytes;

    /** Number of bytes read so far from the underlying layer. */
    private long bytes = 0;

    /** Object used to convert primitive types to bytes. */
    private Conversion conversion;

    /**
     * Constructor.
     * @param in        the underlying InStream
     * @param bufSize   the size of the input buffer in bytes
     */
    public BufferedArrayInputStream(InputStream in, int bufSize) {
        this.in = in;
        BUF_SIZE = bufSize;
        buffer = new byte[BUF_SIZE];
        conversion = Conversion.loadConversion(false);
    }

    /**
     * Constructor.
     * @param in        the underlying InStream
     */
    public BufferedArrayInputStream(InputStream in) {
        this(in, IOProperties.BUFFER_SIZE);
    }

    public long bytesRead() {
        return bytes - buffered_bytes;
    }

    public void resetBytesRead() {
        bytes = buffered_bytes;
    }

    private static final int min(int a, int b) {
        return (a > b) ? b : a;
    }

    public final int read() throws IOException {
        try {
            int b = readByte();
            return (b & 0377);
        } catch(EOFException e) {
            return -1;
        }
    }

    private final void fillBuffer(int len) throws IOException {

        // This ensures that there are at least 'len' bytes in the buffer
        // PRECONDITION: 'index + buffered_bytes' should never be larger
        // than BUF_SIZE!!

        if (buffered_bytes >= len) {
            return;
        }
        if (buffered_bytes == 0) {
            index = 0;
        } else if (index + buffered_bytes > BUF_SIZE - len) {
            // not enough space for "len" more bytes
            System.arraycopy(buffer, index, buffer, 0, buffered_bytes);
            index = 0;
        }
        while (buffered_bytes < len) {
            int n = in.read(buffer, index + buffered_bytes, BUF_SIZE
                    - (index + buffered_bytes));
            if (n < 0) {
                throw new java.io.EOFException("EOF encountered");
            }
            bytes += n;
            buffered_bytes += n;
        }
    }

    public final int available() throws IOException {
        return (buffered_bytes + in.available());
    }

    public void readArray(boolean[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(boolean[" + off + " ... "
                    + (off + len) + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_BOOLEAN;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_BOOLEAN;
                conversion.byte2boolean(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_BOOLEAN;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer
        conversion.byte2boolean(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public void readArray(byte[] a, int off, int len) throws IOException {
        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(byte[" + off + " ... " + (off + len)
                    + "])");
        }

        if (buffered_bytes >= len) {
            // data is already in the buffer.
            System.arraycopy(buffer, index, a, off, len);
            index += len;
            buffered_bytes -= len;

        } else {
            if (buffered_bytes != 0) {
                // first, copy the data we do have to 'a' .
                System.arraycopy(buffer, index, a, off, buffered_bytes);
            }
            int rd = buffered_bytes;
            index = 0;
            do {
                int n = in.read(a, off + rd, len - rd);
                if (n < 0) {
                    throw new java.io.EOFException("EOF encountered");
                }
                rd += n;
                bytes += n;
            } while (rd < len);

            buffered_bytes = 0;
        }
    }

    // static int R = 0;
    // static int W = 0;

    public void readArray(short[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(char[" + off + " ... " + (off + len)
                    + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_SHORT;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_SHORT;
                conversion.byte2short(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_SHORT;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer
        conversion.byte2short(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public void readArray(char[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(char[" + off + " ... " + (off + len)
                    + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_CHAR;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_CHAR;
                conversion.byte2char(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_CHAR;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer
        conversion.byte2char(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public void readArray(int[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(int[" + off + " ... " + (off + len)
                    + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_INT;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_INT;

                conversion.byte2int(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_INT;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer

        conversion.byte2int(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public void readArray(long[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(long[" + off + " ... " + (off + len)
                    + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_LONG;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_LONG;
                conversion.byte2long(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_LONG;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer
        conversion.byte2long(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public void readArray(float[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(float[" + off + " ... " + (off + len)
                    + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_FLOAT;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_FLOAT;
                conversion.byte2float(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_FLOAT;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer
        conversion.byte2float(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public void readArray(double[] a, int off, int len) throws IOException {

        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("readArray(double[" + off + " ... "
                    + (off + len) + "])");
        }

        int useable, converted;
        int to_convert = len * Constants.SIZEOF_DOUBLE;

        while (buffered_bytes < to_convert) {
            // not enough data in the buffer

            if (buffered_bytes == 0) {
                index = 0;
                fillBuffer(min(BUF_SIZE, to_convert));
            } else {
                // first, copy the data we do have to 'a' .
                useable = buffered_bytes / Constants.SIZEOF_DOUBLE;
                conversion.byte2double(buffer, index, a, off, useable);

                len -= useable;
                off += useable;

                converted = useable * Constants.SIZEOF_DOUBLE;
                index += converted;
                buffered_bytes -= converted;
                to_convert -= converted;

                // second, copy the leftovers to the start of the buffer.
                for (int i = 0; i < buffered_bytes; i++) {
                    buffer[i] = buffer[index + i];
                }
                index = 0;

                // third, fill the buffer as far as possible.
                fillBuffer(min(BUF_SIZE, to_convert));
            }
        }

        // enough data in the buffer
        conversion.byte2double(buffer, index, a, off, len);
        buffered_bytes -= to_convert;
        index += to_convert;
    }

    public byte readByte() throws IOException {
        fillBuffer(1);
        buffered_bytes--;
        return buffer[index++];
    }

    public boolean readBoolean() throws IOException {
        fillBuffer(1);
        buffered_bytes--;
        return conversion.byte2boolean(buffer[index++]);
    }

    public char readChar() throws IOException {
        char v;
        fillBuffer(Constants.SIZEOF_CHAR);
        v = conversion.byte2char(buffer, index);
        index += Constants.SIZEOF_CHAR;
        buffered_bytes -= Constants.SIZEOF_CHAR;
        return v;
    }

    public short readShort() throws IOException {
        short v;
        fillBuffer(Constants.SIZEOF_SHORT);
        v = conversion.byte2short(buffer, index);
        index += Constants.SIZEOF_SHORT;
        buffered_bytes -= Constants.SIZEOF_SHORT;
        return v;
    }

    public int readInt() throws IOException {
        int v;
        fillBuffer(Constants.SIZEOF_INT);
        v = conversion.byte2int(buffer, index);
        index += Constants.SIZEOF_INT;
        buffered_bytes -= Constants.SIZEOF_INT;
        return v;
    }

    public long readLong() throws IOException {
        long v;
        fillBuffer(Constants.SIZEOF_LONG);
        v = conversion.byte2long(buffer, index);
        index += Constants.SIZEOF_LONG;
        buffered_bytes -= Constants.SIZEOF_LONG;
        return v;
    }

    public float readFloat() throws IOException {
        float v;
        fillBuffer(Constants.SIZEOF_FLOAT);
        v = conversion.byte2float(buffer, index);
        index += Constants.SIZEOF_FLOAT;
        buffered_bytes -= Constants.SIZEOF_FLOAT;
        return v;
    }

    public double readDouble() throws IOException {
        double v;
        fillBuffer(Constants.SIZEOF_DOUBLE);
        v = conversion.byte2double(buffer, index);
        index += Constants.SIZEOF_DOUBLE;
        buffered_bytes -= Constants.SIZEOF_DOUBLE;
        return v;
    }

    public int read(byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    public int read(byte[] a, int off, int len) throws IOException {
        if (DEBUG && logger.isDebugEnabled()) {
            logger.debug("read(byte[" + off + " ... " + (off + len)
                    + "])");
        }

        if (buffered_bytes >= len) {
            // data is already in the buffer.

            System.arraycopy(buffer, index, a, off, len);
            index += len;
            buffered_bytes -= len;
        } else {
            if (buffered_bytes != 0) {
                // first, copy the data we do have to 'a' .
                System.arraycopy(buffer, index, a, off, buffered_bytes);
            }
            int rd = buffered_bytes;
            index = 0;
            do {
                int n = in.read(a, off + rd, len - rd);
                if (n < 0) {
                    len = rd;
                }
                else {
                    rd += n;
                    bytes += n;
                }
            } while (rd < len);

            buffered_bytes = 0;
        }

        return len;
    }

    public void close() throws IOException {
        in.close();
    }

    public int bufferSize() {
        return BUF_SIZE;
    }

    public void readByteBuffer(ByteBuffer value) throws IOException,
	    ReadOnlyBufferException {

	int len = value.limit() - value.position();

        if (buffered_bytes >= len) {
            // data is already in the buffer.
            value.put(buffer, index, len);
            index += len;
            buffered_bytes -= len;
        } else {
            if (buffered_bytes != 0) {
                // first, copy the data we do have to 'a' .
        	value.put(buffer, index, buffered_bytes);
        	len -= buffered_bytes;
        	buffered_bytes = 0;
            }
            index = 0;
            if (value.hasArray()) {
        	in.read(value.array(), value.arrayOffset(), len);
        	value.position(value.limit());
        	bytes += len;
            } else {
        	do {
        	    int toread = Math.min(len, BUF_SIZE);
        	    fillBuffer(toread);
        	    if (len < buffered_bytes) {
        		toread = len;
        	    } else {
        		toread = buffered_bytes;
        	    }
        	    value.put(buffer, index, toread);
        	    len -= toread;
        	    index += toread;
        	    buffered_bytes -= toread;
        	} while (len > 0);
            }
        }
    }
}


text:
package io.fnx.backend.guice.validation;

import io.fnx.backend.service.DontValidate;
import io.fnx.backend.service.Validate;
import com.google.inject.Singleton;
import com.googlecode.objectify.annotation.Entity;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.inject.Inject;
import javax.validation.ConstraintViolation;
import javax.validation.groups.Default;
import java.lang.reflect.Method;
import java.util.Set;

@Singleton
public class ValidatorInterceptor implements MethodInterceptor {

    private Logger log = LoggerFactory.getLogger(ValidatorInterceptor.class);

    @Inject
    private javax.validation.Validator validator;

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Method m = invocation.getMethod();
        if (m.getAnnotation(DontValidate.class) != null) return invocation.proceed();

        // We always want to validate default group.
        // In default group end all constraints with no group explicitly specified
        Class<?>[] validationGroups = new Class<?>[]{Default.class};
        final Validate validateAnn = m.getAnnotation(Validate.class);
        if (validateAnn != null) {
            final Class<?>[] groups = validateAnn.groups();
            if (groups.length > 0) {
                final Class<?>[] mergedGroups = new Class<?>[groups.length + validationGroups.length];
                System.arraycopy(validationGroups, 0, mergedGroups, 0, validationGroups.length);
                System.arraycopy(groups, 0, mergedGroups, validationGroups.length, groups.length);
                validationGroups = mergedGroups;
            }
        }
        for (Object o : invocation.getArguments()) {
            if (o == null) continue;
            final Class<?> clazz = o.getClass();
            if (clazz.getAnnotation(Entity.class) != null || clazz.getAnnotation(Validate.class) != null) {

                Set<ConstraintViolation<Object>> result = validator.validate(o, validationGroups);
                if (result != null && !result.isEmpty()) {
                    throw new ValidationException(clazz, m, result);
                }
            }

        }
        return invocation.proceed();
    }

}


text:
package com.design.apparel.appareldesigner;

import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Typeface;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

/*******************************************************************************
 * Created by VasukiSairam on 6/22/2015.
 * This code is the main activity that displays signIn and SignUP options
 ******************************************************************************/

public class MainActivity extends Activity {
    Button btnSignIn,btnSignUp;
    ImageView imgView;
    LoginDataBaseAdapter loginDataBaseAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.home);
        imgView = (ImageView) findViewById(R.id.imgApparel);
        Bitmap bm = BitmapFactory.decodeResource(getResources(), R.drawable.apparel_designer);
        RoundImage img = new RoundImage(bm);
        imgView.setImageDrawable(img);

        btnSignIn=(Button)findViewById(R.id.buttonSignIN);
        btnSignUp=(Button)findViewById(R.id.buttonSignUP);

        btnSignUp.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

                Intent intentSignUP=new Intent(getApplicationContext(),SignUPActivity.class);
                startActivity(intentSignUP);
            }
        });

       btnSignIn.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {

             signIn(v);
            }
        });
    }

   public void signIn(View V)
    {
        final Dialog dialog = new Dialog(MainActivity.this);
        dialog.setContentView(R.layout.login);
        dialog.setTitle("Login");

        final EditText editTextUserEmail=(EditText)dialog.findViewById(R.id.editTextUserEmailToLogin);
        loginDataBaseAdapter=new LoginDataBaseAdapter(MainActivity.this);
        loginDataBaseAdapter=loginDataBaseAdapter.open();
        Button btnSignIn=(Button)dialog.findViewById(R.id.buttonSignIn);

        btnSignIn.setOnClickListener(new View.OnClickListener() {

            public void onClick(View v) {
                // get The User name and Password
                String userEmail=editTextUserEmail.getText().toString();
                // fetch the Password form database for respective user name
                Boolean exists=loginDataBaseAdapter.getSingleEntry(userEmail);

                // check if the Stored password matches with  Password entered by user
                if(exists) {
                    Toast.makeText(MainActivity.this, "Congrats: Login Successfull", Toast.LENGTH_SHORT).show();
                    Intent intentApparels = new Intent(getApplicationContext(), ApparelMenu.class);
                    startActivity(intentApparels);

                }
                else
                {
                    Toast.makeText(MainActivity.this, "Account does not exist, Please SignUP", Toast.LENGTH_LONG).show();
                }

               // new checkLogin().execute(v.getContext(),editTextUserEmail.getText().toString());
            }

        });

        dialog.show();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // Close The Database
        loginDataBaseAdapter.close();
    }
}


text:
//
//  TBaseTableViewController.m
//  Tikeyc
//
//  Created by ways on 16/9/27.
//  Copyright © 2016年 tikeyc. All rights reserved.
//

#import "TBaseTableViewController.h"

@interface TBaseTableViewController ()

@end

@implementation TBaseTableViewController

- (void)dealloc
{
    [SVProgressHUD dismiss];
    [TNotificationCenter removeObserver:self];
    [self removeObserverBlocks];
    NSLog(@"%@ 成功销毁了,无内存泄漏",self);
}

- (void)viewDidLoad {
    [super viewDidLoad];

    // Uncomment the following line to preserve selection between presentations.
    // self.clearsSelectionOnViewWillAppear = NO;

    // Uncomment the following line to display an Edit button in the navigation bar for this view controller.
    // self.navigationItem.rightBarButtonItem = self.editButtonItem;

    self.customSupportedInterfaceOrientations = UIInterfaceOrientationMaskPortrait;//默认只能竖屏
    self.edgesForExtendedLayout = UIRectEdgeNone;
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

- (BOOL)prefersStatusBarHidden
{
    return NO;
}

//是否旋转
-(BOOL)shouldAutorotate{
    return YES;
}
//支持的方向
- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return self.customSupportedInterfaceOrientations;
}

#pragma mark - Table view data source
/*
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
#warning Incomplete implementation, return the number of sections
    return 0;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
#warning Incomplete implementation, return the number of rows
    return 0;
}
*/
/*
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:<#@"reuseIdentifier"#> forIndexPath:indexPath];

    // Configure the cell...

    return cell;
}
*/

/*
// Override to support conditional editing of the table view.
- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
    // Return NO if you do not want the specified item to be editable.
    return YES;
}
*/

/*
// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        // Delete the row from the data source
        [tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
    } else if (editingStyle == UITableViewCellEditingStyleInsert) {
        // Create a new instance of the appropriate class, insert it into the array, and add a new row to the table view
    }
}
*/

/*
// Override to support rearranging the table view.
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath toIndexPath:(NSIndexPath *)toIndexPath {
}
*/

/*
// Override to support conditional rearranging of the table view.
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath {
    // Return NO if you do not want the item to be re-orderable.
    return YES;
}
*/

/*
#pragma mark - Navigation

// In a storyboard-based application, you will often want to do a little preparation before navigation
- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    // Get the new view controller using [segue destinationViewController].
    // Pass the selected object to the new view controller.
}
*/

@end