text:
package org.carrot2.matrix.factorization.seeding;

/**
 * Creates random seeding strategies.
 */
public class RandomSeedingStrategyFactory implements ISeedingStrategyFactory
{
    /** The random seed to be used */
    private int seed;

    /** If true, current system time will be used as the random seed */
    private boolean dateSeed;

    /**
     * Creates the factory with seeding based on current system time.
     */
    public RandomSeedingStrategyFactory()
    {
        this.dateSeed = true;
    }

    /**
     * Creates the factory with given seed value.
     */
    public RandomSeedingStrategyFactory(int seed)
    {
        this.seed = seed;
        this.dateSeed = false;
    }

    public ISeedingStrategy createSeedingStrategy()
    {
        RandomSeedingStrategy seeding;

        if (dateSeed)
        {
            seeding = new RandomSeedingStrategy();
        }
        else
        {
            seeding = new RandomSeedingStrategy(seed);
        }

        return seeding;
    }

    /**
     * Returns the random seed to be used.
     *
     */
    public int getSeed()
    {
        return seed;
    }

    /**
     * Sets the random seed to be used. Disables seeding with current system
     * time.
     *
     * @param seed
     */
    public void setSeed(int seed)
    {
        this.seed = seed;
        this.dateSeed = false;
    }

    /**
     * Returns true if the current system time is used to generate seed.
     *
     */
    public boolean getDateSeed()
    {
        return dateSeed;
    }

    /**
     * Set date seed to true to use current system time as random seed.
     *
     * @param dateSeed
     */
    public void setDateSeed(boolean dateSeed)
    {
        this.dateSeed = dateSeed;
    }

    public String toString()
    {
        return "R";
    }
}

redpajama_set_name: RedPajamaGithub


text:
package sqlline;

import java.util.Set;

/**
 * Definition of property that may be specified for SqlLine.
 *
 * @see BuiltInProperty
 */
public interface SqlLineProperty {
  String DEFAULT = "default";
  String[] BOOLEAN_VALUES = {
      Boolean.TRUE.toString(), Boolean.FALSE.toString()};

  String propertyName();

  Object defaultValue();

  boolean isReadOnly();

  boolean couldBeStored();

  Type type();

  Set<String> getAvailableValues();

  /** Property writer. */
  @FunctionalInterface
  interface Writer {
    void write(String value);
  }

  /** Data type of property. */
  enum Type {
    BOOLEAN,
    CHAR,
    FILE_PATH,
    INTEGER,
    STRING;
  }

}

// End SqlLineProperty.java


text:
{% extends "umap/content.html" %}

{% block content %}
  {% include "umap/about_summary.html" %}
{% endblock content %}


text:
Module
(Type in module ng
)

Improve this doc
Description

Interface for configuring angular modules.

Methods

config(configFn)

Use this method to register work which needs to be performed on module loading.

Parameters

configFn – {Function} –

Execute this function on module load. Useful for service
configuration.

constant(name, object)

Because the constant are fixed, they get applied before other provide methods.
See $provide.constant().

Parameters

name – {string} –

constant name

object – {*} –

Constant value.

controller(name, constructor)

See $controllerProvider.register().

Parameters

name – {string} –

Controller name.

constructor – {Function} –

Controller constructor function.

directive(name, directiveFactory)

See $compileProvider.directive().

Parameters

name – {string} –

directive name

directiveFactory – {Function} –

Factory function for creating new instance of
directives.

factory(name, providerFunction)

See $provide.factory().

Parameters

name – {string} –

service name

providerFunction – {Function} –

Function for creating new instance of the service.

filter(name, filterFactory)

See $filterProvider.register().

Parameters

name – {string} –

Filter name.

filterFactory – {Function} –

Factory function for creating new instance of filter.

provider(name, providerType)

See $provide.provider().

Parameters

name – {string} –

service name

providerType – {Function} –

Construction function for creating new instance of the service.

run(initializationFn)

Use this method to register work which should be performed when the injector is done
loading all modules.

Parameters

initializationFn – {Function} –

Execute this function after injector creation.
Useful for application initialization.

service(name, constructor)

See $provide.service().

Parameters

name – {string} –

service name

constructor – {Function} –

A constructor function that will be instantiated.

value(name, object)

See $provide.value().

Parameters

name – {string} –

service name

object – {*} –

Service instance object.

Properties

name

Returns

{string}
–
Name of the module.

requires

Holds the list of modules which the injector will load before the current module is loaded.

Returns

{Array.<string>}
–
List of module names which must be loaded before this module.


text:
[![Build Status](https://secure.travis-ci.org/zendframework/zend-mvc-plugin-identity.svg?branch=master)](https://secure.travis-ci.org/zendframework/zend-mvc-plugin-identity)
[![Coverage Status](https://coveralls.io/repos/zendframework/zend-mvc-plugin-identity/badge.svg?branch=master)](https://coveralls.io/r/zendframework/zend-mvc-plugin-identity?branch=master)

Provides a
[zend-mvc](https://zendframework.github.io/zend-mvc/) plugin (for versions 3.0
and up) that allows retrieving the current identity as provided by
[zend-authentication](https://github.com/zendframework/zend-authentication).

- File issues at https://github.com/zendframework/zend-mvc-plugin-identity/issues
- Documentation is at https://zendframework.github.io/zend-mvc-plugin-identity/


text:
require 'spec_helper'

describe "opendata_url_resource", dbscope: :example, http_server: true do
  # http.default port: 33_190
  http.default doc_root: Rails.root.join("spec", "fixtures", "opendata")

  let(:site) { cms_site }
  let!(:node_search_dataset) { create(:opendata_node_search_dataset) }
  let(:node) { create(:opendata_node_dataset) }
  let(:dataset) { create(:opendata_dataset, cur_node: node) }
  let(:license) do
    file = Fs::UploadedFile.create_from_file(Rails.root.join("spec", "fixtures", "ss", "logo.png"))
    create(:opendata_license, cur_site: site, in_file: file)
  end
  let!(:item) do
    file = Fs::UploadedFile.create_from_file(Rails.root.join("spec", "fixtures", "ss", "logo.png"))
    create(:opendata_license, cur_site: site, in_file: file)
  end
  let(:content_type) { "application/vnd.ms-excel" }
  let(:index_path) { opendata_dataset_url_resources_path site, node, dataset_id: dataset.id }
  let(:new_path) { new_opendata_dataset_url_resource_path site, node, dataset_id: dataset.id }
  let(:file_path) { Rails.root.join("spec", "fixtures", "opendata", "utf-8.csv") }
  let(:download_path) do
    opendata_dataset_url_resource_file_path site,
      node,
      dataset_id: dataset.id,
      url_resource_id: subject.id
    end

  subject { dataset.url_resources.new(attributes_for(:opendata_url_resource)) }
  before do
    subject.license_id = license.id
    subject.original_url = "http://#{http.addr}:#{http.port}/shift_jis.csv"
    subject.crawl_update = "none"
    subject.save!
  end

  it "without login" do
    visit index_path
    expect(current_path).to eq sns_login_path
  end

  it "without auth" do
    login_ss_user
    visit index_path
    expect(status_code).to eq 403
  end

  context "without auth" do
    before { login_cms_user }

    it "#index" do
      visit index_path
      expect(current_path).not_to eq sns_login_path
    end

    it "#new" do
      visit new_path
      within "form#item-form" do
        fill_in "item[original_url]", with: "http://#{http.addr}:#{http.port}/shift_jis.csv"
        fill_in "item[name]", with: "sample"
        select  item.name, from: "item_license_id"
        select  I18n.t("opendata.crawl_update.auto"), from: "item_crawl_update"
        fill_in "item[text]", with: "text"
        click_button I18n.t("views.button.save")
      end
      expect(status_code).to eq 200
      expect(current_path).not_to eq new_path
      expect(page).to have_no_css("form#item-form")
      click_on I18n.t("mongoid.attributes.opendata/url_resource.content")
      expect(current_path).not_to eq new_path
    end

    it "#download" do
      visit download_path
      expect(current_path).to eq download_path
    end

  end
end


text:
'use strict';

module.exports = function(grunt) {
  var _merge = require('lodash.merge');
  var _toArray = require('lodash.toarray');
  var alce = require('alce');
  var path = require('path');
  var handlebarsPath;
  var handlebars;
  var usedPartials = [];
  var usedHelpers = [];

  // Normalizes the input so that it is always an array for the forEach loop
  var getConfig = function(config) {
    if (!config) {
      return [];
    }

    var files = grunt.file.expand(config);

    if (files.length) {
      return files;
    }

    return [config];
  };

  // Gets the final representation of the input, whether it be object, or string
  var parseData = function(data, dontParse) {
    // grunt.file chokes on objects, so we check for it immiedietly
    if (typeof data === 'object') {
      return data;
    }

    // `data` isn't an object, so its probably a file
    try {
      // alce allows us to parse single-quote JSON (which is tehcnically invalid, and thereby chokes JSON.parse)
      data = grunt.file.read(data);
      if (!dontParse) {
        data = alce.parse(data);
      }
    }
    catch (e) {}

    return data;
  };

  // Checks if the input is a glob and if so, returns the unglobbed version of the filename
  var isGlob = function(filename) {
    if (!filename || typeof filename === 'object') {
      return;
    }

    var match = filename.match(/[^\*]*/);

    if (match[0] !== filename) {
      return match.pop();
    }
  };

  // Figures out the name of the file before any globs are used, so the globbed outputs can be generated
  var getBasename = function(filename, template, outputInInput) {
    var basename;
    var glob;

    template = Array.isArray(template) ? filename : template;
    glob = isGlob(template);
    if (outputInInput) {
      basename = _toArray(filename.split('.').pop()) ;
    } else if (glob) {
      basename = filename.slice(glob.length, filename.length).split('.');
      basename.pop();
    } else {
      basename = filename.split('/').pop().split('.');
      basename.pop();
    }
    return basename.join('.');
  };

  var mergeJson = function(source, globals) {
    var json = {}
    var fragment;

    globals.forEach(function(global) {
      if (grunt.util.kindOf(global) === 'object') {
        fragment = global;
      } else {
        if (!grunt.file.exists(global)) {
          return grunt.log.error('JSON file ' + global + ' not found.');
        } else {
          try {
            fragment = grunt.file.readJSON(global);
          }
          catch (e) {
            return grunt.fail.warn(e);
          }
        }
      }
      _merge(json, fragment);
    });

    if (typeof source === 'object') {
      _merge(json, source);
    }

    return json;
  };

  var shouldRegisterFullPaths = function(itShould, type) {

    if (itShould && typeof itShould === 'string') {
      itShould = itShould.toLowerCase().indexOf(type) === 0;
    }

    return itShould;
  };

  var getTemplateData = function(templateData, filepath, index) {
    var data;
    if (Array.isArray(templateData)) {
      data = templateData[index];
      if (data) {
        return data;
      }

      grunt.log.error('You need to assign the same number of data files as source files when using array notation.');

      return;
    }
    if (typeof templateData === 'object') {
      return templateData;
    }
    if (grunt.file.exists(templateData)) {
      return templateData;
    }
    if (isGlob(templateData) !== undefined) {
      data = filepath.replace(path.extname(filepath), path.extname(templateData));
      if (data) {
        return data;
      }

      return grunt.log.error('No matching data file for ' + filepath + '.');
    }

    return templateData;
  };

  var getDest = function(destConfig, index) {
    var dest;
    if (Array.isArray(destConfig)) {
      dest = destConfig[index];
      if (dest) {
        return dest;
      }
      grunt.log.error('You need to assign the same number of destination files as source files when using array notation.');
      return;
    }
    if (isGlob(destConfig) !== undefined) {
      dest = grunt.file.expand(destConfig)[index];
      if (dest) {
        return dest;
      }
      grunt.log.error('You need to assign the same number of destination files as source files when using glob notation.');
      return;
    }
    return destConfig;
  };

  grunt.registerMultiTask('compile-handlebars', 'Compile Handlebars templates ', function() {
    var fs = require('fs');
    var path = require('path');
    var files = this.files;
    var config = this.data;
    var helpers = getConfig(config.helpers);
    var partials = getConfig(config.partials);
    var done = this.async();

    handlebarsPath = config.handlebars ? path.resolve(config.handlebars) : 'handlebars';
    handlebars = require(handlebarsPath);

    helpers.forEach(function(helper) {
      var fullPath = helper.replace(/\.[^/.]+$/, '');
      var name = shouldRegisterFullPaths(config.registerFullPath, 'helpers') ?
        // full path, minus extention
        fullPath :
        // just the file's name
        getBasename(helper, config.helpers);

      if (handlebars.helpers[name] && usedHelpers.indexOf(fullPath) === -1) {
        grunt.log.error(name + ' is already registered, clobbering with the new value. Consider setting `registerFullPath` to true');
      } else {
        usedHelpers.push(fullPath);
      }

      handlebars.registerHelper(name, require(fs.realpathSync(helper)));
    });

    partials.forEach(function(partial) {
      var fullPath = partial.replace(/\.[^/.]+$/, '');
      var name = shouldRegisterFullPaths(config.registerFullPath, 'partials') ?
        // full path, minus extention
        fullPath :
        // just the file's name
        getBasename(partial, config.partials);

      if (handlebars.partials[name] && usedPartials.indexOf(fullPath) === -1) {
        grunt.log.error(name + ' is already registered, clobbering with the new value. Consider setting `registerFullPath` to true');
      } else {
        usedPartials.push(fullPath);
      }

      handlebars.registerPartial(name, fs.readFileSync(fs.realpathSync(partial), 'utf8'));
    });

    var compile = function(file, filepath, index) {
      var dest = file.dest || '';
      var template = filepath;
      var compiledTemplate = handlebars.compile(parseData(template, true));
      var templateData = getTemplateData(config.templateData, filepath, index);
      var outputPath = getDest(dest, index);
      var appendToFile = (outputPath === file.orig.dest && grunt.file.exists(outputPath));
      var operation = appendToFile ? 'appendFileSync' : 'writeFileSync';
      var html = '';
      var json;

      if (config.preHTML) {
        html += parseData(config.preHTML);
      }

      json = mergeJson(parseData(templateData), config.globals || []);

      html += compiledTemplate(json);

      if (config.postHTML) {
        html += parseData(config.postHTML);
      }

      // shamefully copied straight out of grunt's file command, to allow for appending
      // http://git.io/ZYGLEw
      grunt.file.mkdir(path.dirname(outputPath));

      try {
        fs[operation](outputPath, html);
        grunt.verbose.ok();
        return true;
      } catch (e) {
        grunt.verbose.error();
        throw grunt.util.error('Unable to write "' + outputPath + '" file (Error code: ' + e.code + ').', e);
      }

    };

    files.forEach(function(file) {
      if (Array.isArray(file.dest) && file.dest.length > file.src.length) {
        if (file.src.length > 1) {
          grunt.log.error('You may only have one source file when there are more destination files than source files.');
          return;
        } else {
          file.dest.forEach(function(destpath, index) {
            compile(file, file.src[0], index);
          });
        }
      } else {
        if (file.src.length > 0) {
          file.src.forEach(function(filepath, index) {
            compile(file, filepath, index);
          });
        } else {
          file.orig.src.forEach(function(template, index) {
            compile(file, template, index);
          });
        }
      }
    });

    process.nextTick(done);
  });
};


text:
using System;

namespace SFA.DAS.EmployerFinance.Models.Levy
{
    public class DasDeclaration
    {
        public string Id { get; set; }
        public decimal? LevyDueYtd { get; set; }
        public DateTime SubmissionDate { get; set; }
        public string SubmissionType { get; set; }
        public decimal LevyAllowanceForFullYear { get; set; }
        public string PayrollYear { get; set; }
        public short? PayrollMonth { get; set; }
        public bool NoPaymentForPeriod { get; set; }
        public DateTime? DateCeased { get; set; }
        public DateTime? InactiveFrom { get; set; }
        public DateTime? InactiveTo { get; set; }
        public bool EndOfYearAdjustment { get; set; }
        public decimal EndOfYearAdjustmentAmount { get; set; }
        public long SubmissionId { get; set; }
    }
}


text:
<?php
/**
 * @group Kwc_Trl
 * @group Kwc_Menu

ansicht frontend:
http://kwf.kwf.niko.vivid/kwf/kwctest/Kwc_Trl_MenuCache_Root/de
http://kwf.kwf.niko.vivid/kwf/kwctest/Kwc_Trl_MenuCache_Root/de/home_de/test
http://kwf.kwf.niko.vivid/kwf/kwctest/Kwc_Trl_MenuCache_Root/en
http://kwf.kwf.niko.vivid/kwf/kwctest/Kwc_Trl_MenuCache_Root/en/home_en/test
 */
class Kwc_Trl_MenuCache_Test extends Kwc_TestAbstract
{
    public function setUp()
    {
        parent::setUp('Kwc_Trl_MenuCache_Root');
    }

    public function testComponentClasses()
    {
        $this->assertEquals($this->_root->getComponentById('root-mainMenu'), null);
        $this->assertEquals($this->_root->getComponentById('root-mainMenu-subMenu'), null);

        $this->assertEquals($this->_root->getComponentById('root-master-mainMenu')->componentClass, 'Kwc_Menu_OtherCategoryChild_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('root-master-mainMenu-subMenu'), null);

        $this->assertEquals($this->_root->getComponentById('root-master-main-mainMenu')->componentClass, 'Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('root-master-main-mainMenu-subMenu')->componentClass, 'Kwc_Basic_None_Component');

        $this->assertEquals($this->_root->getComponentById('1-mainMenu')->componentClass, 'Kwc_Menu_ParentMenu_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('1-mainMenu-subMenu')->componentClass, 'Kwc_Trl_MenuCache_MainMenu_SubMenu_Component');

        $this->assertEquals($this->_root->getComponentById('2-mainMenu')->componentClass, 'Kwc_Menu_ParentMenu_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('2-mainMenu-subMenu')->componentClass, 'Kwc_Menu_ParentMenu_Component.Kwc_Trl_MenuCache_MainMenu_SubMenu_Component');

        $this->assertEquals($this->_root->getComponentById('4-mainMenu')->componentClass, 'Kwc_Menu_ParentContent_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('4-mainMenu-subMenu'), null);
    }

    public function testComponentClassesBottom()
    {
        $this->assertEquals($this->_root->getComponentById('root-master-bottom-mainMenu')->componentClass, 'Kwc_Menu_OtherCategory_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('root-master-bottom-mainMenu-subMenu'), null);

        $this->assertEquals($this->_root->getComponentById('5-mainMenu')->componentClass, 'Kwc_Menu_ParentContent_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('5-mainMenu-subMenu'), null);

        $this->assertEquals($this->_root->getComponentById('6-mainMenu')->componentClass, 'Kwc_Menu_ParentContent_Component.Kwc_Trl_MenuCache_MainMenu_Component');
        $this->assertEquals($this->_root->getComponentById('6-mainMenu-subMenu'), null);
    }

    public function testMenuDeNameChanged()
    {
        $c = $this->_root->getComponentById('1-mainMenu');
        $html = $c->render();
        $this->assertContains('Home de', $html);
        $this->assertContains('Test', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_PagesTestModel')
            ->getRow(2);
        $row->name = 'Testx';
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Home de', $html);
        $this->assertContains('Testx', $html);
    }

    public function testMenuEnNameChanged()
    {
        $c = $this->_root->getComponentById('root-en-main_1-mainMenu');

        $html = $c->render();
        $this->assertContains('Home en', $html);
        $this->assertContains('Test', $html);
        $this->assertContains('Test2 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_2');
        $row->name = 'Testxen';
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Home en', $html);
        $this->assertContains('Testxen', $html);
    }

    public function testMenuOtherCategoryDeNameChanged()
    {
        $c = $this->_root->getComponentById('root-master-bottom-mainMenu');
        $html = $c->render();
        $this->assertContains('Home de', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_PagesTestModel')
            ->getRow(1);
        $row->name = 'Homex de';
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Homex de', $html);
    }

    public function testMenuOtherCategoryEnNameChanged()
    {
        $c = $this->_root->getComponentById('root-en-bottom-mainMenu');
        $html = $c->render();
        $this->assertContains('Home en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_1');
        $row->name = 'Homex en';
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Homex en', $html);
    }

    public function testMenuOtherCategoryEnShow()
    {
        $c = $this->_root->getComponentById('root-en-bottom-mainMenu');
        $html = $c->render();
        $this->assertNotContains('Test7 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = true;
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Test7 en', $html);
    }

    public function testMenuOtherCategoryEnHide()
    {
        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = true;
        $row->save();

        $c = $this->_root->getComponentById('root-en-bottom-mainMenu');
        $html = $c->render();
        $this->assertContains('Test7 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = false;
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertNotContains('Test7 en', $html);
    }

    public function testParentMenuEnShow()
    {
        $c = $this->_root->getComponentById('root-en-main_1-mainMenu');
        $html = $c->render();
        $this->assertNotContains('Test7 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = true;
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Test7 en', $html);
    }

    public function testParentMenuEnHide()
    {
        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = true;
        $row->save();

        $c = $this->_root->getComponentById('root-en-main_1-mainMenu');

        $html = $c->render();
        $this->assertContains('Test7 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = false;
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertNotContains('Test7 en', $html);
    }

    public function testMenuEnShow()
    {
        $c = $this->_root->getComponentById('root-en-main-mainMenu');
        $html = $c->render();
        $this->assertNotContains('Test7 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = true;
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertContains('Test7 en', $html);
    }

    public function testMenuEnHide()
    {
        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = true;
        $row->save();

        $c = $this->_root->getComponentById('root-en-main-mainMenu');

        $html = $c->render();
        $this->assertContains('Test7 en', $html);

        $row = Kwf_Model_Abstract::getInstance('Kwc_Trl_MenuCache_Category_Trl_PagesTrlTestModel')
            ->getRow('root-en-main_7');
        $row->visible = false;
        $row->save();

        $this->_process();

        $html = $c->render();
        $this->assertNotContains('Test7 en', $html);
    }
}


text:
(function(window) {
    function Validate() {
        this.isValid = false;
        this.message = {
            register: '请输入正确的注册信息',
            login: '请输入正确的登录信息'
        }
    }

    Validate.prototype.register = function(user) {
        if (user.name && user.password && user.repeatPassword && (user.password === user.repeatPassword)) {
            this.isValid = true;
        } else {
            alert(this.message.register);
        }

        return this.isValid;
    }

    Validate.prototype.login = function(user) {
        if (user.name && user.password) {
            this.isValid = true;
        } else {
            alert(this.message.login);
        }

        return this.isValid;
    }

    function validateSingleton() {
        var validate = null;
        return function() {
            if (!validate) {
                validate = new Validate();
            }

            return validate;
        }
    }

    window.Validate = Validate;
    window.validateSingleton = validateSingleton;
})(window);


text:
.centered {
    margin: 0 auto;
    text-align: center;
    width: 60%;
}
h1.color { text-align:center; color:red; }


text:
// Copyright 2003-2012 Nicholas J. Kain <njkain at gmail dot com>
// SPDX-License-Identifier: MIT
#ifndef NCRON_SCHED_HPP_
#define NCRON_SCHED_HPP_
#include <string>
#include <vector>
#include <memory>
#include <sys/time.h>
#include <sys/resource.h>

struct cronentry_t
{
    cronentry_t() : id(0), exectime(0), lasttime(0), interval(0),
                    numruns(0), maxruns(0), journal(false) {}
    typedef std::vector<std::pair<int,int>> cst_list;
    unsigned int id;
    time_t exectime;        /* time at which we will execute in the future */
    time_t lasttime;        /* time that the job last ran */
    unsigned int interval;  /* min interval between executions in seconds */
    unsigned int numruns;   /* number of times a job has run */
    unsigned int maxruns;   /* max # of times a job will run, 0 = nolim */
    bool journal;
    std::string command;
    std::string args;

    cst_list month;       /* 1-12, l=0  is wildcard, h=l is no range */
    cst_list day;         /* 1-31, l=0  is wildcard, h=l is no range */
    cst_list weekday;     /* 1-7,  l=0  is wildcard, h=l is no range */
    cst_list hour;        /* 0-23, l=24 is wildcard, h=l is no range */
    cst_list minute;      /* 0-59, l=60 is wildcard, h=l is no range */

    inline bool operator<(const cronentry_t &o) const {
        return exectime < o.exectime;
    }
    void exec(const struct timespec &ts);
private:
    void set_next_time();
};

struct StackItem {
    StackItem(std::unique_ptr<cronentry_t> &&v) : ce(std::move(v)) {
        exectime = ce ? ce->exectime : 0;
    }
    time_t exectime;
    std::unique_ptr<cronentry_t> ce;
};

static inline bool GtCronEntry(const StackItem &a,
                               const StackItem &b) {
    return a.exectime > b.exectime;
}

void set_initial_exectime(cronentry_t &entry);
time_t get_next_time(const cronentry_t &entry);
void save_stack(std::string_view file,
                const std::vector<StackItem> &stack,
                const std::vector<StackItem> &deadstack);

#endif


text:
package com.amazonaws.services.kinesisvideo.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.services.kinesisvideo.model.*;

import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;

/**
 * ImageMarshaller
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class ImageMarshaller {

    private static final MarshallingInfo<java.util.Date> TIMESTAMP_BINDING = MarshallingInfo.builder(MarshallingType.DATE)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("TimeStamp").timestampFormat("unixTimestamp").build();
    private static final MarshallingInfo<String> ERROR_BINDING = MarshallingInfo.builder(MarshallingType.STRING).marshallLocation(MarshallLocation.PAYLOAD)
            .marshallLocationName("Error").build();
    private static final MarshallingInfo<String> IMAGECONTENT_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("ImageContent").build();

    private static final ImageMarshaller instance = new ImageMarshaller();

    public static ImageMarshaller getInstance() {
        return instance;
    }

    /**
     * Marshall the given parameter object.
     */
    public void marshall(Image image, ProtocolMarshaller protocolMarshaller) {

        if (image == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        try {
            protocolMarshaller.marshall(image.getTimeStamp(), TIMESTAMP_BINDING);
            protocolMarshaller.marshall(image.getError(), ERROR_BINDING);
            protocolMarshaller.marshall(image.getImageContent(), IMAGECONTENT_BINDING);
        } catch (Exception e) {
            throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
        }
    }

}


text:
namespace Microsoft.Azure.Management.RedisEnterprise
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using System.Collections;
    using System.Collections.Generic;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// PrivateEndpointConnectionsOperations operations.
    /// </summary>
    public partial interface IPrivateEndpointConnectionsOperations
    {
        /// <summary>
        /// Lists all the private endpoint connections associated with the
        /// RedisEnterprise cluster.
        /// </summary>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='clusterName'>
        /// The name of the RedisEnterprise cluster.
        /// </param>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse<IEnumerable<PrivateEndpointConnection>>> ListWithHttpMessagesAsync(string resourceGroupName, string clusterName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
        /// <summary>
        /// Gets the specified private endpoint connection associated with the
        /// RedisEnterprise cluster.
        /// </summary>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='clusterName'>
        /// The name of the RedisEnterprise cluster.
        /// </param>
        /// <param name='privateEndpointConnectionName'>
        /// The name of the private endpoint connection associated with the
        /// Azure resource
        /// </param>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse<PrivateEndpointConnection>> GetWithHttpMessagesAsync(string resourceGroupName, string clusterName, string privateEndpointConnectionName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
        /// <summary>
        /// Updates the state of the specified private endpoint connection
        /// associated with the RedisEnterprise cluster.
        /// </summary>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='clusterName'>
        /// The name of the RedisEnterprise cluster.
        /// </param>
        /// <param name='privateEndpointConnectionName'>
        /// The name of the private endpoint connection associated with the
        /// Azure resource
        /// </param>
        /// <param name='properties'>
        /// The private endpoint connection properties.
        /// </param>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse<PrivateEndpointConnection>> PutWithHttpMessagesAsync(string resourceGroupName, string clusterName, string privateEndpointConnectionName, PrivateEndpointConnection properties, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
        /// <summary>
        /// Deletes the specified private endpoint connection associated with
        /// the RedisEnterprise cluster.
        /// </summary>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='clusterName'>
        /// The name of the RedisEnterprise cluster.
        /// </param>
        /// <param name='privateEndpointConnectionName'>
        /// The name of the private endpoint connection associated with the
        /// Azure resource
        /// </param>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse> DeleteWithHttpMessagesAsync(string resourceGroupName, string clusterName, string privateEndpointConnectionName, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
        /// <summary>
        /// Updates the state of the specified private endpoint connection
        /// associated with the RedisEnterprise cluster.
        /// </summary>
        /// <param name='resourceGroupName'>
        /// The name of the resource group. The name is case insensitive.
        /// </param>
        /// <param name='clusterName'>
        /// The name of the RedisEnterprise cluster.
        /// </param>
        /// <param name='privateEndpointConnectionName'>
        /// The name of the private endpoint connection associated with the
        /// Azure resource
        /// </param>
        /// <param name='properties'>
        /// The private endpoint connection properties.
        /// </param>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="ErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse<PrivateEndpointConnection>> BeginPutWithHttpMessagesAsync(string resourceGroupName, string clusterName, string privateEndpointConnectionName, PrivateEndpointConnection properties, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android"
    android:duration="300">

    <alpha
        android:fromAlpha="0.2"
        android:toAlpha="1" />
    <scale
        android:fromXScale="1"
        android:fromYScale="0.2"
        android:pivotX="50%"
        android:pivotY="0"
        android:toXScale="1"
        android:toYScale="1" />

</set>


text:
======
 DIPY
======

.. image:: https://codecov.io/gh/nipy/dipy/branch/master/graph/badge.svg
  :target: https://codecov.io/gh/nipy/dipy

DIPY is a python toolbox for analysis of MR diffusion imaging.

DIPY is for research only; please do not use results from DIPY for
clinical decisions.

Website
=======

Current information can always be found from the DIPY website - http://dipy.org

Mailing Lists
=============

Please see the developers' list at
https://mail.python.org/mailman/listinfo/neuroimaging

Please see the users' forum at
https://neurostars.org

Please join the gitter chatroom `here <https://gitter.im/nipy/dipy>`_.

Code
====

You can find our sources and single-click downloads:

* `Main repository`_ on Github.
* Documentation_ for all releases and current development tree.
* Download as a tar/zip file the `current trunk`_.

.. _main repository: http://github.com/nipy/dipy
.. _Documentation: http://dipy.org
.. _current trunk: http://github.com/nipy/dipy/archives/master

License
=======

DIPY is licensed under the terms of the BSD license.
Please see the LICENSE file in the dipy distribution.

DIPY uses other libraries also licensed under the BSD or the
MIT licenses, with the only exception of the SHORE module which
optionally uses the cvxopt library. Cvxopt is licensed
under the GPL license.