text:
'use strict';

angular.module('freecodecampNightlifeAppApp')
  .controller('MainCtrl', function($scope, $http, $window, Auth) {
    $scope.isLoggedIn = Auth.isLoggedIn;

    $scope.bars = [];

    // Search yelp api for bars matching location
    $scope.search = function(place) {
      $scope.error = null;
      $scope.isLoading = true;
      $http.get('/api/bars/' + place).
      success(function(data) {
        $scope.isLoading = false;
        $scope.bars = data.businesses;
        console.dir(data.businesses);

        // get "going" numbers from api for each business.
        $scope.bars.forEach(function(bar, index) {
          $http.get('/api/rsvps/' + bar.id).
          success(function(data) {
            $scope.bars[index].usersGoing = data.usersGoing;
          }).
          error(function(err) {
            console.log('err!', err);
          });
        });
      }).
      error(function(err) {
        $scope.isLoading = false;
        // Error getting search data
        console.dir(JSON.parse(err.data));

        $scope.error = 'Error: ' + JSON.parse(err.data).error.text;
      });
    };

    /* handles user clicking rsvp button for a bar */
    $scope.onIsGoing = function(index) {
      var bar = $scope.bars[index];

      if (!$scope.isGoing(index)) {
        $http.post('/api/rsvps/' + bar.id + '/' + Auth.getCurrentUser()._id).
        success(function(data) {
          bar.usersGoing = data.usersGoing;
        }).
        error(function(err) {
          console.log('error: ' + err);
        });
      } else {
        $scope.cancelRsvp(index);
      }
    };

    /* return true if current user has rsvp'd to this bar */
    $scope.isGoing = function(index) {
      if ($scope.bars[index].usersGoing && $scope.bars[index].usersGoing.indexOf(Auth.getCurrentUser()._id) !== -1) {
        return true;
      }
      return false;
    };

    /* cancel rsvp */
    $scope.cancelRsvp = function(index) {
      console.log('cancelling rsvp');
      var bar = $scope.bars[index];

      $http.put('/api/rsvps/' + bar.id + '/' + Auth.getCurrentUser()._id).
      success(function(data) {
        bar.usersGoing = data.usersGoing;
      });
    };
  });


text:
from ....testing import assert_equal
from ..dti import DTLUTGen

def test_DTLUTGen_inputs():
    input_map = dict(acg=dict(argstr='-acg',
    ),
    args=dict(argstr='%s',
    ),
    bingham=dict(argstr='-bingham',
    ),
    environ=dict(nohash=True,
    usedefault=True,
    ),
    frange=dict(argstr='-frange %s',
    position=1,
    units='NA',
    ),
    ignore_exception=dict(nohash=True,
    usedefault=True,
    ),
    inversion=dict(argstr='-inversion %d',
    units='NA',
    ),
    lrange=dict(argstr='-lrange %s',
    position=1,
    units='NA',
    ),
    out_file=dict(argstr='> %s',
    genfile=True,
    position=-1,
    ),
    samples=dict(argstr='-samples %d',
    units='NA',
    ),
    scheme_file=dict(argstr='-schemefile %s',
    mandatory=True,
    position=2,
    ),
    snr=dict(argstr='-snr %f',
    units='NA',
    ),
    step=dict(argstr='-step %f',
    units='NA',
    ),
    terminal_output=dict(nohash=True,
    ),
    trace=dict(argstr='-trace %G',
    units='NA',
    ),
    watson=dict(argstr='-watson',
    ),
    )
    inputs = DTLUTGen.input_spec()

    for key, metadata in list(input_map.items()):
        for metakey, value in list(metadata.items()):
            yield assert_equal, getattr(inputs.traits()[key], metakey), value

def test_DTLUTGen_outputs():
    output_map = dict(dtLUT=dict(),
    )
    outputs = DTLUTGen.output_spec()

    for key, metadata in list(output_map.items()):
        for metakey, value in list(metadata.items()):
            yield assert_equal, getattr(outputs.traits()[key], metakey), value

redpajama_set_name: RedPajamaGithub


text:
#import "HUNewGroupViewController.h"
#import "CSToast.h"
#import "DatabaseManager.h"
#import "UserManager.h"
#import "HUImageView.h"
#import "HUBaseViewController+Style.h"
#import "UIImagePickerController+Extensions.h"
#import "UIActionSheet+MKBlockAdditions.h"
#import "AlertViewManager.h"
#import "HUDataManager.h"
#import "HUPickerTableView.h"
#import "HUGroupsCategoryTableViewCell.h"
#import "HUTextView.h"

@interface HUNewGroupViewController (){
    BOOL                _keyboardShowing;
    UIImage             *_avatarImage;
}

@property (nonatomic, weak) UITextView *activeTextView;

@end

@implementation HUNewGroupViewController

#pragma mark - Initialization

- (id) initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil{
    if(self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil]){
        _keyboardShowing = NO;
    }

    return self;
}

#pragma mark - Override

-(void) loadView {

    [super loadView];

    [self showTutorialIfCan:NSLocalizedString(@"tutorial-group-add",nil)];

    _categoryValueLabel.enabled = NO;
    _nameValueLabel.enabled = YES;
    _groupOwnerValueLabel.enabled = NO;
    _passwordValueLabel.enabled = YES;
    _aboutValueLabel.editable = YES;

    [_categoryValueLabel setText:@""];
    [_nameValueLabel setText:@""];
    [_groupOwnerValueLabel setText:[[UserManager defaultManager] getLoginedUser].name];
    [_passwordValueLabel setText:@""];
    [_aboutValueLabel setText:@""];

    [_saveButton setTitle:NSLocalizedString(@"Save", @"") forState:UIControlStateNormal];
    [_cancelButton setTitle:NSLocalizedString(@"Cancel", @"") forState:UIControlStateNormal];
    [_categoryIconView setImage:nil];

    _isEditing = YES;

    [self showKeyboardDoneButtonForTextView:_aboutValueLabel];

}

-(void) updateAddButton{
}

- (void) layoutViews{
    [super layoutViews];

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.2 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
        CGPoint absolutePosition = [_cancelButton convertPoint:_cancelButton.frame.origin toView:_contentView];
        [_contentHeightConstraint setConstant:absolutePosition.y + _cancelButton.height + 20];
    });

    [_groupOwnerValueLabel setText:[[UserManager defaultManager] getLoginedUser].name];

}

- (void) viewWillAppear:(BOOL)animated{

    [super viewWillAppear:animated];

    self.navigationItem.leftBarButtonItems = [self backBarButtonItemsWithSelector:@selector(onBack:)];
    self.navigationItem.title = NSLocalizedString(@"New Group", nil);

    HUNewGroupViewController *this = self;

    [self subscribeForKeyboardWillShowNotificationUsingBlock:^(NSNotification *note) {

    }];

    [self subscribeForKeyboardWillChangeFrameNotificationUsingBlock:^(NSNotification *note) {
        [this animateKeyboardWillShow:note];
    }];

    [self subscribeForKeyboardWillHideNotificationUsingBlock:^(NSNotification *note) {
        [this animateKeyboardWillHide:note];
    }];

    [self layoutViews];
}

- (void) viewWillDisappear:(BOOL)animated {

    [super viewWillDisappear:animated];

    [self unsubscribeForKeyboardWillShowNotification];

    [self unsubscribeForKeyboardWillChangeFrameNotification];

    [self unsubscribeForKeyboardWillHideNotification];

}

#pragma mark - Keyboard Handling

- (void) animateKeyboardWillShow:(NSNotification *)aNotification {
    _keyboardShowing = YES;
    CGSize keyboardSize = [[[aNotification userInfo] objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size;
    _contentView.height = self.view.height - keyboardSize.height;
}

- (void) animateKeyboardWillHide:(NSNotification *)aNotification {
    _keyboardShowing = NO;
    _contentView.height = self.view.height;
}

- (void) viewDidAppear:(BOOL)animated{
    [super viewDidAppear:animated];
    [self layoutViews];
}

- (IBAction)onBack:(id)sender {

    [self dismissViewControllerAnimated:YES
                             completion:nil];
}

- (IBAction) onSave{

    [self.view endEditing:YES];

    [[AlertViewManager defaultManager] showWaiting:NSLocalizedString(@"Processing", nil)
                                           message:@""];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        if(![self validationAsync]){
            [[AlertViewManager defaultManager] dismiss];
            return;
        }

        NSString *groupName = [_nameValueLabel text];
        NSString *groupPassword = [_passwordValueLabel text];
        NSString *description = [_aboutValueLabel text];

        if (groupPassword == nil) groupPassword = @"";

        if (description == nil) description = @"";
        if (_selectedCategoryID == nil) _selectedCategoryID = @"";

        HUNewGroupViewController *this = self;

        [[DatabaseManager defaultManager]

         createGroup:groupName
         description:description
         password:groupPassword
         categoryID:_selectedCategoryID
         categoryName:_categoryValueLabel.text
         ower:[[UserManager defaultManager] getLoginedUser]
         avatarImage:_avatarImage
         success:^(BOOL isSuccess, NSString *errStr) {

             [[UserManager defaultManager] reloadUserDataWithCompletion:^(id result) {
                 dispatch_async(dispatch_get_main_queue(), ^{

                     [[AlertViewManager defaultManager] dismiss];

                     if (isSuccess == YES) {

                         [[AlertViewManager defaultManager] showAlert:NSLocalizedString(@"Group created successfully", nil)];
                         [this onBack:nil];
                         [[NSNotificationCenter defaultCenter] postNotificationName:NotificationSideMenuGroupsSelected object:nil];

                     } else {
                         [CSToast showToast:errStr withDuration:3.0];
                     }
                 });
             }];

             [CSToast showToast:NSLocalizedString(@"Success!", nil) withDuration:3.0];

         } error:^(NSString *errStr) {
             dispatch_async(dispatch_get_main_queue(), ^{
                 [[AlertViewManager defaultManager] dismiss];
             });
         }];

    });

}

- (BOOL) validationAsync{

    if (![_nameValueLabel text] || [_nameValueLabel text].length == 0) {

        [[AlertViewManager defaultManager] showAlert:NSLocalizedString(@"Missing-Group-Name", @"")];

        return NO;
    }

    if (![_aboutValueLabel text] || [_aboutValueLabel text].length == 0) {

        [[AlertViewManager defaultManager] showAlert:NSLocalizedString(@"Missing-Group-Description", @"")];

        return NO;
    }

    if(![[HUDataManager defaultManager] isNameOkay:[_nameValueLabel text]]){

        [[AlertViewManager defaultManager] showAlert:NSLocalizedString(@"Invalid-Name", @"")];

        return NO;

    }

    if([_passwordValueLabel text] != nil && [_passwordValueLabel text].length > 0 && ![[HUDataManager defaultManager] isPasswordOkay:[_passwordValueLabel text]]){

        [[AlertViewManager defaultManager] showAlert:NSLocalizedString(@"Wrong password message", @"")];

        return NO;

    }

    NSDictionary *result = [[DatabaseManager defaultManager] checkUniqueSynchronous:@"findGroup/name" value:[_nameValueLabel text]];

    if(result != nil){

        [[AlertViewManager defaultManager] showAlert:NSLocalizedString(@"Duplicate groupname", @"")];

        return NO;

    }

    return YES;
}

#pragma mark - avatar

-(IBAction) avatarImageViewDidTap:(UITapGestureRecognizer *)recognizer {

    void(^dismissBlock)(int buttonIndex) = ^(int buttonIndex){
        buttonIndex == 0 ? [self showPhotoCameraWithDelegate:self] : [self showPhotoLibraryWithDelegate:self];
    };

    void(^cancelBlock)(void) = ^{

    };

    [UIActionSheet actionSheetWithTitle:NSLocalizedString(@"Please select source", nil)
                                message:nil
                                buttons:@[NSLocalizedString(@"Camera", nil),NSLocalizedString(@"Album", nil)]
                             showInView:self.view
                              onDismiss:dismissBlock
                               onCancel:cancelBlock];

}

#pragma mark - UIImagePickerControllerDelegate

-(void)imagePickerController:(UIImagePickerController*)picker
       didFinishPickingImage:(UIImage*)image
                 editingInfo:(NSDictionary*)editingInfo{

    _avatarImage = [image copy];
    _avatarView.image = image;

    [self dismissViewControllerAnimated:YES
                             completion:nil];
    [self layoutViews];

}

@end


text:
var path = require('path')
var config = require('../config')
var utils = require('./utils')
var webpack = require('webpack')
var merge = require('webpack-merge')
var baseWebpackConfig = require('./webpack.base.conf')
var ExtractTextPlugin = require('extract-text-webpack-plugin')
var HtmlWebpackPlugin = require('html-webpack-plugin')
var env = process.env.NODE_ENV === 'testing'
  ? require('../config/test.env')
  : config.build.env

var webpackConfig = merge(baseWebpackConfig, {
  module: {
    loaders: utils.styleLoaders({ sourceMap: config.build.productionSourceMap, extract: true })
  },
  devtool: config.build.productionSourceMap ? '#source-map' : false,
  // [id]         is replaced by the id of the chunk.
  // [name]       is replaced by the name of the chunk (or with the id when the chunk has no name).
  // [hash]       is replaced by the hash of the compilation. (more like a timestamp)
  // [chunkhash]  is replaced by the hash of the chunk.
  output: {
    path: config.build.assetsRoot,
    filename: utils.assetsPath('js/[name].[chunkhash].js'),
    chunkFilename: utils.assetsPath('js/[id].[chunkhash].js')
  },
  // https://webpack.github.io/docs/using-plugins.html
  plugins: [
    new webpack.DefinePlugin({
      'process.env': env
    }),
    new webpack.optimize.UglifyJsPlugin({
      compress: {
        warnings: false
      }
    }),
    // If you use any hashing ([hash] or [chunkhash]), make sure to have a
    // consistent ordering of modules. Use the OccurrenceOrderPlugin or recordsPath.
    new webpack.optimize.OccurrenceOrderPlugin(),
    // extract css into its own file
    new ExtractTextPlugin(utils.assetsPath('css/[name].[contenthash].css')),
    // generate dist index.html with correct asset hash for caching.
    // you can customize output by editing /index.html
    // see https://github.com/ampedandwired/html-webpack-plugin
    new HtmlWebpackPlugin({
      filename: process.env.NODE_ENV === 'testing'
        ? 'index.html'
        : config.build.index,
      template: 'index.html',
      inject: true,
      minify: {
        removeComments: true,
        collapseWhitespace: true,
        removeAttributeQuotes: true,
        minifyCSS: true,
        minifyJS: true
        // more options:
        // https://github.com/kangax/html-minifier#options-quick-reference
      },
      // necessary to consistently work with multiple chunks via CommonsChunkPlugin
      chunksSortMode: 'dependency'
    }),
    // split vendor js into its own file
    new webpack.optimize.CommonsChunkPlugin({
      name: 'vendor',
      minChunks: function (module, count) {
        // any required modules inside node_modules are extracted to vendor
        return (
          module.resource &&
          /\.js$/.test(module.resource) &&
          module.resource.indexOf(
            path.join(__dirname, '../node_modules')
          ) === 0
        )
      }
    }),
    // extract webpack runtime and module manifest to its own file in order to
    // prevent vendor hash from being updated whenever app bundle is updated
    new webpack.optimize.CommonsChunkPlugin({
      name: 'manifest',
      chunks: ['vendor']
    })
  ]
})

if (config.build.productionGzip) {
  var CompressionWebpackPlugin = require('compression-webpack-plugin')

  webpackConfig.plugins.push(
    new CompressionWebpackPlugin({
      asset: '[path].gz[query]',
      algorithm: 'gzip',
      test: new RegExp(
        '\\.(' +
        config.build.productionGzipExtensions.join('|') +
        ')$'
      ),
      threshold: 10240,
      minRatio: 0.8
    })
  )
}

module.exports = webpackConfig


text:
from __future__ import absolute_import

import os
import sys
import logging

me = os.path.dirname(os.path.abspath(__file__))
# Add us to the PYTHONPATH/sys.path if we're not on it
if not me in sys.path:
    sys.path.insert(0, me)

logfilename = os.path.join('/tmp/', 'puppetboard_passenger_wsgi.log')
# configure the logging
logging.basicConfig(filename=logfilename, level=logging.INFO)

try:
    from puppetboard.app import app as application
except Exception, inst:
    logging.exception("Error: %s", str(type(inst)))


text:
DotNetCqs CommonServiceLocator
==============================

Command/Query separation library using a simple implementation of the CommonServiceLocator so you can use your favourite IoC container.

For more information on Common Service Locator library please visit http://commonservicelocator.codeplex.com/

Many of the main IoC containers already have an implemenation that is compatible with CommonServiceLocator, or you can "roll your own" by [implementing the interface](http://commonservicelocator.codeplex.com/wikipage?title=Implementing%20the%20Interface).

(An extension built on the DotNetCqs framework at https://github.com/jgauffin/dotnetcqs.)


text:
import wx
import wx.lib.newevent

from vistas.ui.utils import get_paint_dc

DraggableValueEventBase, EVT_DRAG_VALUE_EVENT = wx.lib.newevent.NewEvent()

class DraggableValueEvent(DraggableValueEventBase):
    def __init__(self, value):
        super().__init__(value=value)

class DraggableValue(wx.Window):
    def __init__(self, parent, id, value, per_px, min_value=None, max_value=None):
        super().__init__(parent, id)

        self.SetBackgroundStyle(wx.BG_STYLE_PAINT)
        self._value = None
        self._per_px = per_px
        self._dragging = False
        self._mouse_pos = None
        self.min_value = min_value
        self.max_value = max_value
        self.value = value
        self._temp_value = 0
        self.SetCursor(wx.Cursor(wx.CURSOR_SIZEWE))

        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
        self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
        self.Bind(wx.EVT_MOTION, self.OnMotion)

    def _repaint(self):
        extent = wx.ClientDC(self).GetTextExtent("{:.2f}".format(self._value))
        self.SetMinSize(wx.Size(extent.x, extent.y + 1))
        self.GetParent().Layout()
        self.Refresh()

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        if self.min_value is not None and value < self.min_value:
            value = self.min_value
        elif self.max_value is not None and value > self.max_value:
            value = self.max_value
        self._value = value
        self._repaint()

    def OnPaint(self, event):
        dc = get_paint_dc(self)
        dc.SetTextForeground(wx.Colour(0, 0, 255))
        dc.SetPen(wx.Pen(wx.Colour(0, 0, 255), 1, wx.DOT))
        value = self._value if not self._dragging else self._temp_value
        dc.DrawText("{:.2f}".format(value), 0, 0)
        width, height = self.GetSize().Get()
        dc.DrawLine(0, height - 2, width, height - 2)

    def OnLeftDown(self, event):
        self.CaptureMouse()
        self._dragging = True
        self._mouse_pos = event.GetPosition()
        self._temp_value = 0

    def OnLeftUp(self, event):
        if self.HasCapture():
            self.ReleaseMouse()
            self.SetCursor(wx.Cursor(wx.CURSOR_SIZEWE))
            self._dragging = False
            self.value = self._temp_value
            self._temp_value = 0

    def OnCaptureLost(self, event):
        self.ReleaseMouse()
        self.SetCursor((wx.Cursor(wx.CURSOR_SIZEWE)))
        self._dragging = False
        self.value = self._temp_value
        self._temp_value = 0

    def OnMotion(self, event):
        if not self._dragging or not event.LeftIsDown():
            return

        current_mouse_pos = event.GetPosition()
        self._temp_value = self.value + current_mouse_pos.x - self._mouse_pos.x * self._per_px
        self._mouse_pos = current_mouse_pos
        self._repaint()

        evt = DraggableValueEvent(value=self.value)
        wx.PostEvent(self, evt)


text:
package types

import (
	"fmt"

	k8sv1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/errors"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/tools/cache"

	"kubevirt.io/kubevirt/pkg/kubecli"
)

func IsPVCBlockFromStore(store cache.Store, namespace string, claimName string) (pvc *k8sv1.PersistentVolumeClaim, exists bool, isBlockDevice bool, err error) {
	obj, exists, err := store.GetByKey(namespace + "/" + claimName)
	if err != nil || !exists {
		return nil, exists, false, err
	}
	if pvc, ok := obj.(*k8sv1.PersistentVolumeClaim); ok {
		return obj.(*k8sv1.PersistentVolumeClaim), true, isPVCBlock(pvc), nil
	}
	return nil, false, false, fmt.Errorf("this is not a PVC! %v", obj)
}

func IsPVCBlockFromClient(client kubecli.KubevirtClient, namespace string, claimName string) (pvc *k8sv1.PersistentVolumeClaim, exists bool, isBlockDevice bool, err error) {
	pvc, err = client.CoreV1().PersistentVolumeClaims(namespace).Get(claimName, v1.GetOptions{})
	if errors.IsNotFound(err) {
		return nil, false, false, nil
	} else if err != nil {
		return nil, false, false, err
	}
	return pvc, true, isPVCBlock(pvc), nil
}

func isPVCBlock(pvc *k8sv1.PersistentVolumeClaim) bool {
	// We do not need to consider the data in a PersistentVolume (as of Kubernetes 1.9)
	// If a PVC does not specify VolumeMode and the PV specifies VolumeMode = Block
	// the claim will not be bound. So for the sake of a boolean answer, if the PVC's
	// VolumeMode is Block, that unambiguously answers the question
	return pvc.Spec.VolumeMode != nil && *pvc.Spec.VolumeMode == k8sv1.PersistentVolumeBlock
}

func IsPVCShared(pvc *k8sv1.PersistentVolumeClaim) (isShared bool) {
	for _, accessMode := range pvc.Spec.AccessModes {
		if accessMode == k8sv1.ReadWriteMany {
			isShared = true
			break
		}
	}
	return
}

func IsSharedPVCFromClient(client kubecli.KubevirtClient, namespace string, claimName string) (pvc *k8sv1.PersistentVolumeClaim, isShared bool, err error) {
	pvc, err = client.CoreV1().PersistentVolumeClaims(namespace).Get(claimName, v1.GetOptions{})
	if err != nil {
		return nil, false, err
	}

	isShared = IsPVCShared(pvc)
	return pvc, isShared, nil
}


text:
package filer

import (
	"context"
	"github.com/chrislusf/seaweedfs/weed/glog"
	"github.com/viant/ptrie"
	"io"
	"math"
	"strings"
	"time"

	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
	"github.com/chrislusf/seaweedfs/weed/stats"
	"github.com/chrislusf/seaweedfs/weed/util"
)

var (
	_ = VirtualFilerStore(&FilerStoreWrapper{})
	_ = Debuggable(&FilerStoreWrapper{})
)

type VirtualFilerStore interface {
	FilerStore
	DeleteHardLink(ctx context.Context, hardLinkId HardLinkId) error
	DeleteOneEntry(ctx context.Context, entry *Entry) error
	DeleteOneEntrySkipHardlink(ctx context.Context, fullpath util.FullPath) error
	AddPathSpecificStore(path string, storeId string, store FilerStore)
	OnBucketCreation(bucket string)
	OnBucketDeletion(bucket string)
	CanDropWholeBucket() bool
}

type FilerStoreWrapper struct {
	defaultStore   FilerStore
	pathToStore    ptrie.Trie
	storeIdToStore map[string]FilerStore
}

func NewFilerStoreWrapper(store FilerStore) *FilerStoreWrapper {
	if innerStore, ok := store.(*FilerStoreWrapper); ok {
		return innerStore
	}
	return &FilerStoreWrapper{
		defaultStore:   store,
		pathToStore:    ptrie.New(),
		storeIdToStore: make(map[string]FilerStore),
	}
}

func (fsw *FilerStoreWrapper) CanDropWholeBucket() bool {
	if ba, ok := fsw.defaultStore.(BucketAware); ok {
		return ba.CanDropWholeBucket()
	}
	return false
}

func (fsw *FilerStoreWrapper) OnBucketCreation(bucket string) {
	for _, store := range fsw.storeIdToStore {
		if ba, ok := store.(BucketAware); ok {
			ba.OnBucketCreation(bucket)
		}
	}
	if ba, ok := fsw.defaultStore.(BucketAware); ok {
		ba.OnBucketCreation(bucket)
	}
}
func (fsw *FilerStoreWrapper) OnBucketDeletion(bucket string) {
	for _, store := range fsw.storeIdToStore {
		if ba, ok := store.(BucketAware); ok {
			ba.OnBucketDeletion(bucket)
		}
	}
	if ba, ok := fsw.defaultStore.(BucketAware); ok {
		ba.OnBucketDeletion(bucket)
	}
}

func (fsw *FilerStoreWrapper) AddPathSpecificStore(path string, storeId string, store FilerStore) {
	fsw.storeIdToStore[storeId] = NewFilerStorePathTranslator(path, store)
	err := fsw.pathToStore.Put([]byte(path), storeId)
	if err != nil {
		glog.Fatalf("put path specific store: %v", err)
	}
}

func (fsw *FilerStoreWrapper) getActualStore(path util.FullPath) (store FilerStore) {
	store = fsw.defaultStore
	if path == "/" {
		return
	}
	var storeId string
	fsw.pathToStore.MatchPrefix([]byte(path), func(key []byte, value interface{}) bool {
		storeId = value.(string)
		return false
	})
	if storeId != "" {
		store = fsw.storeIdToStore[storeId]
	}
	return
}

func (fsw *FilerStoreWrapper) getDefaultStore() (store FilerStore) {
	return fsw.defaultStore
}

func (fsw *FilerStoreWrapper) GetName() string {
	return fsw.getDefaultStore().GetName()
}

func (fsw *FilerStoreWrapper) Initialize(configuration util.Configuration, prefix string) error {
	return fsw.getDefaultStore().Initialize(configuration, prefix)
}

func (fsw *FilerStoreWrapper) InsertEntry(ctx context.Context, entry *Entry) error {
	actualStore := fsw.getActualStore(entry.FullPath)
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "insert").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "insert").Observe(time.Since(start).Seconds())
	}()

	filer_pb.BeforeEntrySerialization(entry.Chunks)
	if entry.Mime == "application/octet-stream" {
		entry.Mime = ""
	}

	if err := fsw.handleUpdateToHardLinks(ctx, entry); err != nil {
		return err
	}

	// glog.V(4).Infof("InsertEntry %s", entry.FullPath)
	return actualStore.InsertEntry(ctx, entry)
}

func (fsw *FilerStoreWrapper) UpdateEntry(ctx context.Context, entry *Entry) error {
	actualStore := fsw.getActualStore(entry.FullPath)
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "update").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "update").Observe(time.Since(start).Seconds())
	}()

	filer_pb.BeforeEntrySerialization(entry.Chunks)
	if entry.Mime == "application/octet-stream" {
		entry.Mime = ""
	}

	if err := fsw.handleUpdateToHardLinks(ctx, entry); err != nil {
		return err
	}

	// glog.V(4).Infof("UpdateEntry %s", entry.FullPath)
	return actualStore.UpdateEntry(ctx, entry)
}

func (fsw *FilerStoreWrapper) FindEntry(ctx context.Context, fp util.FullPath) (entry *Entry, err error) {
	actualStore := fsw.getActualStore(fp)
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "find").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "find").Observe(time.Since(start).Seconds())
	}()

	entry, err = actualStore.FindEntry(ctx, fp)
	// glog.V(4).Infof("FindEntry %s: %v", fp, err)
	if err != nil {
		return nil, err
	}

	fsw.maybeReadHardLink(ctx, entry)

	filer_pb.AfterEntryDeserialization(entry.Chunks)
	return
}

func (fsw *FilerStoreWrapper) DeleteEntry(ctx context.Context, fp util.FullPath) (err error) {
	actualStore := fsw.getActualStore(fp)
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "delete").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "delete").Observe(time.Since(start).Seconds())
	}()

	existingEntry, findErr := fsw.FindEntry(ctx, fp)
	if findErr == filer_pb.ErrNotFound {
		return nil
	}
	if len(existingEntry.HardLinkId) != 0 {
		// remove hard link
		glog.V(4).Infof("DeleteHardLink %s", existingEntry.FullPath)
		if err = fsw.DeleteHardLink(ctx, existingEntry.HardLinkId); err != nil {
			return err
		}
	}

	// glog.V(4).Infof("DeleteEntry %s", fp)
	return actualStore.DeleteEntry(ctx, fp)
}

func (fsw *FilerStoreWrapper) DeleteOneEntry(ctx context.Context, existingEntry *Entry) (err error) {
	actualStore := fsw.getActualStore(existingEntry.FullPath)
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "delete").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "delete").Observe(time.Since(start).Seconds())
	}()

	if len(existingEntry.HardLinkId) != 0 {
		// remove hard link
		glog.V(4).Infof("DeleteHardLink %s", existingEntry.FullPath)
		if err = fsw.DeleteHardLink(ctx, existingEntry.HardLinkId); err != nil {
			return err
		}
	}

	// glog.V(4).Infof("DeleteOneEntry %s", existingEntry.FullPath)
	return actualStore.DeleteEntry(ctx, existingEntry.FullPath)
}

func (fsw *FilerStoreWrapper) DeleteOneEntrySkipHardlink(ctx context.Context, fullpath util.FullPath) (err error) {
	actualStore := fsw.getActualStore(fullpath)
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "delete").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "delete").Observe(time.Since(start).Seconds())
	}()

	glog.V(4).Infof("DeleteOneEntrySkipHardlink %s", fullpath)
	return actualStore.DeleteEntry(ctx, fullpath)
}

func (fsw *FilerStoreWrapper) DeleteFolderChildren(ctx context.Context, fp util.FullPath) (err error) {
	actualStore := fsw.getActualStore(fp + "/")
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "deleteFolderChildren").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "deleteFolderChildren").Observe(time.Since(start).Seconds())
	}()

	// glog.V(4).Infof("DeleteFolderChildren %s", fp)
	return actualStore.DeleteFolderChildren(ctx, fp)
}

func (fsw *FilerStoreWrapper) ListDirectoryEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, eachEntryFunc ListEachEntryFunc) (string, error) {
	actualStore := fsw.getActualStore(dirPath + "/")
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "list").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "list").Observe(time.Since(start).Seconds())
	}()

	// glog.V(4).Infof("ListDirectoryEntries %s from %s limit %d", dirPath, startFileName, limit)
	return actualStore.ListDirectoryEntries(ctx, dirPath, startFileName, includeStartFile, limit, func(entry *Entry) bool {
		fsw.maybeReadHardLink(ctx, entry)
		filer_pb.AfterEntryDeserialization(entry.Chunks)
		return eachEntryFunc(entry)
	})
}

func (fsw *FilerStoreWrapper) ListDirectoryPrefixedEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, prefix string, eachEntryFunc ListEachEntryFunc) (lastFileName string, err error) {
	actualStore := fsw.getActualStore(dirPath + "/")
	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "prefixList").Inc()
	start := time.Now()
	defer func() {
		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "prefixList").Observe(time.Since(start).Seconds())
	}()
	if limit > math.MaxInt32-1 {
		limit = math.MaxInt32 - 1
	}
	// glog.V(4).Infof("ListDirectoryPrefixedEntries %s from %s prefix %s limit %d", dirPath, startFileName, prefix, limit)
	adjustedEntryFunc := func(entry *Entry) bool {
		fsw.maybeReadHardLink(ctx, entry)
		filer_pb.AfterEntryDeserialization(entry.Chunks)
		return eachEntryFunc(entry)
	}
	lastFileName, err = actualStore.ListDirectoryPrefixedEntries(ctx, dirPath, startFileName, includeStartFile, limit, prefix, adjustedEntryFunc)
	if err == ErrUnsupportedListDirectoryPrefixed {
		lastFileName, err = fsw.prefixFilterEntries(ctx, dirPath, startFileName, includeStartFile, limit, prefix, adjustedEntryFunc)
	}
	return lastFileName, err
}

func (fsw *FilerStoreWrapper) prefixFilterEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, prefix string, eachEntryFunc ListEachEntryFunc) (lastFileName string, err error) {
	actualStore := fsw.getActualStore(dirPath + "/")

	if prefix == "" {
		return actualStore.ListDirectoryEntries(ctx, dirPath, startFileName, includeStartFile, limit, eachEntryFunc)
	}

	var notPrefixed []*Entry
	lastFileName, err = actualStore.ListDirectoryEntries(ctx, dirPath, startFileName, includeStartFile, limit, func(entry *Entry) bool {
		notPrefixed = append(notPrefixed, entry)
		return true
	})
	if err != nil {
		return
	}

	count := int64(0)
	for count < limit && len(notPrefixed) > 0 {
		var isLastItemHasPrefix bool
		for _, entry := range notPrefixed {
			if strings.HasPrefix(entry.Name(), prefix) {
				isLastItemHasPrefix = true
				count++
				if !eachEntryFunc(entry) {
					return
				}
				if count >= limit {
					break
				}
			} else {
				isLastItemHasPrefix = false
			}
		}
		if count < limit && isLastItemHasPrefix && len(notPrefixed) == int(limit) {
			notPrefixed = notPrefixed[:0]
			lastFileName, err = actualStore.ListDirectoryEntries(ctx, dirPath, lastFileName, false, limit, func(entry *Entry) bool {
				notPrefixed = append(notPrefixed, entry)
				return true
			})
			if err != nil {
				return
			}
		} else {
			break
		}
	}
	return
}

func (fsw *FilerStoreWrapper) BeginTransaction(ctx context.Context) (context.Context, error) {
	return fsw.getDefaultStore().BeginTransaction(ctx)
}

func (fsw *FilerStoreWrapper) CommitTransaction(ctx context.Context) error {
	return fsw.getDefaultStore().CommitTransaction(ctx)
}

func (fsw *FilerStoreWrapper) RollbackTransaction(ctx context.Context) error {
	return fsw.getDefaultStore().RollbackTransaction(ctx)
}

func (fsw *FilerStoreWrapper) Shutdown() {
	fsw.getDefaultStore().Shutdown()
}

func (fsw *FilerStoreWrapper) KvPut(ctx context.Context, key []byte, value []byte) (err error) {
	return fsw.getDefaultStore().KvPut(ctx, key, value)
}
func (fsw *FilerStoreWrapper) KvGet(ctx context.Context, key []byte) (value []byte, err error) {
	return fsw.getDefaultStore().KvGet(ctx, key)
}
func (fsw *FilerStoreWrapper) KvDelete(ctx context.Context, key []byte) (err error) {
	return fsw.getDefaultStore().KvDelete(ctx, key)
}

func (fsw *FilerStoreWrapper) Debug(writer io.Writer) {
	if debuggable, ok := fsw.getDefaultStore().(Debuggable); ok {
		debuggable.Debug(writer)
	}
}


text:
class GroupMember < Member
  include FromUnion
  include CreatedAtFilterable

  SOURCE_TYPE = 'Namespace'

  belongs_to :group, foreign_key: 'source_id'

  delegate :update_two_factor_requirement, to: :user

  # Make sure group member points only to group as it source
  default_value_for :source_type, SOURCE_TYPE
  validates :source_type, format: { with: /\ANamespace\z/ }
  default_scope { where(source_type: SOURCE_TYPE) } # rubocop:disable Cop/DefaultScope

  scope :of_groups, ->(groups) { where(source_id: groups.select(:id)) }
  scope :of_ldap_type, -> { where(ldap: true) }
  scope :count_users_by_group_id, -> { group(:source_id).count }

  after_create :update_two_factor_requirement, unless: :invite?
  after_destroy :update_two_factor_requirement, unless: :invite?

  def self.access_level_roles
    Gitlab::Access.options_with_owner
  end

  def self.access_levels
    Gitlab::Access.sym_options_with_owner
  end

  def group
    source
  end

  # Because source_type is `Namespace`...
  def real_source_type
    'Group'
  end

  def notifiable_options
    { group: group }
  end

  private

  def send_invite
    run_after_commit_or_now { notification_service.invite_group_member(self, @raw_invite_token) }

    super
  end

  def post_create_hook
    run_after_commit_or_now { notification_service.new_group_member(self) }

    super
  end

  def post_update_hook
    if saved_change_to_access_level?
      run_after_commit { notification_service.update_group_member(self) }
    end

    super
  end

  def after_accept_invite
    notification_service.accept_group_invite(self)
    update_two_factor_requirement

    super
  end

  def after_decline_invite
    notification_service.decline_group_invite(self)

    super
  end
end

GroupMember.prepend_if_ee('EE::GroupMember')


text:
<!-- If you don't know your Rasa Core version, use `pip list | grep rasa_core`. If you are creating a feature request, feel free to remove all the system information stuff. -->

**Rasa Core version** (e.g. `0.7.3`):

**Operating system** (windows, osx, ...):

**Issue**:

**Content of domain file** (if used & relevant):
```yaml

```


text:
namespace System.Xml.Schema
{
    using System.IO;
    using System.Collections;
    using System.ComponentModel;
    using System.Xml.Serialization;
    using System.Threading;
    using System.Diagnostics;
    using System.Collections.Generic;

    /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema"]/*' />
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    [XmlRoot("schema", Namespace = XmlSchema.Namespace)]
    public class XmlSchema : XmlSchemaObject
    {
        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Namespace"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public const string Namespace = XmlReservedNs.NsXs;
        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.InstanceNamespace"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public const string InstanceNamespace = XmlReservedNs.NsXsi;

        private XmlSchemaForm _attributeFormDefault = XmlSchemaForm.None;
        private XmlSchemaForm _elementFormDefault = XmlSchemaForm.None;
        private XmlSchemaDerivationMethod _blockDefault = XmlSchemaDerivationMethod.None;
        private XmlSchemaDerivationMethod _finalDefault = XmlSchemaDerivationMethod.None;
        private string _targetNs;
        private string _version;
        private XmlSchemaObjectCollection _includes = new XmlSchemaObjectCollection();
        private XmlSchemaObjectCollection _items = new XmlSchemaObjectCollection();
        private string _id;
        private XmlAttribute[] _moreAttributes;

        // compiled info
        private bool _isCompiled = false;
        private bool _isCompiledBySet = false;
        private bool _isPreprocessed = false;
        private bool _isRedefined = false;
        private int _errorCount = 0;
        private XmlSchemaObjectTable _attributes;
        private XmlSchemaObjectTable _attributeGroups = new XmlSchemaObjectTable();
        private XmlSchemaObjectTable _elements = new XmlSchemaObjectTable();
        private XmlSchemaObjectTable _types = new XmlSchemaObjectTable();
        private XmlSchemaObjectTable _groups = new XmlSchemaObjectTable();
        private XmlSchemaObjectTable _notations = new XmlSchemaObjectTable();
        private XmlSchemaObjectTable _identityConstraints = new XmlSchemaObjectTable();

        private static int s_globalIdCounter = -1;
        private ArrayList _importedSchemas;
        private ArrayList _importedNamespaces;

        private int _schemaId = -1; //Not added to a set
        private Uri _baseUri;
        private bool _isChameleon;
        private Hashtable _ids = new Hashtable();
        private XmlDocument _document;
        private XmlNameTable _nameTable;

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.XmlSchema"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public XmlSchema() { }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler)
        {
            return Read(new XmlTextReader(reader), validationEventHandler);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read1"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchema Read(Stream stream, ValidationEventHandler validationEventHandler)
        {
            return Read(new XmlTextReader(stream), validationEventHandler);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read2"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSchema Read(XmlReader reader, ValidationEventHandler validationEventHandler)
        {
            XmlNameTable nameTable = reader.NameTable;
            Parser parser = new Parser(SchemaType.XSD, nameTable, new SchemaNames(nameTable), validationEventHandler);
            try
            {
                parser.Parse(reader, null);
            }
            catch (XmlSchemaException e)
            {
                if (validationEventHandler != null)
                {
                    validationEventHandler(null, new ValidationEventArgs(e));
                }
                else
                {
                    throw;
                }
                return null;
            }
            return parser.XmlSchema;
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Write(Stream stream)
        {
            Write(stream, null);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write1"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Write(Stream stream, XmlNamespaceManager namespaceManager)
        {
            XmlTextWriter xmlWriter = new XmlTextWriter(stream, null);
            xmlWriter.Formatting = Formatting.Indented;
            Write(xmlWriter, namespaceManager);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write2"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Write(TextWriter writer)
        {
            Write(writer, null);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write3"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Write(TextWriter writer, XmlNamespaceManager namespaceManager)
        {
            XmlTextWriter xmlWriter = new XmlTextWriter(writer);
            xmlWriter.Formatting = Formatting.Indented;
            Write(xmlWriter, namespaceManager);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write4"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Write(XmlWriter writer)
        {
            Write(writer, null);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write5"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public void Write(XmlWriter writer, XmlNamespaceManager namespaceManager)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(XmlSchema));
            XmlSerializerNamespaces ns;

            if (namespaceManager != null)
            {
                ns = new XmlSerializerNamespaces();
                bool ignoreXS = false;
                if (this.Namespaces != null)
                { //User may have set both nsManager and Namespaces property on the XmlSchema object
                    ignoreXS = this.Namespaces.Namespaces.ContainsKey("xs") || this.Namespaces.Namespaces.ContainsValue(XmlReservedNs.NsXs);
                }
                if (!ignoreXS && namespaceManager.LookupPrefix(XmlReservedNs.NsXs) == null &&
                    namespaceManager.LookupNamespace("xs") == null)
                {
                    ns.Add("xs", XmlReservedNs.NsXs);
                }
                foreach (string prefix in namespaceManager)
                {
                    if (prefix != "xml" && prefix != "xmlns")
                    {
                        ns.Add(prefix, namespaceManager.LookupNamespace(prefix));
                    }
                }
            }
            else if (this.Namespaces != null && this.Namespaces.Count > 0)
            {
                Dictionary<string, string> serializerNS = this.Namespaces.Namespaces;
                if (!serializerNS.ContainsKey("xs") && !serializerNS.ContainsValue(XmlReservedNs.NsXs))
                { //Prefix xs not defined AND schema namespace not already mapped to a prefix
                    serializerNS.Add("xs", XmlReservedNs.NsXs);
                }
                ns = this.Namespaces;
            }
            else
            {
                ns = new XmlSerializerNamespaces();
                ns.Add("xs", XmlSchema.Namespace);
                if (_targetNs != null && _targetNs.Length != 0)
                {
                    ns.Add("tns", _targetNs);
                }
            }
            serializer.Serialize(writer, this, ns);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Compile"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. https://go.microsoft.com/fwlink/?linkid=14202")]
        public void Compile(ValidationEventHandler validationEventHandler)
        {
            SchemaInfo sInfo = new SchemaInfo();
            sInfo.SchemaType = SchemaType.XSD;
            CompileSchema(null, null, sInfo, null, validationEventHandler, NameTable, false);
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Compileq"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. https://go.microsoft.com/fwlink/?linkid=14202")]
        public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver)
        {
            SchemaInfo sInfo = new SchemaInfo();
            sInfo.SchemaType = SchemaType.XSD;
            CompileSchema(null, resolver, sInfo, null, validationEventHandler, NameTable, false);
        }

#pragma warning disable 618
        internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel)
        {
            //Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
            lock (this)
            {
                //Preprocessing
                SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
                prep.XmlResolver = resolver;
                if (!prep.Execute(this, ns, true, xsc))
                {
                    return false;
                }

                //Compilation
                SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
                _isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
                this.SetIsCompiled(_isCompiled);
                return _isCompiled;
            }
        }
#pragma warning restore 618

        internal void CompileSchemaInSet(XmlNameTable nameTable, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
        {
            Debug.Assert(_isPreprocessed);
            Compiler setCompiler = new Compiler(nameTable, eventHandler, null, compilationSettings);
            setCompiler.Prepare(this, true);
            _isCompiledBySet = setCompiler.Compile();
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.AttributeFormDefault"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("attributeFormDefault"), DefaultValue(XmlSchemaForm.None)]
        public XmlSchemaForm AttributeFormDefault
        {
            get { return _attributeFormDefault; }
            set { _attributeFormDefault = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.BlockDefault"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("blockDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
        public XmlSchemaDerivationMethod BlockDefault
        {
            get { return _blockDefault; }
            set { _blockDefault = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.FinalDefault"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("finalDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
        public XmlSchemaDerivationMethod FinalDefault
        {
            get { return _finalDefault; }
            set { _finalDefault = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.ElementFormDefault"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("elementFormDefault"), DefaultValue(XmlSchemaForm.None)]
        public XmlSchemaForm ElementFormDefault
        {
            get { return _elementFormDefault; }
            set { _elementFormDefault = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.TargetNamespace"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("targetNamespace", DataType = "anyURI")]
        public string TargetNamespace
        {
            get { return _targetNs; }
            set { _targetNs = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Version"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("version", DataType = "token")]
        public string Version
        {
            get { return _version; }
            set { _version = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Includes"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlElement("include", typeof(XmlSchemaInclude)),
         XmlElement("import", typeof(XmlSchemaImport)),
         XmlElement("redefine", typeof(XmlSchemaRedefine))]
        public XmlSchemaObjectCollection Includes
        {
            get { return _includes; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Items"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlElement("annotation", typeof(XmlSchemaAnnotation)),
         XmlElement("attribute", typeof(XmlSchemaAttribute)),
         XmlElement("attributeGroup", typeof(XmlSchemaAttributeGroup)),
         XmlElement("complexType", typeof(XmlSchemaComplexType)),
         XmlElement("simpleType", typeof(XmlSchemaSimpleType)),
         XmlElement("element", typeof(XmlSchemaElement)),
         XmlElement("group", typeof(XmlSchemaGroup)),
         XmlElement("notation", typeof(XmlSchemaNotation))]
        public XmlSchemaObjectCollection Items
        {
            get { return _items; }
        }

        // Compiled info
        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.IsCompiled"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public bool IsCompiled
        {
            get
            {
                return _isCompiled || _isCompiledBySet;
            }
        }

        [XmlIgnore]
        internal bool IsCompiledBySet
        {
            get { return _isCompiledBySet; }
            set { _isCompiledBySet = value; }
        }

        [XmlIgnore]
        internal bool IsPreprocessed
        {
            get { return _isPreprocessed; }
            set { _isPreprocessed = value; }
        }

        [XmlIgnore]
        internal bool IsRedefined
        {
            get { return _isRedefined; }
            set { _isRedefined = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Attributes"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaObjectTable Attributes
        {
            get
            {
                if (_attributes == null)
                {
                    _attributes = new XmlSchemaObjectTable();
                }
                return _attributes;
            }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.AttributeGroups"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaObjectTable AttributeGroups
        {
            get
            {
                if (_attributeGroups == null)
                {
                    _attributeGroups = new XmlSchemaObjectTable();
                }
                return _attributeGroups;
            }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.SchemaTypes"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaObjectTable SchemaTypes
        {
            get
            {
                if (_types == null)
                {
                    _types = new XmlSchemaObjectTable();
                }
                return _types;
            }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Elements"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaObjectTable Elements
        {
            get
            {
                if (_elements == null)
                {
                    _elements = new XmlSchemaObjectTable();
                }
                return _elements;
            }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Id"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAttribute("id", DataType = "ID")]
        public string Id
        {
            get { return _id; }
            set { _id = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.UnhandledAttributes"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlAnyAttribute]
        public XmlAttribute[] UnhandledAttributes
        {
            get { return _moreAttributes; }
            set { _moreAttributes = value; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Groups"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaObjectTable Groups
        {
            get { return _groups; }
        }

        /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Notations"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [XmlIgnore]
        public XmlSchemaObjectTable Notations
        {
            get { return _notations; }
        }

        [XmlIgnore]
        internal XmlSchemaObjectTable IdentityConstraints
        {
            get { return _identityConstraints; }
        }

        [XmlIgnore]
        internal Uri BaseUri
        {
            get { return _baseUri; }
            set
            {
                _baseUri = value;
            }
        }

        [XmlIgnore]
        // Please be careful with this property. Since it lazy initialized and its value depends on a global state
        //   if it gets called on multiple schemas in a different order the schemas will end up with different IDs
        //   Unfortunately the IDs are used to sort the schemas in the schema set and thus changing the IDs might change
        //   the order which would be a breaking change!!
        // Simply put if you are planning to add or remove a call to this getter you need to be extra carefull
        //   or better don't do it at all.
        internal int SchemaId
        {
            get
            {
                if (_schemaId == -1)
                {
                    _schemaId = Interlocked.Increment(ref s_globalIdCounter);
                }
                return _schemaId;
            }
        }

        [XmlIgnore]
        internal bool IsChameleon
        {
            get { return _isChameleon; }
            set { _isChameleon = value; }
        }

        [XmlIgnore]
        internal Hashtable Ids
        {
            get { return _ids; }
        }

        [XmlIgnore]
        internal XmlDocument Document
        {
            get { if (_document == null) _document = new XmlDocument(); return _document; }
        }

        [XmlIgnore]
        internal int ErrorCount
        {
            get { return _errorCount; }
            set { _errorCount = value; }
        }

        internal new XmlSchema Clone()
        {
            XmlSchema that = new XmlSchema();
            that._attributeFormDefault = _attributeFormDefault;
            that._elementFormDefault = _elementFormDefault;
            that._blockDefault = _blockDefault;
            that._finalDefault = _finalDefault;
            that._targetNs = _targetNs;
            that._version = _version;
            that._includes = _includes;

            that.Namespaces = this.Namespaces;
            that._items = _items;
            that.BaseUri = this.BaseUri;

            SchemaCollectionCompiler.Cleanup(that);
            return that;
        }

        internal XmlSchema DeepClone()
        {
            XmlSchema that = new XmlSchema();
            that._attributeFormDefault = _attributeFormDefault;
            that._elementFormDefault = _elementFormDefault;
            that._blockDefault = _blockDefault;
            that._finalDefault = _finalDefault;
            that._targetNs = _targetNs;
            that._version = _version;
            that._isPreprocessed = _isPreprocessed;
            //that.IsProcessing           = this.IsProcessing; //Not sure if this is needed

            //Clone its Items
            for (int i = 0; i < _items.Count; ++i)
            {
                XmlSchemaObject newItem;

                XmlSchemaComplexType complexType;
                XmlSchemaElement element;
                XmlSchemaGroup group;

                if ((complexType = _items[i] as XmlSchemaComplexType) != null)
                {
                    newItem = complexType.Clone(this);
                }
                else if ((element = _items[i] as XmlSchemaElement) != null)
                {
                    newItem = element.Clone(this);
                }
                else if ((group = _items[i] as XmlSchemaGroup) != null)
                {
                    newItem = group.Clone(this);
                }
                else
                {
                    newItem = _items[i].Clone();
                }
                that.Items.Add(newItem);
            }

            //Clone Includes
            for (int i = 0; i < _includes.Count; ++i)
            {
                XmlSchemaExternal newInclude = (XmlSchemaExternal)_includes[i].Clone();
                that.Includes.Add(newInclude);
            }
            that.Namespaces = this.Namespaces;
            //that.includes               = this.includes; //Need to verify this is OK for redefines
            that.BaseUri = this.BaseUri;
            return that;
        }

        [XmlIgnore]
        internal override string IdAttribute
        {
            get { return Id; }
            set { Id = value; }
        }

        internal void SetIsCompiled(bool isCompiled)
        {
            _isCompiled = isCompiled;
        }

        internal override void SetUnhandledAttributes(XmlAttribute[] moreAttributes)
        {
            _moreAttributes = moreAttributes;
        }
        internal override void AddAnnotation(XmlSchemaAnnotation annotation)
        {
            _items.Add(annotation);
        }

        internal XmlNameTable NameTable
        {
            get { if (_nameTable == null) _nameTable = new System.Xml.NameTable(); return _nameTable; }
        }

        internal ArrayList ImportedSchemas
        {
            get
            {
                if (_importedSchemas == null)
                {
                    _importedSchemas = new ArrayList();
                }
                return _importedSchemas;
            }
        }

        internal ArrayList ImportedNamespaces
        {
            get
            {
                if (_importedNamespaces == null)
                {
                    _importedNamespaces = new ArrayList();
                }
                return _importedNamespaces;
            }
        }

        internal void GetExternalSchemasList(IList extList, XmlSchema schema)
        {
            Debug.Assert(extList != null && schema != null);
            if (extList.Contains(schema))
            {
                return;
            }
            extList.Add(schema);
            for (int i = 0; i < schema.Includes.Count; ++i)
            {
                XmlSchemaExternal ext = (XmlSchemaExternal)schema.Includes[i];
                if (ext.Schema != null)
                {
                    GetExternalSchemasList(extList, ext.Schema);
                }
            }
        }

#if TRUST_COMPILE_STATE
        internal void AddCompiledInfo(SchemaInfo schemaInfo) {
            XmlQualifiedName itemName;
            foreach (XmlSchemaElement element in elements.Values) {
                itemName = element.QualifiedName;
                schemaInfo.TargetNamespaces[itemName.Namespace] = true;
                if (schemaInfo.ElementDecls[itemName] == null) {
                    schemaInfo.ElementDecls.Add(itemName, element.ElementDecl);
                }
            }
            foreach (XmlSchemaAttribute attribute in attributes.Values) {
                itemName = attribute.QualifiedName;
                schemaInfo.TargetNamespaces[itemName.Namespace] = true;
                if (schemaInfo.ElementDecls[itemName] == null) {
                    schemaInfo.AttributeDecls.Add(itemName, attribute.AttDef);
                }
            }
            foreach (XmlSchemaType type in types.Values) {
                itemName = type.QualifiedName;
                schemaInfo.TargetNamespaces[itemName.Namespace] = true;
                XmlSchemaComplexType complexType = type as XmlSchemaComplexType;
                if ((complexType == null || type != XmlSchemaComplexType.AnyType) && schemaInfo.ElementDeclsByType[itemName] == null) {
                    schemaInfo.ElementDeclsByType.Add(itemName, type.ElementDecl);
                }
            }
            foreach (XmlSchemaNotation notation in notations.Values) {
                itemName = notation.QualifiedName;
                schemaInfo.TargetNamespaces[itemName.Namespace] = true;
                SchemaNotation no = new SchemaNotation(itemName);
                no.SystemLiteral = notation.System;
                no.Pubid = notation.Public;
                if (schemaInfo.Notations[itemName.Name] == null) {
                    schemaInfo.Notations.Add(itemName.Name, no);
                }
            }
        }
#endif//TRUST_COMPILE_STATE
    }
}


text:
(function(__dependency1__) {
  "use strict";
  var uniq = __dependency1__.uniq;
  var forEach = __dependency1__.forEach;
})(utils);


text:
package org.mcdan.hk2.samples.multimodule;

import javax.inject.Inject;

import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
import org.mcdan.hk2.samples.multimodule.message.MessageFactory;
import org.mcdan.hk2.samples.multimodule.user.UserFactory;

public class Application  {

	public static void main(String[] args) {
		ServiceLocator locator = ServiceLocatorUtilities.createAndPopulateServiceLocator("test");
		UserFactory l = locator.getService(UserFactory.class);
		System.out.println("In startup: " + l.getUser().getUserName());
		final Application app = locator.create(Application.class);
		locator.inject(app);
		app.doSomething();
	}

	@Inject
	private UserFactory userFactory;

	@Inject
	private MessageFactory messageFactory;

	public Application() {

	}

	public void doSomething() {
		System.out.println("From user service: " + userFactory.getUser().getUserName());
		System.out.println("From message service: " + messageFactory.getMessage("from app.").getSubject());
	}
}


text:
import re
from abc import ABCMeta, abstractmethod
from requests import post
from speech_recognition import Recognizer

from mycroft.api import STTApi
from mycroft.configuration import ConfigurationManager
from mycroft.util.log import LOG

class STT(object):
    __metaclass__ = ABCMeta

    def __init__(self):
        config_core = ConfigurationManager.get()
        self.lang = str(self.init_language(config_core))
        config_stt = config_core.get("stt", {})
        self.config = config_stt.get(config_stt.get("module"), {})
        self.credential = self.config.get("credential", {})
        self.recognizer = Recognizer()

    @staticmethod
    def init_language(config_core):
        lang = config_core.get("lang", "en-US")
        langs = lang.split("-")
        if len(langs) == 2:
            return langs[0].lower() + "-" + langs[1].upper()
        return lang

    @abstractmethod
    def execute(self, audio, language=None):
        pass

class TokenSTT(STT):
    __metaclass__ = ABCMeta

    def __init__(self):
        super(TokenSTT, self).__init__()
        self.token = str(self.credential.get("token"))

class BasicSTT(STT):
    __metaclass__ = ABCMeta

    def __init__(self):
        super(BasicSTT, self).__init__()
        self.username = str(self.credential.get("username"))
        self.password = str(self.credential.get("password"))

class GoogleSTT(TokenSTT):
    def __init__(self):
        super(GoogleSTT, self).__init__()

    def execute(self, audio, language=None):
        self.lang = language or self.lang
        return self.recognizer.recognize_google(audio, self.token, self.lang)

class WITSTT(TokenSTT):
    def __init__(self):
        super(WITSTT, self).__init__()

    def execute(self, audio, language=None):
        LOG.warning("WITSTT language should be configured at wit.ai settings.")
        return self.recognizer.recognize_wit(audio, self.token)

class IBMSTT(BasicSTT):
    def __init__(self):
        super(IBMSTT, self).__init__()

    def execute(self, audio, language=None):
        self.lang = language or self.lang
        return self.recognizer.recognize_ibm(audio, self.username,
                                             self.password, self.lang)

class MycroftSTT(STT):
    def __init__(self):
        super(MycroftSTT, self).__init__()
        self.api = STTApi()

    def execute(self, audio, language=None):
        self.lang = language or self.lang
        try:
            return self.api.stt(audio.get_flac_data(convert_rate=16000),
                                self.lang, 1)[0]
        except:
            return self.api.stt(audio.get_flac_data(), self.lang, 1)[0]

class KaldiSTT(STT):
    def __init__(self):
        super(KaldiSTT, self).__init__()

    def execute(self, audio, language=None):
        language = language or self.lang
        response = post(self.config.get("uri"), data=audio.get_wav_data())
        return self.get_response(response)

    def get_response(self, response):
        try:
            hypotheses = response.json()["hypotheses"]
            return re.sub(r'\s*\[noise\]\s*', '', hypotheses[0]["utterance"])
        except:
            return None

class STTFactory(object):
    CLASSES = {
        "mycroft": MycroftSTT,
        "google": GoogleSTT,
        "wit": WITSTT,
        "ibm": IBMSTT,
        "kaldi": KaldiSTT
    }

    @staticmethod
    def create():
        config = ConfigurationManager.get().get("stt", {})
        module = config.get("module", "mycroft")
        clazz = STTFactory.CLASSES.get(module)
        return clazz()


text:
package com.agiletestingframework.automationpractice.website;

import static org.assertj.core.api.Assertions.assertThat;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.testng.ITestResult;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import com.agiletestingframework.automationpractice.website.pageobjects.ContactUsPage;
import com.agiletestingframework.toolbox.ATFHandler;
import com.agiletestingframework.toolbox.managers.ConfigurationManager;

public class ContactUsPageTest {

	public ContactUsPage contactUsPage;

	@BeforeMethod(alwaysRun=true)
	public void BeforeMethodSetup()
	{
		contactUsPage = (ContactUsPage)AutomationPracticePageFactory.getInstance(AutomationPracticePageFactory.CONTACTUS);
		contactUsPage.load();
	}

	@AfterMethod(alwaysRun=true)
	public void takeScreenShotOnFailure(ITestResult testResult, Method method) throws IOException {
		if (testResult.getStatus() == ITestResult.FAILURE) {
			File scrFile = ((TakesScreenshot)ATFHandler.getInstance().getWebAutomation().getWebDriver()).getScreenshotAs(OutputType.FILE);
			FileUtils.copyFile(scrFile, new File(ConfigurationManager.getInstance().getTakesScreenshotSaveLocation()+"\\"+method.getName()+".jpg"));
		}
	}

	@AfterClass
	public void ClassTeardown() {
		ATFHandler.getInstance().teardown();
	}

    /**
     * Validate the form for the ContactUs page is displayed
     */
    @Test(groups = { "smoke" } )
    public void contactUsFormIsDisplayed() {
        assertThat(contactUsPage.contactUsFormIsDisplayed()).isTrue();
    }

    @Test
    public void enterValidEmail(){
    	String email = "email@email.com";

    	contactUsPage.enterEmail(email);
    	contactUsPage.removeFocus();
    	assertThat(contactUsPage.checkIfValidEmail()).isTrue();

    }

    @Test
    public void enterInvalidEmail(){
    	String email = "emailemail.com";

    	contactUsPage.enterEmail(email);
    	contactUsPage.removeFocus();
    	assertThat(contactUsPage.checkIfValidEmail()).isFalse();

    }
}


text:
package org.eulerframework.web.core.base.dao;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.hibernate.FetchMode;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;

import org.eulerframework.web.core.base.entity.BaseEntity;
import org.eulerframework.web.core.base.request.PageQueryRequest;
import org.eulerframework.web.core.base.response.PageResponse;

public interface IBaseDao<T extends BaseEntity<?, ?>>{

    T load(Serializable id);

    List<T> load(Collection<Serializable> ids);

    List<T> load(Serializable[] idArray);

    Serializable save(T entity);

    void update(T entity);

    void saveOrUpdate(T entity);

    void saveOrUpdateBatch(Collection<T> entities);

    void delete(T entity);

    void deleteById(Serializable id);

    void deleteBatch(Collection<T> entities);

    void deleteByIds(Collection<Serializable> ids);

    void deleteByIds(Serializable[] idArray);

    List<T> queryByEntity(T entity);

    List<T> queryAll();

    long countAll();

    PageResponse<T> pageQuery(PageQueryRequest pageQueryRequest);

    /**
     * @param pageQueryRequest
     * @param criterions
     * @return
     */
    PageResponse<T> pageQuery(PageQueryRequest pageQueryRequest, List<Criterion> criterions);

    /**
     * @param pageQueryRequest
     * @param criterions
     * @param orders
     * @return
     */
    PageResponse<T> pageQuery(PageQueryRequest pageQueryRequest, List<Criterion> criterions, List<Order> orders);

    /**
     * @param pageQueryRequest
     * @param criterions
     * @param orders
     * @param projection
     * @return
     */
    PageResponse<T> pageQuery(PageQueryRequest pageQueryRequest, List<Criterion> criterions, List<Order> orders, Projection projection);

    /**
     * @param pageQueryRequest
     * @param criterions
     * @param orders
     * @param projection
     * @param fetchMode
     * @return
     */
    PageResponse<T> pageQuery(PageQueryRequest pageQueryRequest, List<Criterion> criterions, List<Order> orders,
            Projection projection, Map<String, FetchMode> fetchMode);

    void flushSession();

    public boolean isMyEntity(Class<? extends T> clazz);
}


text:
<!DOCTYPE html>

        <title>Ping Smoke Test</title>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">

Application server smoke test

Pings

                Ping!

                List system properties

                List environment variables

                List java: namespace

                List java:comp/env namespace

                List java:global

Health

                Initiate garbage collection with: DELETE /ping/resources/health/garbage

                Start (boot) time

                Current memory stats

                Operating System Info