text:
using Google.Cloud.Tools.ApiIndex.V1;
using Google.Cloud.Tools.Common;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Google.Cloud.Tools.ReleaseManager
{
    /// <summary>
    /// Tool to add a new library based on the service config (and protos) for an API.
    /// </summary>
    public class AddCommand : CommandBase
    {
        public AddCommand()
            : base("add", "Adds an API to the API catalog", "id")
        {
        }

        protected override void ExecuteImpl(string[] args)
        {
            string id = args[0];

            var catalog = ApiCatalog.Load();
            if (catalog.Apis.Any(api => api.Id == id))
            {
                throw new UserErrorException($"API {id} already exists in the API catalog.");
            }
            var root = DirectoryLayout.DetermineRootDirectory();
            var googleapis = Path.Combine(root, "googleapis");
            var apiIndex = ApiIndex.V1.Index.LoadFromGoogleApis(googleapis);

            var targetApi = apiIndex.Apis.FirstOrDefault(api => api.DeriveCSharpNamespace() == id);
            if (targetApi is null)
            {
                var lowerWithoutCloud = id.Replace(".Cloud", "").ToLowerInvariant();
                var possibilities = apiIndex.Apis
                    .Select(api => api.DeriveCSharpNamespace())
                    .Where(ns => ns.Replace(".Cloud", "").ToLowerInvariant() == lowerWithoutCloud);
                throw new UserErrorException(
                    $"No service found for '{id}'.{Environment.NewLine}Similar possibilities (check options?): {string.Join(", ", possibilities)}");
            }

            var api = new ApiMetadata
            {
                Id = id,
                ProtoPath = targetApi.Directory,
                ProductName = targetApi.Title.EndsWith(" API") ? targetApi.Title[..^4] : targetApi.Title,
                Description = targetApi.Description,
                Version = "1.0.0-beta00",
                Type = ApiType.Grpc,
                Generator = GeneratorType.Micro,
                // Let's not include test dependencies, which are rarely useful.
                TestDependencies = null,
                // Translate the host name into the "short name", e.g. bigquery.googleapis.com => bigquery
                ShortName = targetApi.HostName.Split('.').First(),
                // The service config file is always populated in the index, so we don't need to translate empty to null here.
                ServiceConfigFile = targetApi.ConfigFile
            };

            // Add dependencies discovered via the proto imports.
            // This doesn't fail on any dependencies that aren't found - we could tighten this up later
            // by knowing about common protos, for example.
            var apisByProtoPath = catalog.Apis.Where(api => api.ProtoPath is object).ToDictionary(api => api.ProtoPath);
            foreach (var import in targetApi.ImportDirectories)
            {
                if (apisByProtoPath.TryGetValue(import, out var dependency))
                {
                    api.Dependencies.Add(dependency.Id, dependency.Version);
                }
            }

            // Add mixin dependencies discovered via APIs listed in the service config file.
            // This *does* fail if we can't find the API, as that would indicate a general issue.
            foreach (var mixin in targetApi.GetMixinPackages())
            {
                api.Dependencies[mixin] = catalog[mixin].Version;
            }

            // Now work out what the new API metadata looks like in JSON.
            var serializer = new JsonSerializer
            {
                NullValueHandling = NullValueHandling.Ignore,
                Converters = { new StringEnumConverter(new CamelCaseNamingStrategy()) },
                ContractResolver = new DefaultContractResolver { NamingStrategy = new CamelCaseNamingStrategy() }
            };
            api.Json = JToken.FromObject(api, serializer);

            var followingApi = catalog.Apis.FirstOrDefault(api => string.Compare(api.Id, id, StringComparison.Ordinal) > 0);
            if (followingApi is object)
            {
                followingApi.Json.AddBeforeSelf(api.Json);
            }
            else
            {
                // Looks like this API will be last in the list.
                catalog.Apis.Last().Json.AddAfterSelf(api.Json);
            }

            // Done. Let's write out the catalog and display what we've done.
            File.WriteAllText(ApiCatalog.CatalogPath, catalog.FormatJson());
            Console.WriteLine($"Added {id} to the API catalog with the following configuration:");
            Console.WriteLine(api.Json.ToString(Formatting.Indented));
        }
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<module>
  <inherits name="com.google.gwt.user.User" />
  <inherits name="com.google.gwt.user.theme.clean.Clean" />
  <inherits name="com.google.web.bindery.requestfactory.RequestFactory" />

  <source path="" />

  <entry-point class="it.pkg.Basic" />

  <!-- Only support recent browsers -->
  <set-property name="user.agent" value="gecko1_8,safari" />
</module>

redpajama_set_name: RedPajamaGithub


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

    <meta content="text/html; charset=ISO-8859-1" http-equiv="content-type"/>
    <title>WSO2 Carbon Server Home</title>
    <link href="../../admin/css/documentation.css" rel="stylesheet"
          type="text/css" media="all"/>

    WSO2 Carbon Server Home Page

 When you log on to
    the WSO2 Carbon Server, the home page displays information about
    the server hosting envrionment, the JVM configuration information, the
    deployed operating system and the logged in user information in four
    separate tables.

Server

            Host

            The server IP address

            Server URL

            URL of the hosted services

            Server Start Time

            The server start time, displayed precisely to the second.

            System Up Time

            The up time of the system, displayed precisely to the second.

            Version

            Server version

            Repository Location

            The respository location folder used by Carbon.

Operating System

            OS Name

        The version of the operating system used by the server

            OS Version

        The version of the operating system

Operating System User

            Country

            The locale of the operating system user running the Carbon server.

            Home

            The home directory of the operating system user running Carbon.

            Name

            The name of the operating system user running Carbon.

            Timezone

            The timezone of the operating system user running Carbon.

Java VM

            Java Home

            The location of the Java runtime library

            Java Runtime Name

            The Java runtime name ( For example : Java(TM) 2 Runtime
            Environment, Standard Edition )

            Java Version

            The version of the Java runtime library

            Java Vendor

            The Java runtime vendor

            Java VM Version

        The version of the Java virtual machine

Registry

            Registry Type

            Values can be 'Embedded' or 'Remote'. Indicates whether this server uses
            an embedded Registry or remote Registry

            Registry Database Name

            Name of the Registry DB

            Registry Database Version

            Version of the Registry DB

            Database Driver Name

            Name of the JDBC driver used

            Database Driver Version

            Version of the JDBC driver used

            Database URL

            JDBC URL of the Embedded Registry DB


text:
""""
    Here is the RawInput class who handles computer microphone interactions
"""

from ctypes import *
import pyaudio

# RATE = 44100
# FPB = 2048
# CHUNK = 1024

class RawInput:

    def __init__(self):
        """
        Initiate audio ports with PyAudio instance
        """
        # Define our error handler type for ALSA
        # ERROR_HANDLER_FUNC = CFUNCTYPE(None, c_char_p, c_int, c_char_p, c_int, c_char_p)
        # def py_error_handler(filename, line, function, err, fmt):
        #     pass
        # c_error_handler = ERROR_HANDLER_FUNC(py_error_handler)
        # asound = cdll.LoadLibrary('libasound.so')
        # Set error handler
        # asound.snd_lib_error_set_handler(c_error_handler)
        self.record = []
        self.done = False
        self.listening = True
        self.audio = pyaudio.PyAudio()

    def __del__(self):
        """
        Destroy the instance of PyAudio
        """
        self.audio.terminate()

    #Setting reading variables to start/stop vocal recording
    def start(self):
        self.record = []
        self.done = False
        self.listening = True

    def stop(self):
        self.listening = False

    # Reading vocal entry
    def read(self):
        self.start()
        try:
            stream = self.audio.open(format=pyaudio.paInt16,
                                     channels=1,
                                     rate=16000,
                                     input=True,
                                     frames_per_buffer=2048)
            while self.listening:
                data = stream.read(2048)
                self.record.append(data)
            stream.close()
        except:
            print ("Error while reading microphone")
        self.done = True


text:
package tabletserver

import (
	"fmt"
	"io"
	"strings"
	"sync"
	"time"

	"github.com/spf13/pflag"

	"vitess.io/vitess/go/vt/servenv"

	"vitess.io/vitess/go/sqltypes"

	"vitess.io/vitess/go/vt/sqlparser"

	"vitess.io/vitess/go/vt/dbconfigs"

	"vitess.io/vitess/go/mysql"
	"vitess.io/vitess/go/timer"
	"vitess.io/vitess/go/vt/vttablet/tabletserver/connpool"

	"context"

	"google.golang.org/protobuf/proto"

	"vitess.io/vitess/go/history"
	"vitess.io/vitess/go/sync2"
	"vitess.io/vitess/go/vt/log"
	querypb "vitess.io/vitess/go/vt/proto/query"
	topodatapb "vitess.io/vitess/go/vt/proto/topodata"
	vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc"
	"vitess.io/vitess/go/vt/vterrors"
	"vitess.io/vitess/go/vt/vttablet/tabletmanager/vreplication"
	"vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv"
)

var (
	// blpFunc is a legaacy feature.
	// TODO(sougou): remove after legacy resharding worflows are removed.
	blpFunc = vreplication.StatusSummary

	errUnintialized = "tabletserver uninitialized"

	streamHealthBufferSize = uint(20)
)

func init() {
	servenv.OnParseFor("vtcombo", registerHealthStreamerFlags)
	servenv.OnParseFor("vttablet", registerHealthStreamerFlags)
}

func registerHealthStreamerFlags(fs *pflag.FlagSet) {
	fs.UintVar(&streamHealthBufferSize, "stream_health_buffer_size", streamHealthBufferSize, "max streaming health entries to buffer per streaming health client")
}

// healthStreamer streams health information to callers.
type healthStreamer struct {
	stats              *tabletenv.Stats
	degradedThreshold  time.Duration
	unhealthyThreshold sync2.AtomicDuration

	mu      sync.Mutex
	ctx     context.Context
	cancel  context.CancelFunc
	clients map[chan *querypb.StreamHealthResponse]struct{}
	state   *querypb.StreamHealthResponse

	history *history.History

	ticks                  *timer.Timer
	dbConfig               dbconfigs.Connector
	conns                  *connpool.Pool
	initSuccess            bool
	signalWhenSchemaChange bool
}

func newHealthStreamer(env tabletenv.Env, alias *topodatapb.TabletAlias) *healthStreamer {
	var newTimer *timer.Timer
	var pool *connpool.Pool
	if env.Config().SignalWhenSchemaChange {
		reloadTime := env.Config().SignalSchemaChangeReloadIntervalSeconds.Get()
		newTimer = timer.NewTimer(reloadTime)
		// We need one connection for the reloader.
		pool = connpool.NewPool(env, "", tabletenv.ConnPoolConfig{
			Size:               1,
			IdleTimeoutSeconds: env.Config().OltpReadPool.IdleTimeoutSeconds,
		})
	}
	return &healthStreamer{
		stats:              env.Stats(),
		degradedThreshold:  env.Config().Healthcheck.DegradedThresholdSeconds.Get(),
		unhealthyThreshold: sync2.NewAtomicDuration(env.Config().Healthcheck.UnhealthyThresholdSeconds.Get()),
		clients:            make(map[chan *querypb.StreamHealthResponse]struct{}),

		state: &querypb.StreamHealthResponse{
			Target:      &querypb.Target{},
			TabletAlias: alias,
			RealtimeStats: &querypb.RealtimeStats{
				HealthError: errUnintialized,
			},
		},

		history:                history.New(5),
		ticks:                  newTimer,
		conns:                  pool,
		signalWhenSchemaChange: env.Config().SignalWhenSchemaChange,
	}
}

func (hs *healthStreamer) InitDBConfig(target *querypb.Target, cp dbconfigs.Connector) {
	hs.state.Target = proto.Clone(target).(*querypb.Target)
	hs.dbConfig = cp
}

func (hs *healthStreamer) Open() {
	hs.mu.Lock()
	defer hs.mu.Unlock()

	if hs.cancel != nil {
		return
	}
	hs.ctx, hs.cancel = context.WithCancel(context.Background())
	if hs.conns != nil {
		// if we don't have a live conns object, it means we are not configured to signal when the schema changes
		hs.conns.Open(hs.dbConfig, hs.dbConfig, hs.dbConfig)
		hs.ticks.Start(func() {
			if err := hs.reload(); err != nil {
				log.Errorf("periodic schema reload failed in health stream: %v", err)
			}
		})

	}

}

func (hs *healthStreamer) Close() {
	hs.mu.Lock()
	defer hs.mu.Unlock()

	if hs.cancel != nil {
		if hs.ticks != nil {
			hs.ticks.Stop()
			hs.conns.Close()
		}
		hs.cancel()
		hs.cancel = nil
	}
}

func (hs *healthStreamer) Stream(ctx context.Context, callback func(*querypb.StreamHealthResponse) error) error {
	ch, hsCtx := hs.register()
	if hsCtx == nil {
		return vterrors.Errorf(vtrpcpb.Code_UNAVAILABLE, "tabletserver is shutdown")
	}
	defer hs.unregister(ch)

	// trigger the initial schema reload
	if hs.signalWhenSchemaChange {
		hs.ticks.Trigger()
	}

	for {
		select {
		case <-ctx.Done():
			return nil
		case <-hsCtx.Done():
			return vterrors.Errorf(vtrpcpb.Code_UNAVAILABLE, "tabletserver is shutdown")
		case shr, ok := <-ch:
			if !ok {
				return vterrors.Errorf(vtrpcpb.Code_RESOURCE_EXHAUSTED, "stream health buffer overflowed. client should reconnect for up-to-date status")
			}
			if err := callback(shr); err != nil {
				if err == io.EOF {
					return nil
				}
				return err
			}
		}
	}
}

func (hs *healthStreamer) register() (chan *querypb.StreamHealthResponse, context.Context) {
	hs.mu.Lock()
	defer hs.mu.Unlock()

	if hs.cancel == nil {
		return nil, nil
	}

	ch := make(chan *querypb.StreamHealthResponse, streamHealthBufferSize)
	hs.clients[ch] = struct{}{}

	// Send the current state immediately.
	ch <- proto.Clone(hs.state).(*querypb.StreamHealthResponse)
	return ch, hs.ctx
}

func (hs *healthStreamer) unregister(ch chan *querypb.StreamHealthResponse) {
	hs.mu.Lock()
	defer hs.mu.Unlock()

	delete(hs.clients, ch)
}

func (hs *healthStreamer) ChangeState(tabletType topodatapb.TabletType, terTimestamp time.Time, lag time.Duration, err error, serving bool) {
	hs.mu.Lock()
	defer hs.mu.Unlock()

	hs.state.Target.TabletType = tabletType
	if tabletType == topodatapb.TabletType_PRIMARY {
		hs.state.TabletExternallyReparentedTimestamp = terTimestamp.Unix()
	} else {
		hs.state.TabletExternallyReparentedTimestamp = 0
	}
	if err != nil {
		hs.state.RealtimeStats.HealthError = err.Error()
	} else {
		hs.state.RealtimeStats.HealthError = ""
	}
	hs.state.RealtimeStats.ReplicationLagSeconds = uint32(lag.Seconds())
	hs.state.Serving = serving

	hs.state.RealtimeStats.FilteredReplicationLagSeconds, hs.state.RealtimeStats.BinlogPlayersCount = blpFunc()
	hs.state.RealtimeStats.Qps = hs.stats.QPSRates.TotalRate()

	shr := proto.Clone(hs.state).(*querypb.StreamHealthResponse)

	hs.broadCastToClients(shr)
	hs.history.Add(&historyRecord{
		Time:       time.Now(),
		serving:    shr.Serving,
		tabletType: shr.Target.TabletType,
		lag:        lag,
		err:        err,
	})
}

func (hs *healthStreamer) broadCastToClients(shr *querypb.StreamHealthResponse) {
	for ch := range hs.clients {
		select {
		case ch <- shr:
		default:
			// We can't block this state change on broadcasting to a streaming health client, but we
			// also don't want to silently fail to inform a streaming health client of a state change
			// because it can allow a vtgate to get wedged in a state where it's wrong about whether
			// a tablet is healthy and can't automatically recover (see
			//  https://github.com/vitessio/vitess/issues/5445). If we can't send a health update
			// to this client we'll close() the channel which will ultimate fail the streaming health
			// RPC and cause vtgates to reconnect.
			//
			// An alternative approach for streaming health would be to force a periodic broadcast even
			// when there hasn't been an update and/or move away from using channels toward a model where
			// old updates can be purged from the buffer in favor of more recent updates (since only the
			// most recent health state really matters to gates).
			log.Warning("A streaming health buffer is full. Closing the channel")
			close(ch)
			delete(hs.clients, ch)
		}
	}
}

func (hs *healthStreamer) AppendDetails(details []*kv) []*kv {
	hs.mu.Lock()
	defer hs.mu.Unlock()
	if hs.state.Target.TabletType == topodatapb.TabletType_PRIMARY {
		return details
	}
	sbm := time.Duration(hs.state.RealtimeStats.ReplicationLagSeconds) * time.Second
	class := healthyClass
	switch {
	case sbm > hs.unhealthyThreshold.Get():
		class = unhealthyClass
	case sbm > hs.degradedThreshold:
		class = unhappyClass
	}
	details = append(details, &kv{
		Key:   "Replication Lag",
		Class: class,
		Value: fmt.Sprintf("%ds", hs.state.RealtimeStats.ReplicationLagSeconds),
	})
	if hs.state.RealtimeStats.HealthError != "" {
		details = append(details, &kv{
			Key:   "Replication Error",
			Class: unhappyClass,
			Value: hs.state.RealtimeStats.HealthError,
		})
	}

	return details
}

func (hs *healthStreamer) SetUnhealthyThreshold(v time.Duration) {
	hs.unhealthyThreshold.Set(v)
	shr := proto.Clone(hs.state).(*querypb.StreamHealthResponse)
	for ch := range hs.clients {
		select {
		case ch <- shr:
		default:
			log.Info("Resetting health streamer clients due to unhealthy threshold change")
			close(ch)
			delete(hs.clients, ch)
		}
	}
}

// reload reloads the schema from the underlying mysql
func (hs *healthStreamer) reload() error {
	hs.mu.Lock()
	defer hs.mu.Unlock()
	// Schema Reload to happen only on primary.
	if hs.state.Target.TabletType != topodatapb.TabletType_PRIMARY {
		return nil
	}

	ctx := hs.ctx
	conn, err := hs.conns.Get(ctx, nil)
	if err != nil {
		return err
	}
	defer conn.Recycle()

	if !hs.initSuccess {
		hs.initSuccess, err = hs.InitSchemaLocked(conn)
		if err != nil {
			return err
		}
	}

	var tables []string
	var tableNames []string

	callback := func(qr *sqltypes.Result) error {
		for _, row := range qr.Rows {
			table := row[0].ToString()
			tables = append(tables, table)

			escapedTblName := sqlparser.String(sqlparser.NewStrLiteral(table))
			tableNames = append(tableNames, escapedTblName)
		}

		return nil
	}
	alloc := func() *sqltypes.Result { return &sqltypes.Result{} }
	bufferSize := 1000
	err = conn.Stream(ctx, mysql.DetectSchemaChange, callback, alloc, bufferSize, 0)
	if err != nil {
		return err
	}

	// If no change detected, then return
	if len(tables) == 0 {
		return nil
	}

	tableNamePredicate := fmt.Sprintf("table_name IN (%s)", strings.Join(tableNames, ", "))
	del := fmt.Sprintf("%s AND %s", mysql.ClearSchemaCopy, tableNamePredicate)
	upd := fmt.Sprintf("%s AND %s", mysql.InsertIntoSchemaCopy, tableNamePredicate)

	// Reload the schema in a transaction.
	_, err = conn.Exec(ctx, "begin", 1, false)
	if err != nil {
		return err
	}
	defer conn.Exec(ctx, "rollback", 1, false)

	_, err = conn.Exec(ctx, del, 1, false)
	if err != nil {
		return err
	}

	_, err = conn.Exec(ctx, upd, 1, false)
	if err != nil {
		return err
	}

	_, err = conn.Exec(ctx, "commit", 1, false)
	if err != nil {
		return err
	}

	hs.state.RealtimeStats.TableSchemaChanged = tables
	shr := proto.Clone(hs.state).(*querypb.StreamHealthResponse)
	hs.broadCastToClients(shr)
	hs.state.RealtimeStats.TableSchemaChanged = nil

	return nil
}

func (hs *healthStreamer) InitSchemaLocked(conn *connpool.DBConn) (bool, error) {
	for _, query := range mysql.VTDatabaseInit {
		_, err := conn.Exec(hs.ctx, query, 1, false)
		if err != nil {
			return false, err
		}
	}

	return true, nil
}


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ExtractVariables async="false" continueOnError="false" enabled="true" name="EV-GetAllAccountsForCustomer">
    <DisplayName>EV-GetAllAccountsForCustomer</DisplayName>
    <JSONPayload>
        <Variable name="listOfAllAccounts">
            <JSONPath>$.[?(@.customer == {customerId})].accounts</JSONPath>
        </Variable>
    </JSONPayload>
    <Source clearPayload="false">listOfAllAccountsByCustomer</Source>
</ExtractVariables>


text:
"use strict";
let fs = require('fs');
let path = require('path');
let spawn = require('child_process').spawn;

let async = require('async');
let fse = require('fs-extra');
let walk = require('walk').walk;

let sourceDir = path.join(__dirname, '..', 'node_modules', 'openlayers', 'src');
let infoPath = path.join(__dirname, '..', '.build', 'info.json');
let jsdoc = path.join(__dirname, '..', 'node_modules', '.bin', 'jsdoc');
let jsdocConfig = path.join(__dirname, '..', 'buildtools', 'jsdoc', 'info',
    'conf.json');

/**
 * Create a new metadata object.
 * @return {Object} New metadata.
 */
function createInfo() {
  return {symbols: [], defines: []};
}

/**
 * Read symbols & defines metadata from info file.
 * @param {function(Error, Object, Date)} callback Callback called with any
 *     error, the metadata, and the mtime of the info file.
 */
function readInfo(callback) {
  fs.stat(infoPath, function(err, stats) {
    if (err) {
      if (err.code === 'ENOENT') {
        callback(null, createInfo(), new Date(0));
      } else {
        callback(err);
      }
    } else {
      fs.readFile(infoPath, function(err, data) {
        if (err) {
          callback(err);
        } else {
          callback(null, JSON.parse(String(data)), stats.mtime);
        }
      });
    }
  });
}

function makeUnique(array) {
  let values = {};
  array.forEach(function(value) {
    values[value] = true;
  });
  return Object.keys(values);
}

/**
 * Generate a list of .js paths in the source directory that are newer than
 * the info file.
 * @param {Object} info Symbol and defines metadata.
 * @param {Date} date Modification time of info file.
 * @param {function(Error, Object, Array.<string>)} callback Called with any
 *     error, the info object, and the array of newer source paths.
 */
function getNewer(info, date, callback) {
  let allPaths = [];
  let newerPaths = [];

  let walker = walk(sourceDir);
  walker.on('file', function(root, stats, next) {
    let sourcePath = path.join(root, stats.name);
    if (/\.js$/.test(sourcePath)) {
      allPaths.push(sourcePath);
      if (stats.mtime > date) {
        newerPaths.push(sourcePath);
      }
    }
    next();
  });
  walker.on('errors', function() {
    callback(new Error('Trouble walking ' + sourceDir));
  });
  walker.on('end', function() {
    // prune symbols if file no longer exists or has been modified
    let lookup = {};
    info.symbols.forEach(function(symbol) {
      lookup[symbol.name] = symbol;
    });

    /**
     * Gather paths for all parent symbols.
     * @param {Object} symbol Symbol to check.
     * @param {Array.<string>} paths Current paths.
     */
    function gatherParentPaths(symbol, paths) {
      if (symbol.extends) {
        symbol.extends.forEach(function(name) {
          if (name in lookup) {
            let parent = lookup[name];
            paths.push(parent.path);
            gatherParentPaths(parent, paths);
          }
        });
      }
    }

    let dirtyPaths = [];

    info.symbols = info.symbols.filter(function(symbol) {
      let dirty = allPaths.indexOf(symbol.path) < 0;
      if (!dirty) {
        // confirm that symbol and all parent paths are not newer
        let paths = [symbol.path];
        gatherParentPaths(symbol, paths);
        dirty = paths.some(function(p) {
          return newerPaths.indexOf(p) >= 0;
        });
        if (dirty) {
          dirtyPaths.push(symbol.path);
        }
      }
      return !dirty;
    });

    info.defines = info.defines.filter(function(define) {
      let dirty = allPaths.indexOf(define.path) < 0 ||
          newerPaths.indexOf(define.path) >= 0;
      if (dirty) {
        dirtyPaths.push(define.path);
      }
      return !dirty;
    });

    callback(null, info, makeUnique(newerPaths.concat(dirtyPaths)));
  });
}

/**
 * Spawn JSDoc.
 * @param {Object} info Symbol and defines metadata.
 * @param {Array.<string>} newerSources Paths to newer source files.
 * @param {function(Error, Array, string)} callback Callback called with any
 *     error, existing metadata, and the JSDoc output (new metadata).
 */
function spawnJSDoc(info, newerSources, callback) {
  if (newerSources.length === 0) {
    callback(null, info, JSON.stringify(createInfo()));
    return;
  }

  let output = '';
  let errors = '';
  let child = spawn(jsdoc, ['-c', jsdocConfig].concat(newerSources));

  child.stdout.on('data', function(data) {
    output += String(data);
  });

  child.stderr.on('data', function(data) {
    errors += String(data);
  });

  child.on('exit', function(code) {
    if (code) {
      callback(new Error(errors || 'JSDoc failed with no output'));
    } else {
      callback(null, info, output);
    }
  });
}

/**
 * Parse the JSDoc output.
 * @param {Object} info Existing metadata.
 * @param {string} output JSDoc output
 * @param {function(Error, Object, Object)} callback Called with any error,
 *     existing metadata, and new metadata.
 */
function parseOutput(info, output, callback) {
  if (!output) {
    callback(new Error('Expected JSON output'));
    return;
  }

  let newInfo;
  try {
    newInfo = JSON.parse(String(output));
  } catch (err) {
    callback(new Error('Failed to parse output as JSON: ' + output));
    return;
  }

  if (!Array.isArray(newInfo.symbols)) {
    callback(new Error('Expected symbols array: ' + output));
    return;
  }

  if (!Array.isArray(newInfo.defines)) {
    callback(new Error('Expected defines array: ' + output));
    return;
  }

  process.nextTick(function() {
    callback(null, info, newInfo);
  });
}

/**
 * Given the path to a source file, get the list of provides.
 * @param {string} srcPath Path to source file.
 * @param {function(Error, Array.<string>)} callback Called with a list of
 *     provides or any error.
 */
let getProvides = async.memoize(function(srcPath, callback) {
  fs.readFile(srcPath, function(err, data) {
    if (err) {
      callback(err);
      return;
    }
    let provides = [];
    let matcher = /goog\.provide\('(.*)'\)/;
    String(data).split('\n').forEach(function(line) {
      let match = line.match(matcher);
      if (match) {
        provides.push(match[1]);
      }
    });
    callback(null, provides);
  });
});

/**
 * Add provides data to new symbols.
 * @param {Object} info Existing symbols and defines metadata.
 * @param {Object} newInfo New metadata.
 * @param {function(Error, Object)} callback Updated metadata.
 */
function addSymbolProvides(info, newInfo, callback) {

  function addProvides(symbol, callback) {
    getProvides(symbol.path, function(err, provides) {
      if (err) {
        callback(err);
        return;
      }
      symbol.provides = provides;
      callback(null, symbol);
    });
  }

  async.map(newInfo.symbols, addProvides, function(err, newSymbols) {
    newInfo.symbols = newSymbols;
    callback(err, info, newInfo);
  });
}

/**
 * Write symbol and define metadata to the info file.
 * @param {Object} info Existing metadata.
 * @param {Object} newInfo New meatadat.
 * @param {function(Error)} callback Callback.
 */
function writeInfo(info, newInfo, callback) {

  info.symbols = info.symbols.concat(newInfo.symbols).sort(function(a, b) {
    return a.name < b.name ? -1 : 1;
  });

  info.defines = info.defines.concat(newInfo.defines).sort(function(a, b) {
    return a.name < b.name ? -1 : 1;
  });

  let str = JSON.stringify(info, null, '  ');
  fse.outputFile(infoPath, str, callback);
}

/**
 * Determine which source files have been changed, run JSDoc against those, and
 * write out updated info.
 *
 * @param {function(Error)} callback Called when the info file has been written
 *     (or an error occurs).
 */
function main(callback) {
  async.waterfall([
    readInfo,
    getNewer,
    spawnJSDoc,
    parseOutput,
    addSymbolProvides,
    writeInfo
  ], callback);
}

/**
 * If running this module directly, read the config file and call the main
 * function.
 */
if (require.main === module) {
  main(function(err) {
    if (err) {
      console.error(err.message);
      process.exit(1);
    } else {
      process.exit(0);
    }
  });
}

/**
 * Export main function.
 */
module.exports = main;


text:
<?xml version="1.0" ?>

<container xmlns="http://symfony.com/schema/dic/services"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">

    <parameters>
        <parameter key="sensio_hangman.game_context.class">Sensio\Bundle\HangmanBundle\Game\GameContext</parameter>
        <parameter key="sensio_hangman.word_list.class">Sensio\Bundle\HangmanBundle\Game\WordList</parameter>
    </parameters>

    <services>
        <service id="sensio_hangman.game_context" class="%sensio_hangman.game_context.class%">
            <argument type="service" id="session" />
        </service>

        <service id="sensio_hangman.word_list" class="%sensio_hangman.word_list.class%">
            <argument>%sensio_hangman.dictionaries%</argument>

            <call method="loadDictionaries">
            </call>

        </service>
    </services>

</container>


text:
package fromwsdl.handler.common;

public interface TestConstants {

    // used to tell the test service to throw an exception
    public static final int SERVER_THROW_RUNTIME_EXCEPTION = -100;
    public static final int SERVER_THROW_MYFAULT_EXCEPTION = -101;

    public static final String MESSAGE_IN_FAULT = "message in a fault";
    public static final String MESSAGE_IN_EXCEPTION = "message in an exception";

    public static final String USER_CLIENT_PROPERTY_NAME = "client_name_abc";
    public static final String USER_HANDLER_PROPERTY_NAME = "handler_name_123";
    public static final String USER_PROPERTY_CLIENT_SET = "foo_value1";
    public static final String USER_PROPERTY_HANDLER_SET = "foo_value2";

    public static final String HANDLER_NAME = "handlerName";
    public static final String CLIENT_PREFIX = "client";
    public static final String SERVER_PREFIX = "server";
    public static final String INBOUND = "inbound";
    public static final String OUTBOUND = "not inbound";

    // handler actions. not using enums because ints are easier to use in wsdl
    public static final int HA_RETURN_TRUE = 0; // the default
    public static final int HA_RETURN_FALSE = 1;
    public static final int HA_RETURN_FALSE_INBOUND = 2;
    public static final int HA_RETURN_FALSE_OUTBOUND = 3;
    public static final int HA_RETURN_FALSE_CHANGE_MESSAGE = 4;
    public static final int HA_ADD_AND_CHECK_PROPS_INBOUND = 5;
    public static final int HA_ADD_BAD_MU_HEADER_OUTBOUND = 6;
    public static final int HA_ADD_BAD_MU_HEADER_CLIENT2_OUTBOUND = 7;
    public static final int HA_ADD_GOOD_MU_HEADER_OUTBOUND = 8;
    public static final int HA_ADD_HEADER_OUTBOUND_CLIENT_ROLE1 = 9;
    public static final int HA_ADD_HEADER_OUTBOUND = 10;
    public static final int HA_ADD_ONE = 11;
    public static final int HA_ADD_USER_PROPERTY_INBOUND = 12;
    public static final int HA_ADD_USER_PROPERTY_OUTBOUND = 13;
    public static final int HA_CHECK_FOR_ADDED_HEADER_INBOUND = 14;
    public static final int HA_CHECK_FOR_ADDED_HEADER_OUTBOUND = 15;
    public static final int HA_CHECK_FOR_USER_PROPERTY_OUTBOUND = 16;
    public static final int HA_CHECK_MC_BAD_PROPS = 17;
    public static final int HA_CHECK_MC_PROPS = 18;
    public static final int HA_CHECK_LMC = 19;
    public static final int HA_CHECK_SMC = 20;
    public static final int HA_CHECK_SMC_ALL_ROLES = 21;
    public static final int HA_INSERT_FAULT_AND_THROW_PE_INBOUND = 22;
    public static final int HA_INSERT_FAULT_AND_THROW_PE_OUTBOUND = 23;
    public static final int HA_REGISTER_HANDLE_XYZ = 24;
    public static final int HA_THROW_PROTOCOL_EXCEPTION_INBOUND = 25;
    public static final int HA_THROW_PROTOCOL_EXCEPTION_OUTBOUND = 26;
    public static final int HA_THROW_RUNTIME_EXCEPTION_INBOUND = 27;
    public static final int HA_THROW_RUNTIME_EXCEPTION_OUTBOUND = 28;
    public static final int HA_THROW_SOAP_FAULT_EXCEPTION_INBOUND = 29;
    public static final int HA_THROW_SOAP_FAULT_EXCEPTION_OUTBOUND = 30;

    // actions for a handler during a handleFault call
    // all need to be above 200 for server to check
    public static final int HF_CHECK_FAULT_MESSAGE_STRING = 200;
    public static final int HF_GET_FAULT_IN_MESSAGE = 201;
    public static final int HF_RETURN_FALSE = 202;
    public static final int HF_THROW_PROTOCOL_EXCEPTION = 203;
    public static final int HF_THROW_RUNTIME_EXCEPTION = 204;
    public static final int HF_THROW_TEST_PROTOCOL_EXCEPTION = 205;

    // report lists
    public static final String REPORT_CALLED_HANDLERS = "CalledHandlers";
    public static final String REPORT_CLOSED_HANDLERS = "ClosedHandlers";
    public static final String REPORT_DESTROYED_HANDLERS = "BitTheDust";

}


text:
author: Yuwei Cui
brief:
date: 2016/07/26
event:
  what: A comparative study of HTM and other neural network models for online sequence learning with streaming data
  when:
    begin: 2016/07/26 08:00
    end: 2016/07/26 10:00
  where:
    desc: IEEE WCCI 2016
    city: Vancouver
    state: British Columbia
    country: Canada
    web: http://www.wcci2016.org/
  who: Yuwei Cui
  why: Speaking
image: ../images/image.png
org: Research Engineer
tags: numenta ieee wcci world congress computational intelligence 2016
title: IEEE WCCI 2016
type: post
---

### About Talk

This talk is part of the International Joint Conference on Neural Networks
(IJCNN 2016). Special Session TA-4: Online Real-Time Learning Strategies for
Large Data Streams, located in room 215.

**Conference Schedule:**
http://www.wcci2016.org/document/ijcnn2016_5new.pdf

### About Conference

IEEE WCCI has traditionally been the largest technical event in the field of
computational intelligence, hosting three separate prestigious conferences
(IJCNN, FUZZ-IEEE, IEEE CEC) under one roof. Over the years the event has
provided a platform for highly acclaimed intellectuals from all over the world
to discuss and present their research findings on computational intelligence.
The organizing committee will put in place a rich and varied technical program
which is designed to engage participants in cross-fertilization of ideas among
the three big areas in computational intelligence. The event will also offer a
series of social functions, such as welcome reception, conference banquet etc.,
which will serve as a good channel to establish new connections and foster
everlasting friendship among fellow counterparts.


text:
package javax.print.attribute.standard;

import java.net.URI;
import java.util.Locale;

import javax.print.attribute.Attribute;
import javax.print.attribute.URISyntax;
import javax.print.attribute.PrintServiceAttribute;

/**
 * Class PrinterURI is a printing attribute class, a URI, that specifies the
 * globally unique name of a printer.  If it has such a name, an administrator
 * determines a printer's URI and sets this attribute to that name.
 *

 * IPP Compatibility:  This implements the
 * IPP printer-uri attribute. The string form returned by
 * toString()  gives the IPP printer-uri value.
 * The category name returned by getName()
 * gives the IPP attribute name.
 *

 *
 * @author  Robert Herriot
 */

public final class PrinterURI extends URISyntax
        implements PrintServiceAttribute {

    private static final long serialVersionUID = 7923912792485606497L;

    /**
     * Constructs a new PrinterURI attribute with the specified URI.
     *
     * @param  uri  URI of the printer
     *
     * @exception  NullPointerException
     *     (unchecked exception) Thrown if uri is null.
     */
    public PrinterURI(URI uri) {
        super (uri);
    }

    /**
     * Returns whether this printer name attribute is equivalent to the passed
     * in object. To be equivalent, all of the following conditions must be
     * true:
     *

     *

     * object is not null.
     *

     * object is an instance of class PrinterURI.
     *

     * This PrinterURI attribute's underlying URI and
     * object's underlying URI are equal.
     *

     *
     * @param  object  Object to compare to.
     *
     * @return  True if object is equivalent to this PrinterURI
     *          attribute, false otherwise.
     */
    public boolean equals(Object object) {
        return (super.equals(object) && object instanceof PrinterURI);
    }

   /**
     * Get the printing attribute class which is to be used as the "category"
     * for this printing attribute value.
     *

     * For class PrinterURI and any vendor-defined subclasses, the category is
     * class PrinterURI itself.
     *
     * @return  Printing attribute class (category), an instance of class
     *          {@link java.lang.Class java.lang.Class}.
     */
    public final Class<? extends Attribute> getCategory() {
        return PrinterURI.class;
    }

    /**
     * Get the name of the category of which this attribute value is an
     * instance.
     *

     * For class PrinterURI and any vendor-defined subclasses, the category
     * name is "printer-uri".
     *
     * @return  Attribute category name.
     */
    public final String getName() {
        return "printer-uri";
    }

}


text:
<?php

namespace Studiow\ValueObject\Hash;

use Studiow\ValueObject\Scalar\NativeString;
use InvalidArgumentException;

class BcryptHash extends NativeString
{
    public static function fromString(string $input): BcryptHash
    {
        return new self(password_hash($input, PASSWORD_BCRYPT));
    }

    public function __construct(string $hash)
    {
        $info = password_get_info($hash);
        if ($info['algoName'] != 'bcrypt') {
            throw new InvalidArgumentException(sprintf("Invalid bcrypt hash: %s", $hash));
        }
        parent::__construct($hash);
    }
}


text:
/* This file contains the CSS data for the editable area(iframe) of TinyMCE */
/* You can extend this CSS by adding your own CSS file with the the content_css option */

body, td, pre
{
	font-family: Verdana, Arial, Helvetica, sans-serif;
	font-size: 0.8em;
}

body
{
	background-color: #FFFFFF;
}

.mceVisualAid
{
	border: 1px dashed #BBBBBB !important;
}

div.mceVisualAid
{
	background-image:url('../images/spacer.gif');
	visibility: visible !important;
}

.mceItemAnchor
{
	width: 12px;
	line-height: 6px;
	overflow: hidden;
	padding-left: 12px;
	background-image: url('../images/anchor_symbol.gif');
	background-position: bottom;
	background-repeat: no-repeat;
}


text:
vagrant-weber
=============

a template for using Vagrant for developing Elixir applications with Weber

## Getting Started

1. Download and install [VirtualBox](https://www.virtualbox.org/)
2. Download and install [Vagrant](http://www.vagrantup.com/)
3. Clone this repo and `cd` into the directory
4. Run `vagrant up` to set up the vm
5. Run `vagrant ssh` to start a session on the vm
6. Run `cd /vagrant/[you project name] && ./start.sh` to run weber
7. Visit `http://localhost:8080/` in your favorite browser

## TODO

- Find a way to exit `iex` when using `./start_in_vagrant.sh`

> ##### Note
>
> The default project name is 'weber_test', so be sure to update `weber_project_name` in the `Vagrantfile` to
> reflect your needs.

[![githalytics.com alpha](https://cruel-carlota.pagodabox.com/5896d6c53b95330624df3109b75c2bab "githalytics.com")](http://githalytics.com/slogsdon/vagrant-weber)


text:
/*
 * GetQueueInfoResponse.cpp
 *
 *  Created on: Jul 22, 2014
 *      Author: bwang
 */

#include "GetQueueInfoResponse.h"

namespace libyarn {

GetQueueInfoResponse::GetQueueInfoResponse() {
	responseProto = GetQueueInfoResponseProto::default_instance();
}

GetQueueInfoResponse::GetQueueInfoResponse(const GetQueueInfoResponseProto &proto) :
		responseProto(proto) {
}

GetQueueInfoResponse::~GetQueueInfoResponse() {
}

GetQueueInfoResponseProto& GetQueueInfoResponse::getProto(){
	return responseProto;

}

void GetQueueInfoResponse::setQueueInfo(QueueInfo &info) {
	QueueInfoProto *infoProto = new QueueInfoProto();
	infoProto->CopyFrom(info.getProto());
	responseProto.set_allocated_queueinfo(infoProto);
}

QueueInfo GetQueueInfoResponse::getQueueInfo(){
	return QueueInfo(responseProto.queueinfo());
}

} /* namespace libyarn */


text:
'use strict';

var path = require('path');

module.exports = function getPagesFromURLs(destinationFolder, urls) {
  var pages = [];

  urls.forEach(function (urlObj) {
    var local = destinationFolder + urlObj.localFile;
    pages.push({
      local: path.normalize(local),
      remote: urlObj.url
    });
  });

  return pages;
};


text:
package purecollections;

final class Cons<T> extends ICons<T> {

	private final T head;
	private final Cons<T> tail;

	public Cons(T head, Cons<T> tail) {
		this.head = head;
		this.tail = tail;
	}

	public T getHead() { return head; }

	public Cons<T> getTail() { return tail; }

	public Computation<ICons<T>> getTailThunk() { return new Value<ICons<T>>(tail); }

}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Strict//EN">

<meta http-equiv="Content-Language" content="en-us">
<title>Library Download Tips</title>
<link rel="stylesheet" type="text/css" href="../style.css">
<base target="_blank">

Tecgraf/PUC-Rio Library Download Tips

All the libraries were build using Tecmake. Please use it if you intend to recompile the sources.
Tecmake
  can be found at
http://www.tecgraf.puc-rio.br/tecmake.

The IM files can be downloaded at

http://sourceforge.net/projects/imtoolkit/files/.

  The CD files can be downloaded at

http://sourceforge.net/projects/canvasdraw/files/.

  The IUP files can be downloaded at

http://sourceforge.net/projects/iup/files/.

  The Lua files can be downloaded at

http://sourceforge.net/projects/luabinaries/files/.

Build Configuration

Libraries and executables were built using speed optimization. In UNIX the dynamic libraries were NOT built with
  the -fpic parameter. In MacOS X the dynamic libraries are in bundle format. The source code along with the
  "config.mak" files for Tecmake are also available.

The DLLs were built using the cdecl calling convention. This should be
a problem for Visual Basic users.

In Visual C++ 6 and 7 we use the single thread C Run Time Library for static libraries and the multi thread C RTL for DLLs.
  Because this were the default in Visual Studio for new projects. Since Visual C++ 8, both use the multithread C RTL.

Packaging

The package files available for download are named according to the platform where they were build.

In UNIX all strings are based in the result of the command "uname -a". The package name is a concatenation of the
  platform uname, the system major version number and the system
minor version number. Some times a
  suffix must be added to complement the name. The compiler used is always gcc. Binaries for 64-bits receive the suffix: "_64". In Linux when
there are different versions of gcc for the same
  uname, the platform name is created adding the major version number of the compiler added as a suffix: "g3" for gcc 3 and "g4" for gcc
  4.

In Windows the platform name is the compiler and its major version number.

All library packages (*_lib*) contains pre-compiled binaries for the specified platform and includes. Packages with
"_bin" suffix
  contains executables only.

The package name is a general reference for the platform. If you have the same platform it will work fine, but it
  may also work in similar platforms.

Here are some examples of packages:

iup2_4_Linux26_lib.tar.gz = IUP 2.4 32-bits Libraries and Includes for Linux with Kernel version 2.6 built with
    gcc 3.

iup2_4_Linux26g4_64_bin.tar.gz = IUP 2.4 64-bits Executables for
Linux  with Kernel version 2.6 built with gcc 4.

iup2_4_Win32_vc8_lib.tar.gz = IUP 2.4 32-bits Static Libraries and Includes for Windows to use with Visual C++
8 (2005).

iup2_4_Win32_dll9_lib.tar.gz = IUP 2.4 32-bits Dynamic Libraries (DLLs),
import libraries and Includes for Windows to use with Visual C++
9 (2008).

iup2_4_Docs_html.tar.gz = IUP 2.4 documentation files in HTML format (the web site files can be browsed
    locally).

iup2_4_Win32_bin.tar.gz = IUP 2.4 32-bits Executables for Windows.

The documentation files are in HTML format. They do not include the CHM and PDF versions. These two files are
  provided as a separate download, but they all have the same documentation.

Installation

For any platform we recommend you to create a folder to contain the third party libraries you download. Then just
  unpack the packages you download in that folder. The packages already contains a directory structure that separates
  each library or toolkit. For example:

\mylibs\
        iup\
            bin\
            html\
            include\
            lib\Linux26
            lib\Linux26g4_64
            lib\vc8
            src
        cd\
        im\
        lua5.1\

This structure will also made the process of building from sources more simple, since the projects and makefiles
  will assume this structure .

Usage

For makefiles use:

1) "-I/mylibs/iup/include" to find include files
2) "-L/mylibs/iup/lib/Linux26" to find library files
3) "-liup" to specify the library files

For IDEs the configuration involves the same 3 steps above, but each IDE has a different dialog. The IUP toolkit
  has a Guide for some IDEs:

    Borland C++ BuilderX -
http://www.tecgraf.puc-rio.br/iup/en/ide_guide/cppbx.html

Code Blocks - http://www.tecgraf.puc-rio.br/iup/en/ide_guide/codeblocks.html

    Dev-C++ - http://www.tecgraf.puc-rio.br/iup/en/ide_guide/dev-cpp.html

Eclipse for C++ -

http://www.tecgraf.puc-rio.br/iup/en/ide_guide/eclipse.html

Microsoft Visual C++ (Visual Studio 2003) -
http://www.tecgraf.puc-rio.br/iup/en/ide_guide/msvc.html

    Microsoft Visual C++ (Visual Studio 2005) -
http://www.tecgraf.puc-rio.br/iup/en/ide_guide/msvc8.html

Open Watcom - http://www.tecgraf.puc-rio.br/iup/en/ide_guide/owc.html

Available Platforms

The following platforms can be available:

    Package Name
    Description

    AIX43
     IBM AIX 4.3 (ppc) / gcc 2.95 / Motif 2.1

    IRIX65
     SGI IRIX 6.5 (mips) / gcc 3.0 / Motif 2.1

    IRIX6465
     SGI IRIX 6.5 (mips) / gcc 3.3 / Motif 1.2

    Linux24
     Red Hat 7.3 (x86) / Kernel 2.4 / gcc 2.95 /
    Open Motif
	2.1 / GTK 2.0

    Linux24g3
     CentOS 3.9 (x86) / Kernel 2.4 / gcc 3.2 / Open
	Motif 2.2
	3 / GTK 2.2

    Linux24g3_64
     Red Hat E.L. WS 3 (x64) / Kernel 2.4 / gcc
	3.2 / Open Motif 2.2 3 / GTK 2.2

    Linux26
     CentOS 4.6 (x86) / Kernel 2.6 / gcc 3.4 / Open
	Motif 2.2
	3 / GTK 2.4

    Linux26_64
     CentOS 4.6 (x64) / Kernel 2.6 / gcc 3.4 / Open
	Motif 2.2
	3 / GTK 2.4

    Linux26_ia64
     Red Hat E.L. AS 4 (ia64) / Kernel 2.6 / gcc 3.4 /
    Open Motif 2.2 3 / GTK 2.4

    Linux26g4ppc
     Ubuntu 7.10 (ppc) / Kernel 2.6 / gcc 4.1 / Open Motif 2.2
	3 / GTK 2.?

    Linux26g4
     Ubuntu 10.4 (x86) / Kernel 2.6 / gcc 4.4 / Open Motif
	2.2 3 / GTK 2.20

    Linux26g4_64
     Ubuntu 10.4 (x64) / Kernel 2.6 / gcc 4.4 / OpenMotif 2.2 3 / GTK 2.20

    Linux30
     Ubuntu 11.10 (x86) / Kernel 3.0 / gcc 4.6 / Open Motif
	2.2 3 / GTK 2.24

    Linux30_64
     Ubuntu 11.10 (x64) / Kernel 3.0 / gcc 4.6 / OpenMotif 2.2 3
	/ GTK 2.24

    SunOS57
     Sun Solaris 7 (sparc) / gcc 2.95 / Motif 2.1

    SunOS58
     Sun Solaris 8 (sparc) / gcc 3.4 / Motif 2.1

    SunOS510
     Sun Solaris 10 (sparc) / gcc 3.4 / Motif 2.1

    SunOS510x86
     Sun Solaris 10 (x86) / gcc 3.3 / Motif 2.1

    FreeBSD54
     Free BSD 5.4 (x86) / gcc 3.4

    MacOS104
     Mac OS X 10.4 (ppc)
	[Tiger] / Darwin Kernel 8 / gcc 4.0

    MacOS104x86
     Mac OS X 10.4 (x86)
	[Tiger] / Darwin Kernel 8 / gcc 4.0

    MacOS105x86
     Mac OS X 10.5 (x86)
	[Leopard] / Darwin Kernel 9 / gcc 4.0

    MacOS106
     Mac OS X 10.6 (x64)
	[Snow Leopard] / Darwin Kernel 10 / gcc 4.2

    Win32_vc6
     Static library built with Microsoft Visual C++ 6 (static RTL/single thread)

    Win32_vc7
     Static library built with Microsoft Visual C++ 7.1 (.NET 2003) (static RTL/single thread)

      	 Also compatible with Microsoft Visual C++ Toolkit 2003

    Win32_vc8
     Static library built with Microsoft Visual C++ 8.0 (2005) (static RTL/multithread)

      	 Also compatible with Microsoft Visual C++ 2005 Express Edition

    Win32_vc9
     Static library built with Microsoft Visual C++ 9.0 (2008) (static RTL/multithread)

      	 Also compatible with Microsoft Visual C++ 2008 Express Edition

    Win32_vc10
     Static library built with Microsoft Visual C++ 10.0 (2010) (static RTL/multithread)

       Also compatible with Microsoft Visual C++ 2010 Express Edition -

       http://www.microsoft.com/express/vc/
    ¹

    Win32_dll6
     DLL and import library built
	with vc6, creates dependency with MSVCRT.DLL

    Win32_dll7
     DLL and import library built
	with vc7, creates dependency with MSVCR71.DLL

    Win32_dll8
     DLL and import library built
	with vc8, creates dependency with MSVCR80.DLL

    Win32_dll9
     DLL and import library built
	with vc9, creates dependency with MSVCR90.DLL

    Win32_dll10
     DLL and import library built
	with vc10, creates dependency with MSVCR100.DLL

    Win64_vc8
     Same as Win32_vc8 but for 64-bits
    systems using the x64 standard.

    Win64_vc9
     Same as Win32_vc9 but for 64-bits
    systems using the x64 standard.

    Win64_vc10
     Same as Win32_vc10 but for 64-bits
    systems using the x64 standard.

    Win64_dll8
     Same as Win32_dll8 but for 64-bits
    systems using the x64 standard.

    Win64_dll9
     Same as Win32_dll9 but for 64-bits
    systems using the x64 standard.

    Win64_dll10
     Same as Win32_dll10 but for 64-bits
    systems using the x64 standard.

    Win32_gcc3
     Static library built with Cygwin gcc 3.4  (Depends on Cygwin
	DLL 1.5)

    Win32_gcc4
     Static library built with Cygwin gcc 4.3  (Depends on Cygwin DLL 1.7) -
      http://www.cygwin.com/
    ¹

    Win32_cygw15
     Same as Win32_gcc3, but using the Cygwin Posix
    system and also with a DLL and import library

    Win32_cygw17
     Same as Win32_gcc4, but using the Cygwin Posix
    system and also with a DLL and import library

    Win32_dllg4
     DLL and import library built
	with Cygwin gcc 4.3 (See Win32_gcc4)

    Win32_mingw3
     Static library built with MingW gcc 3.4

    Win32_mingw4
     Static library built with MingW gcc 4.6 -
    http://www.mingw.org/
    ¹

	 Also compatible with Dev-C++ -
    http://www.bloodshed.net/devcpp.html

 and with Code Blocks -
	http://www.codeblocks.org/
    ¹

    Win32_dllw4
     DLL and import library built
	with MingW gcc 4.6 (See Win32_mingw4)

    Win64_mingw4
     Static library built with MingW gcc 4.5 -
    http://mingw-w64.sourceforge.net/
    ¹
 Tool chains targeting Win64 / Personal Builds / "sezero"
 for
	64-bits systems using the x64 standard.

    Win64_dllw4
     DLL and import library built
	with MingW gcc 4.5,
 for 64-bits systems using the x64 standard.
 creates dependency with MSVCRT.DLL

    Win32_owc1
     Static library built with Open Watcom 1.5 -
    http://www.openwatcom.org/

    Win32_bc55
     Static library built with Borland C++ 5.5 Compiler -

       https://downloads.embarcadero.com/free/c_builder
	  ¹

    Win32_bc56
     Static library built with Borland C++ BuilderX
	1.0 / Borland C++ 5.6 Compiler ¹,²

       (the C++ BuilderX IDE can also be configured to use mingw3 or gcc3 versions.)

    Win32_bc6
     Static library built with Embarcadero C++ Builder
	2010 / Embarcadero C++ 6 Compiler -

       https://downloads.embarcadero.com/free/c_builder
	(trial)

    Win32_bin
     Executables only for Windows NT/2000/XP/Vista/7 (can be
	generated by any of the above compilers)

    Win64_bin
     Same as Win32_bin but for 64-bits systems
    using the x64 standard

    Win32_cygw15_bin
     Executables only for Windows NT/2000/XP, but
    using the Cygwin Posix system (See Win32_cygw15)

    Win32_cygw17_bin
     Executables only for Windows NT/2000/XP, but
    using the Cygwin Posix system (See Win32_cygw17)

¹ - Notice that all the Windows
  compilers with links here are free to download and use.

  ² - Recently Borland removed the C++ Builder X
  from download. But if you bought a book that has the CD of the compiler, then
  it is still free to use.

	3 - OpenMotif 2.2 is classified as
	'experimental' by the Open Group.


text:
Package `netlink` provides low-level access to Linux netlink sockets.
MIT Licensed.

For more information about how netlink works, check out my blog series
on [Linux, Netlink, and Go](https://mdlayher.com/blog/linux-netlink-and-go-part-1-netlink/).

If you have any questions or you'd like some guidance, please join us on
[Gophers Slack](https://invite.slack.golangbridge.org) in the `#networking`
channel!

## Stability

See the [CHANGELOG](./CHANGELOG.md) file for a description of changes between
releases.

This package has a stable v1 API and any future breaking changes will prompt
the release of a new major version. Features and bug fixes will continue to
occur in the v1.x.x series.

In order to reduce the maintenance burden, this package is only supported on
Go 1.12+. Older versions of Go lack critical features and APIs which are
necessary for this package to function correctly.

**If you depend on this package in your applications, please use Go modules.**

## Design

A [number of netlink packages](https://godoc.org/?q=netlink) are already
available for Go, but I wasn't able to find one that aligned with what
I wanted in a netlink package:

- Straightforward, idiomatic API
- Well tested
- Well documented
- Doesn't use package/global variables or state
- Doesn't necessarily need root to work

My goal for this package is to use it as a building block for the creation
of other netlink family packages.

## Ecosystem

Over time, an ecosystem of Go packages has developed around package `netlink`.
Many of these packages provide building blocks for further interactions with
various netlink families, such as `NETLINK_GENERIC` or `NETLINK_ROUTE`.

To have your package included in this diagram, please send a pull request!

![netlink ecosystem](./netlink.svg)


text:
#pragma once
#include <aws/location/LocationService_EXPORTS.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/location/model/GeofenceGeometry.h>
#include <utility>

namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;

namespace Utils
{
namespace Json
{
  class JsonValue;
} // namespace Json
} // namespace Utils
namespace LocationService
{
namespace Model
{
  class AWS_LOCATIONSERVICE_API GetGeofenceResult
  {
  public:
    GetGeofenceResult();
    GetGeofenceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
    GetGeofenceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);

    /**
     *
The timestamp for when the geofence collection was created in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline const Aws::Utils::DateTime& GetCreateTime() const{ return m_createTime; }

    /**
     *
The timestamp for when the geofence collection was created in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline void SetCreateTime(const Aws::Utils::DateTime& value) { m_createTime = value; }

    /**
     *
The timestamp for when the geofence collection was created in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline void SetCreateTime(Aws::Utils::DateTime&& value) { m_createTime = std::move(value); }

    /**
     *
The timestamp for when the geofence collection was created in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline GetGeofenceResult& WithCreateTime(const Aws::Utils::DateTime& value) { SetCreateTime(value); return *this;}

    /**
     *
The timestamp for when the geofence collection was created in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline GetGeofenceResult& WithCreateTime(Aws::Utils::DateTime&& value) { SetCreateTime(std::move(value)); return *this;}

    /**
     *
The geofence identifier.

     */
    inline const Aws::String& GetGeofenceId() const{ return m_geofenceId; }

    /**
     *
The geofence identifier.

     */
    inline void SetGeofenceId(const Aws::String& value) { m_geofenceId = value; }

    /**
     *
The geofence identifier.

     */
    inline void SetGeofenceId(Aws::String&& value) { m_geofenceId = std::move(value); }

    /**
     *
The geofence identifier.

     */
    inline void SetGeofenceId(const char* value) { m_geofenceId.assign(value); }

    /**
     *
The geofence identifier.

     */
    inline GetGeofenceResult& WithGeofenceId(const Aws::String& value) { SetGeofenceId(value); return *this;}

    /**
     *
The geofence identifier.

     */
    inline GetGeofenceResult& WithGeofenceId(Aws::String&& value) { SetGeofenceId(std::move(value)); return *this;}

    /**
     *
The geofence identifier.

     */
    inline GetGeofenceResult& WithGeofenceId(const char* value) { SetGeofenceId(value); return *this;}

    /**
     *
Contains the geofence geometry details describing a polygon or a circle.

     */
    inline const GeofenceGeometry& GetGeometry() const{ return m_geometry; }

    /**
     *
Contains the geofence geometry details describing a polygon or a circle.

     */
    inline void SetGeometry(const GeofenceGeometry& value) { m_geometry = value; }

    /**
     *
Contains the geofence geometry details describing a polygon or a circle.

     */
    inline void SetGeometry(GeofenceGeometry&& value) { m_geometry = std::move(value); }

    /**
     *
Contains the geofence geometry details describing a polygon or a circle.

     */
    inline GetGeofenceResult& WithGeometry(const GeofenceGeometry& value) { SetGeometry(value); return *this;}

    /**
     *
Contains the geofence geometry details describing a polygon or a circle.

     */
    inline GetGeofenceResult& WithGeometry(GeofenceGeometry&& value) { SetGeometry(std::move(value)); return *this;}

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline const Aws::String& GetStatus() const{ return m_status; }

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline void SetStatus(const Aws::String& value) { m_status = value; }

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline void SetStatus(Aws::String&& value) { m_status = std::move(value); }

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline void SetStatus(const char* value) { m_status.assign(value); }

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline GetGeofenceResult& WithStatus(const Aws::String& value) { SetStatus(value); return *this;}

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline GetGeofenceResult& WithStatus(Aws::String&& value) { SetStatus(std::move(value)); return *this;}

    /**
     *
Identifies the state of the geofence. A geofence will hold one of the
     * following states:

 ACTIVE — The geofence has been
     * indexed by the system.

 PENDING — The geofence
     * is being processed by the system.

 FAILED — The
     * geofence failed to be indexed by the system.

     * DELETED — The geofence has been deleted from the system index.

     *

 DELETING — The geofence is being deleted from the
     * system index.

     */
    inline GetGeofenceResult& WithStatus(const char* value) { SetStatus(value); return *this;}

    /**
     *
The timestamp for when the geofence collection was last updated in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline const Aws::Utils::DateTime& GetUpdateTime() const{ return m_updateTime; }

    /**
     *
The timestamp for when the geofence collection was last updated in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline void SetUpdateTime(const Aws::Utils::DateTime& value) { m_updateTime = value; }

    /**
     *
The timestamp for when the geofence collection was last updated in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline void SetUpdateTime(Aws::Utils::DateTime&& value) { m_updateTime = std::move(value); }

    /**
     *
The timestamp for when the geofence collection was last updated in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline GetGeofenceResult& WithUpdateTime(const Aws::Utils::DateTime& value) { SetUpdateTime(value); return *this;}

    /**
     *
The timestamp for when the geofence collection was last updated in ISO 8601
     * format: YYYY-MM-DDThh:mm:ss.sssZ

     */
    inline GetGeofenceResult& WithUpdateTime(Aws::Utils::DateTime&& value) { SetUpdateTime(std::move(value)); return *this;}

  private:

    Aws::Utils::DateTime m_createTime;

    Aws::String m_geofenceId;

    GeofenceGeometry m_geometry;

    Aws::String m_status;

    Aws::Utils::DateTime m_updateTime;
  };

} // namespace Model
} // namespace LocationService
} // namespace Aws


text: require('../symlinked');


text:
import React from 'react';
import PropTypes from 'prop-types';
import { mount } from 'enzyme';

import Card from '../Card';
import { Icon } from '../../..';

describe('<Card />', () => {
  let mounted = null;
  let props = {};

  const context = { assetBasePath: '/' };
  const childContextTypes = { assetBasePath: PropTypes.string };
  const options = { context, childContextTypes };

  beforeEach(() => {
    props = {
      boundary: true,
      icon: <Icon icon="contact" sprite="standard" />,
      title: 'Base Card',
      headerRight: 'Right Header',
      children: 'Body',
      footer: 'footer',
    };

    mounted = mount(
      <Card {...props} />, options
    );
  });

  it('DEPRECATED: renders the icon', () => {
    expect(mounted.find(Icon).exists()).toBeTruthy();
  });

  it('DEPRECATED: renders the header', () => {
    expect(mounted.find('h2').first().text()).toEqual(props.title);
  });

  it('DEPRECATED: renders headerRight', () => {
    expect(mounted.find('div.slds-no-flex').first().text()).toEqual(props.headerRight);
  });

  it('DEPRECATED: renders body', () => {
    expect(mounted.find('div.slds-card__body').first().text()).toEqual(props.children);
  });

  it('DEPRECATED: renders footer', () => {
    expect(mounted.find('footer.slds-card__footer').first().text()).toEqual(props.footer);
  });

  it('DEPRECATED: allows passing boundary flag', () => {
    expect(mounted.find('.slds-card').hasClass('slds-card_boundary')).toBeTruthy();
  });

  it('DEPRECATED: applies className and rest-properties', () => {
    mounted.setProps({ className: 'foo', 'data-test': 'bar' });
    expect(mounted.find('.slds-card').hasClass('foo')).toBeTruthy();
    expect(mounted.find('.slds-card').prop('data-test')).toEqual('bar');
  });
});


text:
Spree Installer
===============

**Until the release of Spree 1.0 you must use the --edge option**

Command line utility to create new Spree store applications
and extensions

See the main spree project: https://github.com/spree/spree

Installation
------------

```ruby
gem install spree_cmd
```
This will make the command line utility 'spree' available.

You can add Spree to an existing rails application

```ruby
rails new my_app
spree install my_app
```

Extensions
----------

To build a new Spree Extension, you can run
```ruby
spree extension my_extension
```
Examples
--------

If you want to accept all the defaults pass --auto_accept

spree install my_store --edge --auto_accept

to use a local clone of Spree, pass the --path option

spree install my_store --path=../spree

Options
-------

* `--auto_accept` to answer yes to all questions
* `--edge` to use the edge version of Spree
* `--path=../spree` to use a local version of spree
* `--git=git@github.com:cmar/spree.git` to use git version of spree
  * `--branch=my_changes` to use git branch
  * `--ref=23423423423423` to use git reference
  * `--tag=my_tag` to use git tag

Older Versions of Spree
-----------------------

Versions of the Spree gem before 1.0 included a spree binary. If you
have one of these installed in your gemset, then you can alternatively
use the command line utility "spree_cmd". For example "spree_cmd install
my_app".


text:
(function(angular){

  //TODO : Add ngTouch - done
  //     : Lightbox content can be changed
  //     : Set text default for image label
  //     : Dynamic update src/details, add new src/details
  //     : Promise when close lightbox - done
  //     : Disable keyboard nav - done
  //     : Disable ngTouch on specific cases
  //     : Close lightbox dynamically
  //     : Change modal controller
  //     : Change modal template url
  //     : Add service methods : getCurrentImage user navigate to
  //     :                     : programatically navigate to some other images
  //     :                     : Add event if user navigate to other images
  'use strict';

  angular
  .module('ngBootstrapLightbox')
  .provider('lightbox', function LightboxProvider(){

    var _this               = this;
    _this._lightbox         = {

      options : {

        fadeDuration                : 0.7, // in seconds
        resizeDuration              : 0.5, // in seconds
        fitImageInViewPort          : false,
        positionFromTop             : 50,  // in pixel
        showImageNumberLabel        : false,
        alwaysShowNavOnTouchDevices : false,
        wrapAround                  : false,
        disableKeyboardNav          : false,

        //should not change it for now
        modalTemplateUrl            : 'src/partials/modal.tpl.html',
        windowTemplateUrl           : 'src/partials/window.tpl.html'
      },

      modalController : function($scope, $modalInstance, album, currentImageIndex, options){

        $scope.album             = album;
        $scope.currentImageIndex = currentImageIndex;
        $scope.options           = options;

        //store the modal instance so later we can remove the modal
        //from bootstrap directive
        $scope.modalInstance     = $modalInstance;
        $scope.$watch(function(){
          return $scope.album;
        }, function(){
          console.log($scope.album);
        })
      }
    };

    /**
     * [setDefaultOptions for setting the defualt options during config phase]
     *
     * @param {Object} options [default options need to override]
     */
    _this.setDefaultOptions = function(options){

      angular.extend(_this._lightbox.options, options);
    };

    _this.$get = ['$modal', function($modal){

      return {

        /**
         * [open open bootstrap modal when use click on thumbnail]
         *
         * @param  {Array} album    [Array of image passing to lightbox, contains : [{src, caption, thumb}]]
         * @param  {int} curIndex [current index of image inside array album that user click on]
         * @param  {Object} options  [Override options object]
         */
        open : function(album, curIndex, options){

          var newOptions = {};
          angular.extend(newOptions, _this._lightbox.options, options);

          //open bootstrap model
          _this._lightbox.modalInstance = $modal.open({

            templateUrl             : _this._lightbox.options.modalTemplateUrl,

            //need to fix bootstrap windowTemplateUrl to make lightbox
            //modal at the center of the page
            windowTemplateUrl       : _this._lightbox.options.windowTemplateUrl,
            controller              : ['$scope', '$modalInstance', 'album', 'currentImageIndex', 'options',
                                      _this._lightbox.modalController],
            resolve                 : {
              album             : function(){
                return album;
              },
              currentImageIndex : function(){
                return curIndex;
              },
              options           : function(){
                return newOptions;
              }
            }
          });

          return _this._lightbox.modalInstance;
        },
      };
    }];
  });
})(angular);


text:
'use strict';

const Fixtures = require('../fixtures');
const Faker = require('faker');

const db = Fixtures.db;
const Server = Fixtures.server;

const lab = exports.lab = require('lab').script();
const expect = require('code').expect;

const before = lab.before;
const after = lab.after;
const describe = lab.describe;
const it = lab.it;

describe('POST /user/confirm', () => {

  let server;
  const user1 = Fixtures.user({ validated: false });
  const user2 = Fixtures.user({ validated: false });
  const validation1 = Fixtures.validation({ user_id: user1.id });
  const validation2 = Fixtures.validation({ user_id: user2.id, created_at: Faker.date.past(1, new Date(Date.now() + 86401000)) });
  before(() => {

    return Promise.all([
      Server,
      db.users.insert(user1),
      db.users.insert(user2)
    ]).then((items) => {

      server = items[0];
      return Promise.all([
        db.validations.insert(validation1),
        db.validations.insert(validation2)
      ]);
    });
  });

  after(() => {

    return Promise.all([
      db.users.destroy({ id: user1.id }),
      db.users.destroy({ id: user2.id })
    ]);
  });

  it('confirms user', () => {

    return server.inject({ method: 'post', url: '/user/confirm', credentials: user1, payload: { token: validation1.token } }).then((res) => {

      expect(res.statusCode).to.equal(200);
      return res.result;
    }).then((result) => {

      expect(result.validated).to.equal(true);
      return db.users.findOne({ id: user1.id });
    }).then((updatedUser) => {

      expect(updatedUser.validated).to.equal(true);
      return db.validations.findOne({ user_id: user1.id });
    }).then((existingValidation) => {

      expect(existingValidation).to.not.exist();
    });
  });

  it('ignores invalid token', () => {

    return server.inject({ method: 'post', url: '/user/confirm', credentials: user2, payload: { token: Faker.random.uuid() } }).then((res) => {

      expect(res.statusCode).to.equal(404);
      return db.users.findOne({ id: user2.id });
    }).then((updatedUser) => {

      expect(updatedUser.validated).to.equal(false);
    });
  });

  it('ignores old token', () => {

    return server.inject({ method: 'post', url: '/user/confirm', credentials: user2, payload: { token: validation2.token } }).then((res) => {

      expect(res.statusCode).to.equal(404);
      return db.users.findOne({ id: user2.id });
    }).then((updatedUser) => {

      expect(updatedUser.validated).to.equal(false);
    });
  });
});


text:
package java.awt;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Vector;
import java.util.Enumeration;
import sun.awt.AWTAccessor;
import java.awt.peer.MenuBarPeer;
import java.awt.event.KeyEvent;
import javax.accessibility.*;

/**
 * The MenuBar class encapsulates the platform's
 * concept of a menu bar bound to a frame. In order to associate
 * the menu bar with a Frame object, call the
 * frame's setMenuBar method.
 *

 *
 * This is what a menu bar might look like:
 *

 *
 *

 * A menu bar handles keyboard shortcuts for menu items, passing them
 * along to its child menus.
 * (Keyboard shortcuts, which are optional, provide the user with
 * an alternative to the mouse for invoking a menu item and the
 * action that is associated with it.)
 * Each menu item can maintain an instance of MenuShortcut.
 * The MenuBar class defines several methods,
 * {@link MenuBar#shortcuts} and
 * {@link MenuBar#getShortcutMenuItem}
 * that retrieve information about the shortcuts a given
 * menu bar is managing.
 *
 * @author Sami Shaio
 * @see        Frame
 * @see        Frame#setMenuBar(MenuBar)
 * @see        Menu
 * @see        MenuItem
 * @see        MenuShortcut
 * @since      JDK1.0
 */
public class MenuBar extends MenuComponent implements MenuContainer, Accessible {

    static {
        /* ensure that the necessary native libraries are loaded */
        Toolkit.loadLibraries();
        if (!GraphicsEnvironment.isHeadless()) {
            initIDs();
        }
        AWTAccessor.setMenuBarAccessor(
            new AWTAccessor.MenuBarAccessor() {
                public Menu getHelpMenu(MenuBar menuBar) {
                    return menuBar.helpMenu;
                }

                public Vector<Menu> getMenus(MenuBar menuBar) {
                    return menuBar.menus;
                }
            });
    }

    /**
     * This field represents a vector of the
     * actual menus that will be part of the MenuBar.
     *
     * @serial
     * @see #countMenus()
     */
    Vector<Menu> menus = new Vector<>();

    /**
     * This menu is a special menu dedicated to
     * help.  The one thing to note about this menu
     * is that on some platforms it appears at the
     * right edge of the menubar.
     *
     * @serial
     * @see #getHelpMenu()
     * @see #setHelpMenu(Menu)
     */
    Menu helpMenu;

    private static final String base = "menubar";
    private static int nameCounter = 0;

    /*
     * JDK 1.1 serialVersionUID
     */
     private static final long serialVersionUID = -4930327919388951260L;

    /**
     * Creates a new menu bar.
     * @exception HeadlessException if GraphicsEnvironment.isHeadless()
     * returns true.
     * @see GraphicsEnvironment#isHeadless
     */
    public MenuBar() throws HeadlessException {
    }

    /**
     * Construct a name for this MenuComponent.  Called by getName() when
     * the name is null.
     */
    String constructComponentName() {
        synchronized (MenuBar.class) {
            return base + nameCounter++;
        }
    }

    /**
     * Creates the menu bar's peer.  The peer allows us to change the
     * appearance of the menu bar without changing any of the menu bar's
     * functionality.
     */
    public void addNotify() {
        synchronized (getTreeLock()) {
            if (peer == null)
                peer = Toolkit.getDefaultToolkit().createMenuBar(this);

            int nmenus = getMenuCount();
            for (int i = 0 ; i < nmenus ; i++) {
                getMenu(i).addNotify();
            }
        }
    }

    /**
     * Removes the menu bar's peer.  The peer allows us to change the
     * appearance of the menu bar without changing any of the menu bar's
     * functionality.
     */
    public void removeNotify() {
        synchronized (getTreeLock()) {
            int nmenus = getMenuCount();
            for (int i = 0 ; i < nmenus ; i++) {
                getMenu(i).removeNotify();
            }
            super.removeNotify();
        }
    }

    /**
     * Gets the help menu on the menu bar.
     * @return    the help menu on this menu bar.
     */
    public Menu getHelpMenu() {
        return helpMenu;
    }

    /**
     * Sets the specified menu to be this menu bar's help menu.
     * If this menu bar has an existing help menu, the old help menu is
     * removed from the menu bar, and replaced with the specified menu.
     * @param m    the menu to be set as the help menu
     */
    public void setHelpMenu(final Menu m) {
        synchronized (getTreeLock()) {
            if (helpMenu == m) {
                return;
            }
            if (helpMenu != null) {
                remove(helpMenu);
            }
            helpMenu = m;
            if (m != null) {
                if (m.parent != this) {
                    add(m);
                }
                m.isHelpMenu = true;
                m.parent = this;
                MenuBarPeer peer = (MenuBarPeer)this.peer;
                if (peer != null) {
                    if (m.peer == null) {
                        m.addNotify();
                    }
                    peer.addHelpMenu(m);
                }
            }
        }
    }

    /**
     * Adds the specified menu to the menu bar.
     * If the menu has been part of another menu bar,
     * removes it from that menu bar.
     *
     * @param        m   the menu to be added
     * @return       the menu added
     * @see          MenuBar#remove(int)
     * @see          MenuBar#remove(MenuComponent)
     */
    public Menu add(Menu m) {
        synchronized (getTreeLock()) {
            if (m.parent != null) {
                m.parent.remove(m);
            }
            menus.addElement(m);
            m.parent = this;

            MenuBarPeer peer = (MenuBarPeer)this.peer;
            if (peer != null) {
                if (m.peer == null) {
                    m.addNotify();
                }
                peer.addMenu(m);
            }
            return m;
        }
    }

    /**
     * Removes the menu located at the specified
     * index from this menu bar.
     * @param        index   the position of the menu to be removed.
     * @see          MenuBar#add(Menu)
     */
    public void remove(final int index) {
        synchronized (getTreeLock()) {
            Menu m = getMenu(index);
            menus.removeElementAt(index);
            MenuBarPeer peer = (MenuBarPeer)this.peer;
            if (peer != null) {
                m.removeNotify();
                m.parent = null;
                peer.delMenu(index);
            }
            if (helpMenu == m) {
                helpMenu = null;
                m.isHelpMenu = false;
            }
        }
    }

    /**
     * Removes the specified menu component from this menu bar.
     * @param        m the menu component to be removed.
     * @see          MenuBar#add(Menu)
     */
    public void remove(MenuComponent m) {
        synchronized (getTreeLock()) {
            int index = menus.indexOf(m);
            if (index >= 0) {
                remove(index);
            }
        }
    }

    /**
     * Gets the number of menus on the menu bar.
     * @return     the number of menus on the menu bar.
     * @since      JDK1.1
     */
    public int getMenuCount() {
        return countMenus();
    }

    /**
     * @deprecated As of JDK version 1.1,
     * replaced by getMenuCount().
     */
    @Deprecated
    public int countMenus() {
        return getMenuCountImpl();
    }

    /*
     * This is called by the native code, so client code can't
     * be called on the toolkit thread.
     */
    final int getMenuCountImpl() {
        return menus.size();
    }

    /**
     * Gets the specified menu.
     * @param      i the index position of the menu to be returned.
     * @return     the menu at the specified index of this menu bar.
     */
    public Menu getMenu(int i) {
        return getMenuImpl(i);
    }

    /*
     * This is called by the native code, so client code can't
     * be called on the toolkit thread.
     */
    final Menu getMenuImpl(int i) {
        return menus.elementAt(i);
    }

    /**
     * Gets an enumeration of all menu shortcuts this menu bar
     * is managing.
     * @return      an enumeration of menu shortcuts that this
     *                      menu bar is managing.
     * @see         MenuShortcut
     * @since       JDK1.1
     */
    public synchronized Enumeration<MenuShortcut> shortcuts() {
        Vector<MenuShortcut> shortcuts = new Vector<>();
        int nmenus = getMenuCount();
        for (int i = 0 ; i < nmenus ; i++) {
            Enumeration<MenuShortcut> e = getMenu(i).shortcuts();
            while (e.hasMoreElements()) {
                shortcuts.addElement(e.nextElement());
            }
        }
        return shortcuts.elements();
    }

    /**
     * Gets the instance of MenuItem associated
     * with the specified MenuShortcut object,
     * or null if none of the menu items being managed
     * by this menu bar is associated with the specified menu
     * shortcut.
     * @param        s the specified menu shortcut.
     * @see          MenuItem
     * @see          MenuShortcut
     * @since        JDK1.1
     */
     public MenuItem getShortcutMenuItem(MenuShortcut s) {
        int nmenus = getMenuCount();
        for (int i = 0 ; i < nmenus ; i++) {
            MenuItem mi = getMenu(i).getShortcutMenuItem(s);
            if (mi != null) {
                return mi;
            }
        }
        return null;  // MenuShortcut wasn't found
     }

    /*
     * Post an ACTION_EVENT to the target of the MenuPeer
     * associated with the specified keyboard event (on
     * keydown).  Returns true if there is an associated
     * keyboard event.
     */
    boolean handleShortcut(KeyEvent e) {
        // Is it a key event?
        int id = e.getID();
        if (id != KeyEvent.KEY_PRESSED && id != KeyEvent.KEY_RELEASED) {
            return false;
        }

        // Is the accelerator modifier key pressed?
        int accelKey = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
        if ((e.getModifiers() & accelKey) == 0) {
            return false;
        }

        // Pass MenuShortcut on to child menus.
        int nmenus = getMenuCount();
        for (int i = 0 ; i < nmenus ; i++) {
            Menu m = getMenu(i);
            if (m.handleShortcut(e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Deletes the specified menu shortcut.
     * @param     s the menu shortcut to delete.
     * @since     JDK1.1
     */
    public void deleteShortcut(MenuShortcut s) {
        int nmenus = getMenuCount();
        for (int i = 0 ; i < nmenus ; i++) {
            getMenu(i).deleteShortcut(s);
        }
    }

    /* Serialization support.  Restore the (transient) parent
     * fields of Menubar menus here.
     */

    /**
     * The MenuBar's serialized data version.
     *
     * @serial
     */
    private int menuBarSerializedDataVersion = 1;

    /**
     * Writes default serializable fields to stream.
     *
     * @param s the ObjectOutputStream to write
     * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
     * @see #readObject(ObjectInputStream)
     */
    private void writeObject(java.io.ObjectOutputStream s)
      throws ClassNotFoundException,
             IOException
    {
      s.defaultWriteObject();
    }

    /**
     * Reads the ObjectInputStream.
     * Unrecognized keys or values will be ignored.
     *
     * @param s the ObjectInputStream to read
     * @exception HeadlessException if
     *   GraphicsEnvironment.isHeadless returns
     *   true
     * @see GraphicsEnvironment#isHeadless
     * @see #writeObject(java.io.ObjectOutputStream)
     */
    private void readObject(ObjectInputStream s)
      throws ClassNotFoundException, IOException, HeadlessException
    {
      // HeadlessException will be thrown from MenuComponent's readObject
      s.defaultReadObject();
      for (int i = 0; i < menus.size(); i++) {
        Menu m = menus.elementAt(i);
        m.parent = this;
      }
    }

    /**
     * Initialize JNI field and method IDs
     */
    private static native void initIDs();

/////////////////
// Accessibility support
////////////////

    /**
     * Gets the AccessibleContext associated with this MenuBar.
     * For menu bars, the AccessibleContext takes the form of an
     * AccessibleAWTMenuBar.
     * A new AccessibleAWTMenuBar instance is created if necessary.
     *
     * @return an AccessibleAWTMenuBar that serves as the
     *         AccessibleContext of this MenuBar
     * @since 1.3
     */
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleAWTMenuBar();
        }
        return accessibleContext;
    }

    /**
     * Defined in MenuComponent. Overridden here.
     */
    int getAccessibleChildIndex(MenuComponent child) {
        return menus.indexOf(child);
    }

    /**
     * Inner class of MenuBar used to provide default support for
     * accessibility.  This class is not meant to be used directly by
     * application developers, but is instead meant only to be
     * subclassed by menu component developers.
     *

     * This class implements accessibility support for the
     * MenuBar class.  It provides an implementation of the
     * Java Accessibility API appropriate to menu bar user-interface elements.
     * @since 1.3
     */
    protected class AccessibleAWTMenuBar extends AccessibleAWTMenuComponent
    {
        /*
         * JDK 1.3 serialVersionUID
         */
        private static final long serialVersionUID = -8577604491830083815L;

        /**
         * Get the role of this object.
         *
         * @return an instance of AccessibleRole describing the role of the
         * object
         * @since 1.4
         */
        public AccessibleRole getAccessibleRole() {
            return AccessibleRole.MENU_BAR;
        }

    } // class AccessibleAWTMenuBar

}


text:
package com.siyeh.ig.serialization;

import com.intellij.psi.*;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtil;
import com.siyeh.HardcodedMethodConstants;
import com.siyeh.ig.BaseInspectionVisitor;
import com.siyeh.ig.psiutils.SerializationUtils;
import org.jetbrains.annotations.NotNull;

class SerializableInnerClassHasSerialVersionUIDFieldVisitor
  extends BaseInspectionVisitor {

  private final SerializableInspectionBase inspection;

  SerializableInnerClassHasSerialVersionUIDFieldVisitor(
    SerializableInspectionBase inspection) {
    this.inspection = inspection;
  }

  @Override
  public void visitClass(@NotNull PsiClass aClass) {
    // no call to super, so it doesn't drill down
    if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) {
      return;
    }
    if (aClass instanceof PsiTypeParameter) {
      return;
    }
    if (inspection.ignoreAnonymousInnerClasses && aClass instanceof PsiAnonymousClass) {
      return;
    }
    if (aClass.findFieldByName(HardcodedMethodConstants.SERIAL_VERSION_UID, false) != null) {
      return;
    }
    final PsiClass containingClass = PsiTreeUtil.getParentOfType(aClass, PsiClass.class);
    if (containingClass == null) {
      return;
    }
    if (aClass.hasModifierProperty(PsiModifier.STATIC)) {
      return;
    }
    final PsiModifierListOwner staticElement = PsiUtil.getEnclosingStaticElement(aClass, containingClass);
    if (staticElement != null) {
      return;
    }
    if (!SerializationUtils.isSerializable(aClass)) {
      return;
    }
    if (inspection.isIgnoredSubclass(aClass)) {
      return;
    }
    registerClassError(aClass);
  }
}


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

<testcase>
   <info>

This test checks fo:change-bar-* on list elements.

   </info>
   <fo>
      <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
         <fo:layout-master-set>
            <fo:simple-page-master page-height="145mm" page-width="210mm" margin="10mm"
               master-name="master">
               <fo:region-body column-count="2" column-gap="10mm"/>
            </fo:simple-page-master>
         </fo:layout-master-set>
         <fo:page-sequence master-reference="master">
            <fo:flow flow-name="xsl-region-body">

               <fo:block change-bar-style="solid" change-bar-color="red" change-bar-offset="2mm"
                  change-bar-width="0.3mm">

                  <fo:block>
                     <fo:change-bar-begin change-bar-class="first-half"/><fo:inline color="red"
                        id="first-half">January February March April May </fo:inline><fo:change-bar-begin
                           change-bar-class="summer" change-bar-color="green" change-bar-offset="1mm"
                        /><fo:inline color="brown" id="june-inline">June</fo:inline><fo:change-bar-end
                           change-bar-class="first-half"/><fo:inline color="green" id="summer"> July
                              August</fo:inline><fo:change-bar-end change-bar-class="summer"/> September October
                     November December</fo:block>

                  <fo:change-bar-begin change-bar-class="first-half"/>
                  <fo:block id="january">January</fo:block>
                  <fo:block id="february">February</fo:block>
                  <fo:block id="march">March</fo:block>
                  <fo:wrapper color="red">
                     <fo:block id="april">April</fo:block>
                     <fo:block id="may">May</fo:block>
                  </fo:wrapper>
                  <fo:change-bar-begin change-bar-class="summer" change-bar-color="green"
                     change-bar-offset="1mm"/>
                  <fo:wrapper color="brown">
                     <fo:block id="june-block">June</fo:block>
                  </fo:wrapper>
                  <fo:change-bar-end change-bar-class="first-half"/>
                  <fo:wrapper color="red">
                     <fo:block id="july">July</fo:block>
                     <fo:block id="august">August</fo:block>
                  </fo:wrapper>
                  <fo:change-bar-end change-bar-class="summer"/>
                  <fo:block id="september">September</fo:block>
                  <fo:block id="october">October</fo:block>
                  <fo:block id="november">November</fo:block>
                  <fo:block id="december">December</fo:block>

               </fo:block>
            </fo:flow>
         </fo:page-sequence>
      </fo:root>
   </fo>
   <checks>

      <eval expected="(solid,#ff0000,850)" xpath="//inlineparent[@prod-id='first-half']/inlineblock[1]/@border-start"/>
      <eval expected="-6519" xpath="//inlineparent[@prod-id='first-half']/inlineblock[1]/@left-offset"/>
      <eval expected="(solid,#ff0000,850)" xpath="//inlineparent[@prod-id='june-inline']/inlineblock[1]/@border-start"/>
      <eval expected="-6519" xpath="//inlineparent[@prod-id='june-inline']/inlineblock[1]/@left-offset"/>
      <eval expected="(solid,#008000,850)" xpath="//inlineparent[@prod-id='june-inline']/inlineblock[2]/@border-start"/>
      <eval expected="-3684" xpath="//inlineparent[@prod-id='june-inline']/inlineblock[2]/@left-offset"/>
      <eval expected="(solid,#008000,850)" xpath="//lineArea[2]/inlineparent[@prod-id='summer']/inlineblock[1]/@border-start"/>
      <eval expected="-3684" xpath="//lineArea[2]/inlineparent[@prod-id='summer']/inlineblock[1]/@left-offset"/>

      <eval expected="(solid,#ff0000,850)" xpath="//block[@prod-id='may']/block[1]/@border-start"/>
      <eval expected="-6519" xpath="//block[@prod-id='may']/block[1]/@left-offset"/>
      <eval expected="(solid,#ff0000,850)" xpath="//block[@prod-id='june-block']/block[1]/@border-start"/>
      <eval expected="-6519" xpath="//block[@prod-id='june-block']/block[1]/@left-offset"/>
      <eval expected="(solid,#008000,850)" xpath="//block[@prod-id='june-block']/block[2]/@border-start"/>
      <eval expected="-3684" xpath="//block[@prod-id='june-block']/block[2]/@left-offset"/>
      <eval expected="(solid,#008000,850)" xpath="//block[@prod-id='july']/block[1]/@border-start"/>
      <eval expected="-3684" xpath="//block[@prod-id='july']/block[1]/@left-offset"/>
   </checks>
</testcase>


text:
package com.avaryuon.fwk.core.bean.context;

import org.jboss.weld.context.ManagedContext;

/**
 * Context for view.
 *
 * @author Akyruu (akyruu@hotmail.com)
 * @version 0.1
 */
public interface ViewContext extends ManagedContext {
	/* STATIC FIELDS ======================================================= */
	// Nothing here

	/* METHODS ============================================================= */
	// Nothing here
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/app/SampleGame.iml" filepath="$PROJECT_DIR$/app/SampleGame.iml" />
      <module fileurl="file://$PROJECT_DIR$/../../current-sdk/proj.android-studio/libGreedyAndroidAgent/libGreedyAndroidAgent.iml" filepath="$PROJECT_DIR$/../../current-sdk/proj.android-studio/libGreedyAndroidAgent/libGreedyAndroidAgent.iml" />
      <module fileurl="file://$PROJECT_DIR$/../libs/cocos2d-x/cocos/platform/android/libcocos2dx/libcocos2dx.iml" filepath="$PROJECT_DIR$/../libs/cocos2d-x/cocos/platform/android/libcocos2dx/libcocos2dx.iml" />
      <module fileurl="file://$PROJECT_DIR$/proj.android-studio.iml" filepath="$PROJECT_DIR$/proj.android-studio.iml" />
    </modules>
  </component>
</project>