text:
package markdown

import (
	"net/http"
	"os"
	"path"
	"strconv"
	"strings"
	"text/template"
	"time"

	"github.com/mholt/caddy/caddyhttp/httpserver"
	"github.com/russross/blackfriday"
)

// Markdown implements a layer of middleware that serves
// markdown as HTML.
type Markdown struct {
	// Server root
	Root string

	// Jail the requests to site root with a mock file system
	FileSys http.FileSystem

	// Next HTTP handler in the chain
	Next httpserver.Handler

	// The list of markdown configurations
	Configs []*Config
}

// Config stores markdown middleware configurations.
type Config struct {
	// Markdown renderer
	Renderer blackfriday.Renderer

	// Base path to match
	PathScope string

	// List of extensions to consider as markdown files
	Extensions map[string]struct{}

	// List of style sheets to load for each markdown file
	Styles []string

	// List of JavaScript files to load for each markdown file
	Scripts []string

	// The list of index files to try
	IndexFiles []string

	// Template(s) to render with
	Template *template.Template

	// a pair of template's name and its underlying file path
	TemplateFiles map[string]string
}

// ServeHTTP implements the http.Handler interface.
func (md Markdown) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
	var cfg *Config
	for _, c := range md.Configs {
		if httpserver.Path(r.URL.Path).Matches(c.PathScope) { // not negated
			cfg = c
			break // or goto
		}
	}
	if cfg == nil {
		return md.Next.ServeHTTP(w, r) // exit early
	}

	// We only deal with HEAD/GET
	switch r.Method {
	case http.MethodGet, http.MethodHead:
	default:
		return http.StatusMethodNotAllowed, nil
	}

	var dirents []os.FileInfo
	var lastModTime time.Time
	fpath := r.URL.Path
	if idx, ok := httpserver.IndexFile(md.FileSys, fpath, cfg.IndexFiles); ok {
		// We're serving a directory index file, which may be a markdown
		// file with a template.  Let's grab a list of files this directory
		// URL points to, and pass that in to any possible template invocations,
		// so that templates can customize the look and feel of a directory.
		fdp, err := md.FileSys.Open(fpath)
		switch {
		case err == nil: // nop
		case os.IsPermission(err):
			return http.StatusForbidden, err
		case os.IsExist(err):
			return http.StatusNotFound, nil
		default: // did we run out of FD?
			return http.StatusInternalServerError, err
		}
		defer fdp.Close()

		// Grab a possible set of directory entries.  Note, we do not check
		// for errors here (unreadable directory, for example).  It may
		// still be useful to have a directory template file, without the
		// directory contents being present.  Note, the directory's last
		// modification is also present here (entry ".").
		dirents, _ = fdp.Readdir(-1)
		for _, d := range dirents {
			lastModTime = latest(lastModTime, d.ModTime())
		}

		// Set path to found index file
		fpath = idx
	}

	// If not supported extension, pass on it
	if _, ok := cfg.Extensions[path.Ext(fpath)]; !ok {
		return md.Next.ServeHTTP(w, r)
	}

	// At this point we have a supported extension/markdown
	f, err := md.FileSys.Open(fpath)
	switch {
	case err == nil: // nop
	case os.IsPermission(err):
		return http.StatusForbidden, err
	case os.IsExist(err):
		return http.StatusNotFound, nil
	default: // did we run out of FD?
		return http.StatusInternalServerError, err
	}
	defer f.Close()

	fs, err := f.Stat()
	if err != nil {
		return http.StatusGone, nil
	}
	lastModTime = latest(lastModTime, fs.ModTime())

	ctx := httpserver.NewContextWithHeader(w.Header())
	ctx.Root = md.FileSys
	ctx.Req = r
	ctx.URL = r.URL
	html, err := cfg.Markdown(title(fpath), f, dirents, ctx)
	if err != nil {
		return http.StatusInternalServerError, err
	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Header().Set("Content-Length", strconv.Itoa(len(html)))
	httpserver.SetLastModifiedHeader(w, lastModTime)
	if r.Method == http.MethodGet {
		w.Write(html)
	}
	return http.StatusOK, nil
}

// latest returns the latest time.Time
func latest(t ...time.Time) time.Time {
	var last time.Time

	for _, tt := range t {
		if tt.After(last) {
			last = tt
		}
	}

	return last
}

// title gives a backup generated title for a page
func title(p string) string {
	return strings.TrimSuffix(path.Base(p), path.Ext(p))
}


text:
<component name="libraryTable">
  <library name="1_android-support-v4">
    <CLASSES>
      <root url="jar://$PROJECT_DIR$/build/exploded-aar/TestePaginator.libs/melo-paginator/unspecified/libs/android-support-v4.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES />
  </library>
</component>

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>org.jivesoftware.util.cache Class Hierarchy (Openfire 3.10.2 Javadoc)</title>
<meta name="date" content="2015-06-22">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Tree

Deprecated

Index

Help

Openfire 3.10.2 Javadoc

Prev

Next

Frames

No Frames

All Classes

Hierarchy For Package org.jivesoftware.util.cache

Package Hierarchies:

All Packages

Class Hierarchy

java.lang.Object

org.jivesoftware.util.cache.CacheFactory

org.jivesoftware.util.cache.CacheSizes

org.jivesoftware.util.cache.CacheWrapper<K,V> (implements org.jivesoftware.util.cache.Cache<K,V>)

org.jivesoftware.util.cache.ComponentCacheWrapper<K,V>

org.jivesoftware.util.cache.DefaultCache<K,V> (implements org.jivesoftware.util.cache.Cache<K,V>)

org.jivesoftware.util.cache.DefaultLocalCacheStrategy (implements org.jivesoftware.util.cache.CacheFactoryStrategy)

org.jivesoftware.util.cache.DummyExternalizableUtil (implements org.jivesoftware.util.cache.ExternalizableUtilStrategy)

org.jivesoftware.util.cache.ExternalizableUtil

java.lang.Throwable (implements java.io.Serializable)

java.lang.Exception

org.jivesoftware.util.cache.CannotCalculateSizeException

Interface Hierarchy

org.jivesoftware.util.cache.CacheFactoryStrategy

org.jivesoftware.util.cache.ExternalizableUtilStrategy

java.util.Map<K,V>

org.jivesoftware.util.cache.Cache<K,V>

java.lang.Runnable

org.jivesoftware.util.cache.ClusterTask (also extends java.io.Externalizable)

java.io.Serializable

org.jivesoftware.util.cache.Cacheable

java.io.Externalizable

org.jivesoftware.util.cache.ClusterTask (also extends java.lang.Runnable)

Overview

Package

Class

Tree

Deprecated

Index

Help

Openfire 3.10.2 Javadoc

Prev

Next

Frames

No Frames

All Classes

Copyright © 2003-2008 Jive Software.


text:
#ifndef RMLUI_CORE_DATAEXPRESSION_H
#define RMLUI_CORE_DATAEXPRESSION_H

#include "../../Include/RmlUi/Core/Header.h"
#include "../../Include/RmlUi/Core/Types.h"
#include "../../Include/RmlUi/Core/DataTypes.h"

namespace Rml {

class Element;
class DataModel;
struct InstructionData;
using Program = Vector<InstructionData>;
using AddressList = Vector<DataAddress>;

class DataExpressionInterface {
public:
    DataExpressionInterface() = default;
    DataExpressionInterface(DataModel* data_model, Element* element, Event* event = nullptr);

    DataAddress ParseAddress(const String& address_str) const;
    Variant GetValue(const DataAddress& address) const;
    bool SetValue(const DataAddress& address, const Variant& value) const;
    bool CallTransform(const String& name, Variant& inout_result, const VariantList& arguments);
    bool EventCallback(const String& name, const VariantList& arguments);

private:
    DataModel* data_model = nullptr;
    Element* element = nullptr;
    Event* event = nullptr;
};

class DataExpression {
public:
    DataExpression(String expression);
    ~DataExpression();

    bool Parse(const DataExpressionInterface& expression_interface, bool is_assignment_expression);

    bool Run(const DataExpressionInterface& expression_interface, Variant& out_value);

    // Available after Parse()
    StringList GetVariableNameList() const;

private:
    String expression;

    Program program;
    AddressList addresses;
};

} // namespace Rml
#endif


text:
SpreeExtendedLineItem
=====================

This extension gives you ability to mark products as being
sold by volume ( ex. 1.35 kilos of potatos ).

This means

Example
=======

Example goes here.

Testing
-------

Be sure to add the rspec-rails gem to your Gemfile and then create a dummy test app for the specs to run against.

    $ bundle exec rake test app
    $ bundle exec rspec spec

Copyright (c) 2012 [name of extension creator], released under the New BSD License


text:
/* Polyfills */
import "core-js/es6"
import "core-js/es7/reflect"
require("zone.js/dist/zone")


text:
import { PageComponent } from '@shared/components/page.component';
import { Component, Input, NgZone, OnInit } from '@angular/core';
import { WidgetContext } from '@home/models/widget-component.models';
import { Store } from '@ngrx/store';
import { AppState } from '@core/core.state';
import { Router } from '@angular/router';
import { UtilsService } from '@core/services/utils.service';

interface NavigationCardWidgetSettings {
  name: string;
  icon: string;
  path: string;
}

@Component({
  selector: 'tb-navigation-card-widget',
  templateUrl: './navigation-card-widget.component.html',
  styleUrls: ['./navigation-card-widget.component.scss']
})
export class NavigationCardWidgetComponent extends PageComponent implements OnInit {

  settings: NavigationCardWidgetSettings;

  translatedName: string;

  @Input()
  ctx: WidgetContext;

  constructor(protected store: Store<AppState>,
              private utils: UtilsService,
              private ngZone: NgZone,
              private router: Router) {
    super(store);
  }

  ngOnInit(): void {
    this.ctx.$scope.navigationCardWidget = this;
    this.settings = this.ctx.settings;
    this.translatedName = this.utils.customTranslation(this.settings.name, this.settings.name);
  }

  navigate($event: Event, path: string) {
    $event.preventDefault();
    this.ngZone.run(() => {
      this.router.navigateByUrl(path);
    });
  }

}


text:
#!/bin/env node
//  OpenShift sample Node application
var express = require('express');
var fs      = require('fs');

function getArticle(dateString) {

    return '{ "title" : "an article", "description" : "this is an article", "date" : "' + dateString + '" }';
}

function getArticles(date) {
    var articles = "";

    var dateString = date.toISOString().
                                replace(/T/, ' ').
                                replace(/\..+/, '');

    var articleCount = date.getSeconds();
    var articleCountString = articleCount.toString();
    if (articleCountString.length > 1)
        articleCountString = articleCountString[1];
    else
        articleCountString = articleCountString[0];

    articles = getArticle(dateString);
    for (var i=1; i<Number(articleCountString); i++) {
        articles = articles.concat(',');
        articles = articles.concat(getArticle(dateString));
    }

    return articles;
}

/**
 *  Define the sample application.
 */
var SampleApp = function() {

    //  Scope.
    var self = this;

    /*  ================================================================  */
    /*  Helper functions.                                                 */
    /*  ================================================================  */

    /**
     *  Set up server IP address and port # using env variables/defaults.
     */
    self.setupVariables = function() {
        //  Set the environment variables we need.
        self.ipaddress = process.env.OPENSHIFT_NODEJS_IP;
        self.port      = process.env.OPENSHIFT_NODEJS_PORT || 8080;

        if (typeof self.ipaddress === "undefined") {
            //  Log errors on OpenShift but continue w/ 127.0.0.1 - this
            //  allows us to run/test the app locally.
            console.warn('No OPENSHIFT_NODEJS_IP var, using 127.0.0.1');
            self.ipaddress = "127.0.0.1";
        };
    };

    /**
     *  Populate the cache.
     */
    self.populateCache = function() {
        if (typeof self.zcache === "undefined") {
            self.zcache = { 'index.html': '' };
        }

        //  Local cache for static content.
        self.zcache['index.html'] = fs.readFileSync('./index.html');
    };

    /**
     *  Retrieve entry (content) from cache.
     *  @param {string} key  Key identifying content to retrieve from cache.
     */
    self.cache_get = function(key) { return self.zcache[key]; };

    /**
     *  terminator === the termination handler
     *  Terminate server on receipt of the specified signal.
     *  @param {string} sig  Signal to terminate on.
     */
    self.terminator = function(sig){
        if (typeof sig === "string") {
           console.log('%s: Received %s - terminating sample app ...',
                       Date(Date.now()), sig);
           process.exit(1);
        }
        console.log('%s: Node server stopped.', Date(Date.now()) );
    };

    /**
     *  Setup termination handlers (for exit and a list of signals).
     */
    self.setupTerminationHandlers = function(){
        //  Process on exit and signals.
        process.on('exit', function() { self.terminator(); });

        // Removed 'SIGPIPE' from the list - bugz 852598.
        ['SIGHUP', 'SIGINT', 'SIGQUIT', 'SIGILL', 'SIGTRAP', 'SIGABRT',
         'SIGBUS', 'SIGFPE', 'SIGUSR1', 'SIGSEGV', 'SIGUSR2', 'SIGTERM'
        ].forEach(function(element, index, array) {
            process.on(element, function() { self.terminator(element); });
        });
    };

    /*  ================================================================  */
    /*  App server functions (main app logic here).                       */
    /*  ================================================================  */

    /**
     *  Create the routing table entries + handlers for the application.
     */
    self.createRoutes = function() {
        self.routes = { };

        // Routes for /health, /asciimo and /
        self.routes['/health'] = function(req, res) {
            res.send('1');
        };

        self.routes['/asciimo'] = function(req, res) {
            var link = "http://i.imgur.com/kmbjB.png";
            res.send("");
        };

        self.routes['/'] = function(req, res) {
            res.setHeader('Content-Type', 'text/html');
            res.send(self.cache_get('index.html') );
        };

        self.routes['/articles'] = function(req, res) {
            var dateString = new Date().toISOString().
                                       replace(/T/, ' ').
                                       replace(/\..+/, '');
            res.setHeader('Content-Type', 'application/json');

            var articles = getArticles(new Date());

/**            res.send('{ "response" : "success", "articles" : [ { "title" : "an article", "description" : "this is an article", "date" : "' + dateString + '" } ] }'); */

            res.send('{ "response" : "success", "articles" : [ ' + articles + ' ] }');
        };
    };

    /**
     *  Initialize the server (express) and create the routes and register
     *  the handlers.
     */
    self.initializeServer = function() {
        self.createRoutes();
        self.app = express.createServer();

        //  Add handlers for the app (from the routes).
        for (var r in self.routes) {
            self.app.get(r, self.routes[r]);
        }
    };

    /**
     *  Initializes the sample application.
     */
    self.initialize = function() {
        self.setupVariables();
        self.populateCache();
        self.setupTerminationHandlers();

        // Create the express server and routes.
        self.initializeServer();
    };

    /**
     *  Start the server (starts up the sample application).
     */
    self.start = function() {
        //  Start the app on the specific interface (and port).
        self.app.listen(self.port, self.ipaddress, function() {
            console.log('%s: Node server started on %s:%d ...',
                        Date(Date.now() ), self.ipaddress, self.port);
        });
    };

};   /*  Sample Application.  */

/**
 *  main():  Main code.
 */
var zapp = new SampleApp();
zapp.initialize();
zapp.start();


text:
package org.voovan.docker.test.command;

import junit.framework.TestCase;
import org.voovan.docker.DockerGlobal;
import org.voovan.docker.command.Container.*;
import org.voovan.tools.TEnv;
import org.voovan.tools.TFile;
import org.voovan.tools.TString;
import org.voovan.tools.json.JSON;
import org.voovan.tools.log.Logger;

import java.io.File;
import java.nio.ByteBuffer;

/**
 * 类文字命名
 *
 * @author helyho
 *         <p>
 *         JDocker Framework.
 *         WebSite: https://github.com/helyho/JDocker
 *         Licence: Apache v2 License
 */
public class ContainersUnit extends TestCase {

    public ContainersUnit(String name) {
        super(name);
    }

    public String formatJSON(Object obj){
        return JSON.formatJson(JSON.toJSON(obj));
    }

    public void setUp(){
        DockerGlobal.DOCKER_REST_HOST = "127.0.0.1";
        DockerGlobal.DOCKER_REST_PORT = 2735;
        DockerGlobal.DEBUG = true;
    }

    public void testCreate() throws Exception {
        CmdContainerCreate createCmd =  CmdContainerCreate.newInstance("Voovan");
        createCmd.connect();
        Object data = createCmd.image("alpine").network("bridge")
                .bind("v_tx:/v_tx").link("dockerfly:dockerfly")
                .cmd("ping","127.0.0.1").env("author=helyho")
                .exposePort("tcp",22,"2222").send();
        createCmd.close();
        Logger.info(formatJSON(data));
    }

    public void testInfo() throws Exception {
        CmdContainerList cmdContainersList = CmdContainerList.newInstance();
        cmdContainersList.connect();
        Object data = cmdContainersList.name("dockerfly").all(true).send();
        cmdContainersList.close();
        Logger.info(formatJSON(data));
        while(true){
            cmdContainersList.connect();
            data = cmdContainersList.name("dockerfly").all(true).send();
            cmdContainersList.close();
            Logger.info(formatJSON(data));
            TEnv.sleep(1);
        }
    }

    public void testDetail() throws Exception {
        CmdContainerDetail cmdContainerDetail = CmdContainerDetail.newInstance("dockerfly");
        cmdContainerDetail.connect();
        Object data = cmdContainerDetail.send();
        cmdContainerDetail.close();
        Logger.info(formatJSON(data));
    }

    public void testRename() throws Exception {
        CmdContainerRename cmdContainerRename = CmdContainerRename.newInstance("53b3bd0cfd787f471ec9fbbd4b62d95d043df1249c818a77df7603cbb536fc60");
        Object data = cmdContainerRename.newName("dockfly_1").send();
        cmdContainerRename.close();
        Logger.info(formatJSON(data));
    }

    public void testUpdate() throws Exception {
        CmdContainerUpdate cmdContainerUpdate =  CmdContainerUpdate.newInstance("Voovan");
        cmdContainerUpdate.connect();
        Object data = cmdContainerUpdate.cpuPeriod(1000000).memory(250).send();
        cmdContainerUpdate.close();
        Logger.info(formatJSON(data));
    }

    public void testRemove() throws Exception {
        CmdContainerRemove cmdContainerRemove = CmdContainerRemove.newInstance("Voovan");
        cmdContainerRemove.connect();
        Object data = cmdContainerRemove.send();
        cmdContainerRemove.close();
        Logger.info(formatJSON(data));
    }

    public void testStart() throws Exception {
        CmdContainerStart cmdContainerStart = CmdContainerStart.newInstance("Voovan");
        cmdContainerStart.connect();
        Object data = cmdContainerStart.send();
        cmdContainerStart.close();
        Logger.info(formatJSON(data));
    }

    public void testStop() throws Exception {
        CmdContainerStop cmdContainerStop = CmdContainerStop.newInstance("Voovan");
        cmdContainerStop.connect();
        Object data = cmdContainerStop.send();
        cmdContainerStop.close();
        Logger.info(formatJSON(data));
    }

    public void testChange() throws Exception {
        CmdContainerChange cmdContainerChange = CmdContainerChange.newInstance("Voovan");
        cmdContainerChange.connect();
        Object data = cmdContainerChange.send();
        cmdContainerChange.close();
        Logger.info(formatJSON(data));
    }

    public void testTop() throws Exception {
        CmdContainerTop cmdContainerTop = CmdContainerTop.newInstance("Voovan");
        cmdContainerTop.connect();
        Object data = cmdContainerTop.send();
        cmdContainerTop.close();
        Logger.info(formatJSON(data));
    }

    public void testStats() throws Exception {
        CmdContainerStats cmdContainerStats = CmdContainerStats.newInstance("dockerfly");
        cmdContainerStats.connect();
        Object data = cmdContainerStats.send();
        cmdContainerStats.close();
        Logger.info(formatJSON(data));
    }

    public void testPause() throws Exception {
        CmdContainerPause cmdContainerPause = CmdContainerPause.newInstance("Voovan");
        cmdContainerPause.connect();
        Object data = cmdContainerPause.send();
        cmdContainerPause.close();
        Logger.info(formatJSON(data));
    }

    public void testUnPause() throws Exception {
        CmdContainerUnPause cmdContainerUnPause = CmdContainerUnPause.newInstance("Voovan");
        cmdContainerUnPause.connect();
        Object data = cmdContainerUnPause.send();
        cmdContainerUnPause.close();
        Logger.info(formatJSON(data));
    }

    public void testReStart() throws Exception {
        CmdContainerReStart cmdContainerReStart = CmdContainerReStart.newInstance("Voovan");
        cmdContainerReStart.connect();
        Object data = cmdContainerReStart.send();
        cmdContainerReStart.close();
        Logger.info(formatJSON(data));
    }

    public void testResize() throws Exception {
        CmdContainerResize cmdContainerResize = CmdContainerResize.newInstance("Voovan");
        cmdContainerResize.connect();
        Object data = cmdContainerResize.height(30).width(20).send();
        cmdContainerResize.close();
        Logger.info(formatJSON(data));
    }

    public void testAttach() throws Exception {
        CmdContainerAttach cmdContainerAttach = CmdContainerAttach.newInstance("voovan");
        cmdContainerAttach.connect();
        Object data = cmdContainerAttach.logs(true).stream(true).stdin(true)
                .stdout(true).stderr(true).send();
        cmdContainerAttach.close();
        Logger.info(formatJSON(data));
    }

    public void testAttachStream() throws Exception {
        CmdContainerAttach cmdContainerAttach = CmdContainerAttach.newInstance("voovan");
        cmdContainerAttach.stream(true);
        cmdContainerAttach.stdout(true);
        cmdContainerAttach.connect();
        cmdContainerAttach.send();

        int count = 0;
        while(true){
            String data = cmdContainerAttach.loadStream();
            if(data!=null) {
                Logger.simple(data);
            }
            TEnv.sleep(1000);
            count ++;

            if(count > 10){
                break;
            }
        }

        cmdContainerAttach.close();
    }

    public void testLogs() throws Exception {
        CmdContainerLogs cmdContainerLogs = CmdContainerLogs.newInstance("dockerfly");
        cmdContainerLogs.connect();
        Object data = cmdContainerLogs.send();
        cmdContainerLogs.close();
        Logger.info(TString.unConvertEscapeChar((String)data));
    }

    public void testCommit() throws Exception {
        CmdContainerCommit cmdContainerCommit = CmdContainerCommit.newInstance("Voovan");
        cmdContainerCommit.connect();
        Object data = cmdContainerCommit.repo("helyhotest").tag("latest").pause(true).send();
        cmdContainerCommit.close();
        Logger.info(formatJSON(data));
    }

    public void testKill() throws Exception {
        CmdContainerKill cmdContainerKill = CmdContainerKill.newInstance("Voovan");
        cmdContainerKill.connect();
        String data = cmdContainerKill.send();
        cmdContainerKill.close();
        Logger.info(formatJSON(data));
    }

    public void testExport() throws Exception {
        CmdContainerExport cmdContainerExport = CmdContainerExport.newInstance("Voovan");
        cmdContainerExport.connect();
        ByteBuffer data = cmdContainerExport.send();
        cmdContainerExport.close();
        TFile.writeFile(new File("/Users/helyho/x.tar"),data.array());
    }

    public void testArchiveGet() throws Exception {
        CmdContainerArchiveGet cmdContainerArchiveGet = CmdContainerArchiveGet.newInstance("Voovan");
        cmdContainerArchiveGet.connect();
        ByteBuffer data = cmdContainerArchiveGet.path("/etc/hosts").send();
        cmdContainerArchiveGet.close();
        TFile.writeFile(new File("/Users/helyho/x.tar"),data.array());
    }

    public void testArchivePut() throws Exception {
        CmdContainerArchivePut cmdContainerArchivePut = CmdContainerArchivePut.newInstance("Voovan","/Users/helyho/x.tar");
        cmdContainerArchivePut.connect();
        ByteBuffer data = cmdContainerArchivePut.path("/root").send();
        cmdContainerArchivePut.close();
        Logger.info(formatJSON(data));
    }
}


text:
package org.kordamp.ikonli.boxicons;

/**
 * @author Andres Almiray
 */
@org.kordamp.jipsy.annotations.ServiceProviderFor(org.kordamp.ikonli.IkonProvider.class)
public class BoxiconsRegularIkonProvider implements org.kordamp.ikonli.IkonProvider<BoxiconsRegular> {
    @Override
    public Class<BoxiconsRegular> getIkon() {
        return BoxiconsRegular.class;
    }
}


text:
package net.hydromatic.optiq.rules.java;

import net.hydromatic.linq4j.expressions.Expression;
import net.hydromatic.linq4j.expressions.ParameterExpression;

import org.eigenbase.rel.RelCollation;
import org.eigenbase.rel.RelFieldCollation;
import org.eigenbase.reltype.RelDataType;
import org.eigenbase.util.Pair;

import java.lang.reflect.Type;
import java.util.List;

/**
 * Physical type of a row.
 *
 *
Consists of the SQL row type (returned by {@link #getRowType()}), the Java
 * type of the row (returned by {@link #getJavaRowType()}), and methods to
 * generate expressions to access fields, generate records, and so forth.
 * Together, the records encapsulate how the logical type maps onto the physical
 * type.

 */
public interface PhysType {
  /** Returns the Java type (often a Class) that represents a row. For
   * example, in one row format, always returns {@code Object[].class}. */
  Type getJavaRowType();

  /**
   * Returns the Java class that is used to store the field with the given
   * ordinal.
   *
   *
For instance, when the java row type is {@code Object[]}, the java
   * field type is {@code Object} even if the field is not nullable.
 */
  Type getJavaFieldType(int field);

  /** Returns the SQL row type. */
  RelDataType getRowType();

  /** Returns the Java class of the field with the given ordinal. */
  Class fieldClass(int field);

  /** Returns whether a given field allows null values. */
  boolean fieldNullable(int index);

  /** Generates a reference to a given field in an expression.
   *
   *
For example given {@code expression=employee} and {@code field=2},
   * generates

   *
   *
{@code employee.deptno}

   *
   * @param expression Expression
   * @param field Ordinal of field
   * @return Expression to access the field of the expression
   */
  Expression fieldReference(Expression expression, int field);

  /** Generates a reference to a given field in an expression.
   *
   *
This method optimizes for the target storage type (i.e. avoids
   * casts).

   *
   *
For example given {@code expression=employee} and {@code field=2},
   * generates

   *
   *
{@code employee.deptno}

   *
   * @param expression Expression
   * @param field Ordinal of field
   * @param storageType optional hint for storage class
   * @return Expression to access the field of the expression
   */
  Expression fieldReference(Expression expression, int field,
      Type storageType);

  /** Generates an accessor function for a given list of fields.  The resulting
   * object is a {@link List} (implementing {@link Object#hashCode()} and
   * {@link Object#equals(Object)} per that interface) and also implements
   * {@link Comparable}.
   *
   *
For example:

   *
   *
{@code
   * new Function1<Employee, Object[]> {
   *    public Object[] apply(Employee v1) {
   *        return FlatLists.of(v1.<fieldN>, v1.<fieldM>);
   *    }
   * }
   * }

   */
  Expression generateAccessor(List<Integer> fields);

  /** Generates a selector for the given fields from an expression, with the
   * default row format. */
  Expression generateSelector(
      ParameterExpression parameter,
      List<Integer> fields);

  /** Generates a lambda expression that is a selector for the given fields from
   * an expression. */
  Expression generateSelector(
      ParameterExpression parameter,
      List<Integer> fields,
      JavaRowFormat targetFormat);

  /** Generates a selector for the given fields from an expression. */
  Expression selector(
      ParameterExpression parameter,
      List<Integer> fields,
      JavaRowFormat targetFormat);

  /** Projects a given collection of fields from this input record, into
   * a particular preferred output format. The output format is optimized
   * if there are 0 or 1 fields. */
  PhysType project(
      List<Integer> integers,
      JavaRowFormat format);

  /** Returns a lambda to create a collation key and a comparator. The
   * comparator is sometimes null. */
  Pair<Expression, Expression> generateCollationKey(
      List<RelFieldCollation> collations);

  /** Returns a comparator. Unlike the comparator returned by
   * {@link #generateCollationKey(java.util.List)}, this comparator acts on the
   * whole element. */
  Expression generateComparator(
      RelCollation collation);

  /** Returns a expression that yields a comparer, or null if this type
   * is comparable. */
  Expression comparer();

  /** Generates an expression that creates a record for a row, initializing
   * its fields with the given expressions. There must be one expression per
   * field.
   *
   * @param expressions Expression to initialize each field
   * @return Expression to create a row
   */
  Expression record(List<Expression> expressions);

  /** Returns the format. */
  JavaRowFormat getFormat();

  List<Expression> accessors(Expression parameter, List<Integer> argList);

  /** Returns a copy of this type that allows nulls if {@code nullable} is
   * true. */
  PhysType makeNullable(boolean nullable);
}

// End PhysType.java


text:
default: test

updatedeps:
	go get -v -u ./...

deps:
	go get -v ./...

test: deps
	go test -v -parallel 5

test-race: deps
	go test -v -race -parallel 5

test-all: vet lint test test-race

vet: deps
	go vet *.go

lint: deps
	@go get github.com/golang/lint/golint
	golint ./...

# cover shows test coverages
cover: deps
	@go get golang.org/x/tools/cmd/cover
	go test -coverprofile=cover.out
	go tool cover -html cover.out
	rm cover.out


text:
ActiveRecord::Schema.define(version: 20170316001039) do

  # These are extensions that must be enabled in order to support this database
  enable_extension "plpgsql"

  create_table "user_bills", force: :cascade do |t|
    t.integer  "user_id"
    t.integer  "bill_id"
    t.datetime "created_at", null: false
    t.datetime "updated_at", null: false
  end

  create_table "user_legislators", force: :cascade do |t|
    t.integer  "user_id"
    t.string   "legislator_id"
    t.datetime "created_at",    null: false
    t.datetime "updated_at",    null: false
  end

  create_table "user_nominations", force: :cascade do |t|
    t.integer  "user_id"
    t.integer  "nomination_id"
    t.datetime "created_at",    null: false
    t.datetime "updated_at",    null: false
  end

  create_table "users", force: :cascade do |t|
    t.string   "email",                  default: "", null: false
    t.string   "encrypted_password",     default: "", null: false
    t.string   "reset_password_token"
    t.datetime "reset_password_sent_at"
    t.datetime "remember_created_at"
    t.integer  "sign_in_count",          default: 0,  null: false
    t.datetime "current_sign_in_at"
    t.datetime "last_sign_in_at"
    t.inet     "current_sign_in_ip"
    t.inet     "last_sign_in_ip"
    t.datetime "created_at",                          null: false
    t.datetime "updated_at",                          null: false
    t.string   "username"
    t.index ["email"], name: "index_users_on_email", unique: true, using: :btree
    t.index ["reset_password_token"], name: "index_users_on_reset_password_token", unique: true, using: :btree
    t.index ["username"], name: "index_users_on_username", unique: true, using: :btree
  end

end