text:
/*jshint
         asi:true,
         bitwise:true,
         browser:true,
         curly:true,
         eqeqeq:false,
         forin:true,
         noarg:true,
         noempty:true,
         plusplus:false,
         smarttabs:true,
         sub:true,
         trailing:false,
         undef:true,
         white:false,
         onevar:false
 */
/*global define*/
define( [ "yasmf", "text!html/startView.html!strip", "app/views/gameView",
  "app/views/optionsView", "app/views/highScoresView", "hammer"
], function( _y, startViewHTML, GameView, OptionsView, HighScoresView, Hammer ) {
  var _className = "StartView";
  var StartView = function() {
    var self = new _y.UI.ViewContainer();
    self.subclass( _className );
    self._playButton = null;
    self._optionsButton = null;
    self._highScoresButton = null;
    self.overrideSuper( self.class, "render", self.render );
    self.render = function() {
      return _y.template( startViewHTML, {
        "APP_TITLE": _y.T( "APP_TITLE" ),
        "PLAY": _y.T( "PLAY" ),
        "OPTIONS": _y.T( "OPTIONS" ),
        "HIGH_SCORES": _y.T( "HIGH_SCORES" )
      } );
    }
    self.quitApp = function() {
      navigator.app.exitApp();
    }
    self.playGame = function() {
      var aGameView = new GameView();
      aGameView.init();
      self.navigationController.pushView( aGameView );
    }
    self.showOptions = function() {
      var anOptionsView = new OptionsView();
      anOptionsView.init();
      self.navigationController.pushView( anOptionsView );
    }
    self.showHighScores = function() {
      var aHighScoreView = new HighScoresView();
      aHighScoreView.init();
      self.navigationController.pushView( aHighScoreView );
    }
    self.overrideSuper( self.class, "renderToElement", self.renderToElement );
    self.renderToElement = function() {
      self.super( _className, "renderToElement" );
      self._playButton = self.element.querySelector( ".game-actions .game-play" );
      Hammer( self._playButton ).on( "tap", self.playGame );
      self._optionsButton = self.element.querySelector( ".game-actions .game-options" );
      Hammer( self._optionsButton ).on( "tap", self.showOptions );
      self._highScoresButton = self.element.querySelector(
        ".game-actions .game-high-scores" );
      Hammer( self._highScoresButton ).on( "tap", self.showHighScores );
      _y.UI.backButton.addListenerForNotification( "backButtonPressed", self.quitApp );
    }
    self.startAnimation = function() {
      var e = self.element.querySelector( ".game-title" );
      e.style.webkitAnimationName = "animateTitle";
    }
    self.stopAnimation = function() {
      var e = self.element.querySelector( ".game-title" );
      e.style.webkitAnimationName = "inherit";
    }
    self.overrideSuper( self.class, "init", self.init );
    self.init = function( theParentElement ) {
      self.super( _className, "init", [ undefined, "div", "startView ui-container",
        theParentElement
      ] );
      self.addListenerForNotification( "viewWillAppear", self.startAnimation );
      self.addListenerForNotification( "viewWillDisappear", self.stopAnimation );
    }
    self.overrideSuper( self.class, "initWithOptions", self.init );
    self.initWithOptions = function( options ) {
      var theParentElement;
      if ( typeof options !== "undefined" ) {
        if ( typeof options.parent !== "undefined" ) {
          theParentElement = options.parent;
        }
      }
      self.init( theParentElement );
    }
    self.overrideSuper( self.class, "destroy", self.destroy );
    self.destroy = function() {
      self._playButton = null;
      self._optionsButton = null;
      self._highScoresButton = null;
      self.super( _className, "destroy" );
    }
    return self;
  };
  _y.addTranslations( {
    "APP_TITLE": {
      "EN": "Cave Runner"
    },
    "BACK": {
      "EN": "Back",
      "ES": "Volver"
    },
    "CANCEL": {
      "EN": "Cancel",
      "ES": "Cancelar"
    },
    "PLAY": {
      "EN": "Play!"
    },
    "OPTIONS": {
      "EN": "Options"
    },
    "HIGH_SCORES": {
      "EN": "High Scores"
    }
  } );
  return StartView;
} );


text:
if [ -d re2 ]
then

echo Updating RE2
cd re2
hg pull -u
else

echo Checkout RE2
hg clone https://re2.googlecode.com/hg re2
echo Applying Patches
cd re2
patch -p1 < ../hg_diff_g.patch
echo Copying file_strings.h and file_strings.cc
cp ../file_strings.h re2/
cp ../file_strings.cc re2/
fi

redpajama_set_name: RedPajamaGithub


text:
package de.vogella.datastructures.map;

public class MyEntry<K, V> {
  private final K key;
  private V value;

  public MyEntry(K key, V value) {
    this.key = key;
    this.value = value;
  }

  public K getKey() {
    return key;
  }

  public V getValue() {
    return value;
  }

  public void setValue(V value) {
    this.value = value;
  }
}


text:
import { Component, Inject, OnInit, ViewEncapsulation } from '@angular/core';
import { Title } from '@angular/platform-browser';
import {
  Event as RouterEvent, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, Router
} from '@angular/router';
import { I18NEXT_SERVICE, ITranslationService } from 'angular-i18next';
import { filter, map, mergeMap } from 'rxjs/operators';

// import 'assets/ng-validation.css';

@Component({
  selector: 'app',
  encapsulation: ViewEncapsulation.None,
  templateUrl: './app.component.html'
})
export class AppComponent implements OnInit  {

  loading = true;
  start = 0;
  constructor(private router: Router,
              private title: Title,
              @Inject(I18NEXT_SERVICE) private i18NextService: ITranslationService) {
      // spinner/loader subscription
      router.events
        .subscribe((event: RouterEvent) => {
            this.navigationInterceptor(event);
        });
      // page title subscription
      // https://toddmotto.com/dynamic-page-titles-angular-2-router-events#final-code
      this.router.events
        .pipe(
            filter(event => event instanceof NavigationEnd),
            map(() => this.router.routerState.root),
            map(route => {
              while (route.firstChild) route = route.firstChild;
              return route;
            }),
            filter(route => route.outlet === 'primary'),
            mergeMap(route => route.data)
        )
        .subscribe((event) => this.updatePageTitle(event['title']));
  }

  ngOnInit() {
    this.i18NextService.events.languageChanged.subscribe(lang => {
      const root = this.router.routerState.root;
      if (root != null && root.firstChild != null) {
        const data: any = root.firstChild.data;
        this.updatePageTitle(data && data.value && data.value.title);
      }
    });
  }

  // http://stackoverflow.com/questions/37069609/show-loading-screen-when-navigating-between-routes-in-angular-2
  navigationInterceptor(event: RouterEvent): void {
        if (event instanceof NavigationStart) {
            this.loading = true;
        }
        if (event instanceof NavigationEnd
            || event instanceof NavigationCancel
            || event instanceof NavigationError) {
            this.loading = false;
        }
    }

    updatePageTitle(title: string): void {
      const newTitle = title || 'application_title';
      console.log('Setting page title:', newTitle);
      this.title.setTitle(newTitle);
      console.log('Setting page title end:', newTitle);
    }
}


text:
<?php
/**
 * Displays the footer section of the theme.
 *
 * @package 		Theme Horse
 * @subpackage 		Ambition
 * @since 			Ambition 1.0
 */
?>
		<?php
			if (!is_page_template('page-templates/page-template-business.php')) { ?>
				</div><!-- .container -->
			<?php } ?>
			</div><!-- #content -->
			<?php
			/**
			 * ambition_after_main hook
			 */
			do_action('ambition_after_main');
			?>
			<?php
			/**
			 * ambition_before_footer hook
			 */
			do_action('ambition_before_footer');
			?>
			<footer id="colophon" class="site-footer clearfix" role="contentinfo">
			<?php
			/**
			 * ambition_footer hook
			 *
			 * HOOKED_FUNCTION_NAME PRIORITY
			 * ambition_footer_widget_area 15
			 * ambition_open_siteinfo_div 20
			 * ambition_socialnetworks 25
			 * ambition_footer_info 30
			 * ambition_close_siteinfo_div 40
			 * ambition_backtotop_html 45
			 */
			do_action('ambition_footer');
			?>
			</footer><!-- #colophon -->
		</div><!-- #page -->
		<?php
		/**
		 * ambition_after hook
		 */
		do_action('ambition_after');
		wp_footer(); ?>
	</body>
</html>


text:
<?php

use App\Services\Config\DotenvReader;
use App\Services\Filesystem\LaravelFilesystem;

use org\bovigo\vfs\vfsStream;

class DotenvReaderTest extends TestCase
{
    protected $rootDir;

    public function setUp()
    {
        parent::setUp();

        $this->rootDir = vfsStream::setup('rootDir');
    }

    public function test_Should_GetConfigValue_When_ConfigExistsAndValueIsNotEmpty()
    {
        $contents = <<<EOF
NAME1=value1
NAME2='value2'
NAME3= v a l u e 3
NAME4=

EOF;

        $dotenv = vfsStream::newFile('.env')->at($this->rootDir)->setContent($contents);

        $dotenvReader = new DotenvReader(
            new LaravelFilesystem($this->app['files']),
            vfsStream::url('rootDir/.env')
        );
        $value = $dotenvReader->getConfig('NAME1');

        $this->assertEquals('value1', $value);
    }

    public function test_Should_GetConfigValue_When_ConfigExistsAndValueIsSingleQuoted()
    {
        $contents = <<<EOF
NAME1=value1
NAME2='value2'
NAME3= v a l u e 3
NAME4=

EOF;

        $dotenv = vfsStream::newFile('.env')->at($this->rootDir)->setContent($contents);

        $dotenvReader = new DotenvReader(
            new LaravelFilesystem($this->app['files']),
            vfsStream::url('rootDir/.env')
        );
        $value = $dotenvReader->getConfig('NAME2');

        $this->assertEquals("'value2'", $value);
    }

    public function test_Should_GetConfigValue_When_ConfigExistsAndValueHasWhitespaces()
    {
        $contents = <<<EOF
NAME1=value1
NAME2='value2'
NAME3= v a l u e 3
NAME4=

EOF;

        $dotenv = vfsStream::newFile('.env')->at($this->rootDir)->setContent($contents);

        $dotenvReader = new DotenvReader(
            new LaravelFilesystem($this->app['files']),
            vfsStream::url('rootDir/.env')
        );
        $value = $dotenvReader->getConfig('NAME3');

        $this->assertEquals(' v a l u e 3 ', $value);
    }

    public function test_Should_GetNull_When_ConfigExistsAndValueIsEmpty()
    {
        $contents = <<<EOF
NAME1=value1
NAME2='value2'
NAME3= v a l u e 3
NAME4=

EOF;

        $dotenv = vfsStream::newFile('.env')->at($this->rootDir)->setContent($contents);

        $dotenvReader = new DotenvReader(
            new LaravelFilesystem($this->app['files']),
            vfsStream::url('rootDir/.env')
        );
        $value = $dotenvReader->getConfig('NAME4');

        $this->assertNull($value);
    }

    public function test_Should_GetNull_When_ConfigDoesNotExist()
    {
        $contents = <<<EOF
NAME1=value1
NAME2='value2'
NAME3= v a l u e 3
NAME4=

EOF;

        $dotenv = vfsStream::newFile('.env')->at($this->rootDir)->setContent($contents);

        $dotenvReader = new DotenvReader(
            new LaravelFilesystem($this->app['files']),
            vfsStream::url('rootDir/.env')
        );
        $value = $dotenvReader->getConfig('NAME5');

        $this->assertNull($value);
    }
}


text:
package net.karlmartens.ui.widget;

import net.karlmartens.ui.action.ResizeAllColumnsAction;
import net.karlmartens.ui.action.ResizeColumnAction;
import net.karlmartens.ui.widget.Table.KTableImpl;

import org.eclipse.jface.action.IMenuManager;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.MenuDetectEvent;
import org.eclipse.swt.events.MenuDetectListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;

final class TableColumnManager {

  private final Table _container;
  private final KTableImpl _table;

  private final SortColumnsContribution _sortColumnsContribution;
  private final ResizeColumnAction _resizeColumnAction;
  private final ResizeAllColumnsAction _resizeAllColumnsAction;
  private final VisibleColumnsContribution _visibleColumnsConstribution;
  private final FilterGroupContribution _filterGroupContribution;

  private boolean _columnsSortable = false;

  private int _columnIndex;
  private Point _offset;
  private Image _image;
  private Shell _shell;

  private boolean _columnMove = false;
  private boolean _selection = false;

  TableColumnManager(Table container, KTableImpl table) {
    _container = container;
    _table = table;

    _sortColumnsContribution = new SortColumnsContribution(this, _container);
    _resizeColumnAction = new ResizeColumnAction(_container, -1);
    _resizeAllColumnsAction = new ResizeAllColumnsAction(_container);

    _visibleColumnsConstribution = new VisibleColumnsContribution(_container);
    _filterGroupContribution = new FilterGroupContribution(_container);

    final IMenuManager columnMenu = container.getMenuManager();
    columnMenu.appendToGroup(Table.GROUP_COMMAND, _sortColumnsContribution);
    columnMenu.appendToGroup(Table.GROUP_COMMAND, _resizeColumnAction);
    columnMenu.appendToGroup(Table.GROUP_COMMAND, _resizeAllColumnsAction);
    columnMenu.appendToGroup(Table.GROUP_DATA, _visibleColumnsConstribution);
    columnMenu.appendToGroup(Table.GROUP_DATA, _filterGroupContribution);
    columnMenu.update();

    hookControl();
  }

  boolean isSortEnabled() {
    return _columnsSortable;
  }

  void enableColumnSort() {
    _columnsSortable = true;
  }

  private void hookControl() {
    _table.addDisposeListener(_widgetListener);
    _table.addMenuDetectListener(_widgetListener);
    _table.addMouseListener(_widgetListener);
    _table.addMouseMoveListener(_widgetListener);
  }

  private void releaseControl() {
    _table.removeDisposeListener(_widgetListener);
    _table.removeMenuDetectListener(_widgetListener);
    _table.removeMouseListener(_widgetListener);
    _table.removeMouseMoveListener(_widgetListener);
  }

  private Display getDisplay() {
    return _table.getDisplay();
  }

  private void initiateColumnMove(MouseEvent e, int colIndex) {
    _columnMove = true;
    _table.setIgnoreMouseMove(true);

    final Rectangle cellCords = _table.getCellRect(colIndex, 0);
    final int height = _table.getClientArea().height;
    _offset = new Point(cellCords.x - e.x, cellCords.y - e.y);

    if (_image != null)
      _image.dispose();
    _image = new Image(getDisplay(), new Rectangle(0, 0, cellCords.width,
        height));
    _image.getImageData().alpha = 0;

    final GC gc = new GC(_table);
    gc.copyArea(_image, cellCords.x, cellCords.y);
    gc.dispose();
  }

  private void showColumnMoveEffect() {
    _table.setCursor(getDisplay().getSystemCursor(SWT.CURSOR_HAND));

    _shell = new Shell(getDisplay(), SWT.NO_TRIM);
    _shell.setLayout(new FillLayout());
    _shell.setBounds(_image.getBounds());

    final Label l = new Label(_shell, SWT.NONE);
    l.setImage(_image);
    l.setBackground(getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY));

    _shell.open();
  }

  private void cancelColumnMove() {
    _columnMove = false;
    _offset = null;
    _table.setIgnoreMouseMove(false);

    if (_image != null && !_image.isDisposed())
      _image.dispose();
    _image = null;

    if (_shell != null && !_shell.isDisposed())
      _shell.dispose();
    _shell = null;

    _table.setCursor(getDisplay().getSystemCursor(SWT.CURSOR_ARROW));
  }

  private boolean isColumnMoveActive() {
    return _columnMove;
  }

  private void initiateSelection() {
    _selection = true;
  }

  private void cancelSelection() {
    _selection = false;
  }

  private boolean isSelectionActive() {
    return _selection;
  }

  private final Listener _widgetListener = new Listener();

  private final class Listener implements MouseListener, MouseMoveListener,
      MenuDetectListener, DisposeListener {

    @Override
    public void mouseDoubleClick(MouseEvent e) {
      if (_table != e.getSource())
        return;

      final Point cellCord = _table.getCellForCoordinates(e.x, e.y);
      if (cellCord.y < 0
          || cellCord.y >= _table.getModel().getFixedHeaderRowCount())
        return;

      final TableColumn column = _container.getColumn(cellCord.x);
      if (!column.isVisible())
        return;

      final Rectangle r = _table.getCellRect(cellCord.x, cellCord.y);
      if (r.x + r.width - e.x <= 5) {
        _resizeColumnAction.setColumnIndex(cellCord.x);
        _resizeColumnAction.run();
        return;
      }

      if (e.x - r.x <= 5) {
        for (int i = cellCord.x - 1; i >= 0; i--) {
          final TableColumn pColumn = _container.getColumn(i);
          if (pColumn.isVisible()) {
            _resizeColumnAction.setColumnIndex(i);
            _resizeColumnAction.run();
            return;
          }
        }
      }
    }

    @Override
    public void mouseDown(MouseEvent e) {
      if (_table != e.getSource()) {
        cancelColumnMove();
        cancelSelection();
        return;
      }

      if (e.button != 1) {
        cancelColumnMove();
        cancelSelection();
        return;
      }

      final Point cellCord = _table.getCellForCoordinates(e.x, e.y);
      if (cellCord.y < 0
          || cellCord.y >= _table.getModel().getFixedHeaderRowCount()) {
        cancelColumnMove();
        cancelSelection();
        return;
      }

      if (cellCord.x < 0 || cellCord.x >= _container.getColumnCount()) {
        cancelColumnMove();
        cancelSelection();
        return;
      }

      final Rectangle r = _table.getCellRect(cellCord.x, cellCord.y);
      if (e.x - r.x <= 5 || r.x + r.width - e.x <= 5) {
        cancelColumnMove();
        cancelSelection();
        return;
      }

      _columnIndex = cellCord.x;
      initiateSelection();

      if (!_container.getColumn(_columnIndex).isMoveable()) {
        cancelColumnMove();
        return;
      }

      initiateColumnMove(e, cellCord.x);
    }

    @Override
    public void mouseUp(MouseEvent e) {
      if (!isColumnMoveActive() && !isSelectionActive())
        return;

      if (_table != e.getSource()) {
        cancelColumnMove();
        cancelSelection();
        return;
      }

      final Point cellCord = _table.getCellForCoordinates(e.x, e.y);
      if (cellCord.x < 0 || cellCord.x >= _container.getColumnCount()
          || _columnIndex == cellCord.x) {
        cancelColumnMove();

        if (isSelectionActive()) {
          if (_columnsSortable) {
            _container.sort(_columnIndex);
          }

          final TableColumn column = _container.getColumn(_columnIndex);
          column.notifyListeners(SWT.Selection, new Event());
          cancelSelection();
        }
        return;
      }

      if (isColumnMoveActive())
        _container.moveColumn(_columnIndex, cellCord.x);

      cancelColumnMove();
      cancelSelection();
    }

    @Override
    public void mouseMove(MouseEvent e) {
      cancelSelection();
      if (!isColumnMoveActive())
        return;

      if (_table != e.getSource()) {
        cancelColumnMove();
        return;
      }

      if (_shell == null) {
        showColumnMoveEffect();
      }

      final Point cellCord = _table.getCellForCoordinates(e.x, e.y);
      if (cellCord.x >= 0 && cellCord.x < _container.getColumnCount()) {
        final TableColumn column = _container.getColumn(cellCord.x);
        if (column.isMoveable()) {
          _shell.setAlpha(200);
        } else {
          _shell.setAlpha(100);
        }
      }

      final int max = _table.getClientArea().width - _shell.getBounds().width;
      final Point p = _container.toDisplay(_table.getLocation());
      p.x += Math.max(Math.min(e.x + _offset.x, max), 0);
      _shell.setLocation(p);
    }

    @Override
    public void menuDetected(MenuDetectEvent e) {
      final Point cord = _table.toControl(e.x, e.y);
      final Point cell = _table.getCellForCoordinates(cord.x, cord.y);

      final int columnIndex = cell.x;
      _sortColumnsContribution.setColumnIndex(columnIndex);
      _filterGroupContribution.setColumnIndex(columnIndex);
      _resizeColumnAction.setColumnIndex(columnIndex);
    }

    @Override
    public void widgetDisposed(DisposeEvent e) {
      releaseControl();
      _visibleColumnsConstribution.dispose();
      _filterGroupContribution.dispose();
    }
  }
}


text:
require 'spec_helper'

describe SunFrog::Models::Item do
  subject { described_class.new(size: 'L', quantity: 5, m: '44091') }
  describe 'initialization' do
    it { expect(subject.size).to be     == 'L'     }
    it { expect(subject.quantity).to be == 5       }
    it { expect(subject.m).to be        == '44091' }
  end
end


text:
package registry

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type NetworkService struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Payload              string   `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	Matches              []*Match `protobuf:"bytes,3,rep,name=matches,proto3" json:"matches,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NetworkService) Reset()         { *m = NetworkService{} }
func (m *NetworkService) String() string { return proto.CompactTextString(m) }
func (*NetworkService) ProtoMessage()    {}
func (*NetworkService) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{0}
}

func (m *NetworkService) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NetworkService.Unmarshal(m, b)
}
func (m *NetworkService) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NetworkService.Marshal(b, m, deterministic)
}
func (m *NetworkService) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkService.Merge(m, src)
}
func (m *NetworkService) XXX_Size() int {
	return xxx_messageInfo_NetworkService.Size(m)
}
func (m *NetworkService) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkService.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkService proto.InternalMessageInfo

func (m *NetworkService) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *NetworkService) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

func (m *NetworkService) GetMatches() []*Match {
	if m != nil {
		return m.Matches
	}
	return nil
}

type Match struct {
	SourceSelector       map[string]string `protobuf:"bytes,1,rep,name=source_selector,json=sourceSelector,proto3" json:"source_selector,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Routes               []*Destination    `protobuf:"bytes,2,rep,name=routes,proto3" json:"routes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Match) Reset()         { *m = Match{} }
func (m *Match) String() string { return proto.CompactTextString(m) }
func (*Match) ProtoMessage()    {}
func (*Match) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{1}
}

func (m *Match) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Match.Unmarshal(m, b)
}
func (m *Match) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Match.Marshal(b, m, deterministic)
}
func (m *Match) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Match.Merge(m, src)
}
func (m *Match) XXX_Size() int {
	return xxx_messageInfo_Match.Size(m)
}
func (m *Match) XXX_DiscardUnknown() {
	xxx_messageInfo_Match.DiscardUnknown(m)
}

var xxx_messageInfo_Match proto.InternalMessageInfo

func (m *Match) GetSourceSelector() map[string]string {
	if m != nil {
		return m.SourceSelector
	}
	return nil
}

func (m *Match) GetRoutes() []*Destination {
	if m != nil {
		return m.Routes
	}
	return nil
}

type Destination struct {
	DestinationSelector  map[string]string `protobuf:"bytes,1,rep,name=destination_selector,json=destinationSelector,proto3" json:"destination_selector,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Weight               uint32            `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Destination) Reset()         { *m = Destination{} }
func (m *Destination) String() string { return proto.CompactTextString(m) }
func (*Destination) ProtoMessage()    {}
func (*Destination) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{2}
}

func (m *Destination) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Destination.Unmarshal(m, b)
}
func (m *Destination) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Destination.Marshal(b, m, deterministic)
}
func (m *Destination) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Destination.Merge(m, src)
}
func (m *Destination) XXX_Size() int {
	return xxx_messageInfo_Destination.Size(m)
}
func (m *Destination) XXX_DiscardUnknown() {
	xxx_messageInfo_Destination.DiscardUnknown(m)
}

var xxx_messageInfo_Destination proto.InternalMessageInfo

func (m *Destination) GetDestinationSelector() map[string]string {
	if m != nil {
		return m.DestinationSelector
	}
	return nil
}

func (m *Destination) GetWeight() uint32 {
	if m != nil {
		return m.Weight
	}
	return 0
}

type NetworkServiceManager struct {
	Name                 string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Url                  string               `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	ExpirationTime       *timestamp.Timestamp `protobuf:"bytes,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
	State                string               `protobuf:"bytes,4,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *NetworkServiceManager) Reset()         { *m = NetworkServiceManager{} }
func (m *NetworkServiceManager) String() string { return proto.CompactTextString(m) }
func (*NetworkServiceManager) ProtoMessage()    {}
func (*NetworkServiceManager) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{3}
}

func (m *NetworkServiceManager) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NetworkServiceManager.Unmarshal(m, b)
}
func (m *NetworkServiceManager) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NetworkServiceManager.Marshal(b, m, deterministic)
}
func (m *NetworkServiceManager) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkServiceManager.Merge(m, src)
}
func (m *NetworkServiceManager) XXX_Size() int {
	return xxx_messageInfo_NetworkServiceManager.Size(m)
}
func (m *NetworkServiceManager) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkServiceManager.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkServiceManager proto.InternalMessageInfo

func (m *NetworkServiceManager) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *NetworkServiceManager) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *NetworkServiceManager) GetExpirationTime() *timestamp.Timestamp {
	if m != nil {
		return m.ExpirationTime
	}
	return nil
}

func (m *NetworkServiceManager) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

type NetworkServiceEndpoint struct {
	Name                      string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Payload                   string            `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	NetworkServiceName        string            `protobuf:"bytes,3,opt,name=network_service_name,json=networkServiceName,proto3" json:"network_service_name,omitempty"`
	NetworkServiceManagerName string            `protobuf:"bytes,4,opt,name=network_service_manager_name,json=networkServiceManagerName,proto3" json:"network_service_manager_name,omitempty"`
	Labels                    map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	State                     string            `protobuf:"bytes,6,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}          `json:"-"`
	XXX_unrecognized          []byte            `json:"-"`
	XXX_sizecache             int32             `json:"-"`
}

func (m *NetworkServiceEndpoint) Reset()         { *m = NetworkServiceEndpoint{} }
func (m *NetworkServiceEndpoint) String() string { return proto.CompactTextString(m) }
func (*NetworkServiceEndpoint) ProtoMessage()    {}
func (*NetworkServiceEndpoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{4}
}

func (m *NetworkServiceEndpoint) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NetworkServiceEndpoint.Unmarshal(m, b)
}
func (m *NetworkServiceEndpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NetworkServiceEndpoint.Marshal(b, m, deterministic)
}
func (m *NetworkServiceEndpoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkServiceEndpoint.Merge(m, src)
}
func (m *NetworkServiceEndpoint) XXX_Size() int {
	return xxx_messageInfo_NetworkServiceEndpoint.Size(m)
}
func (m *NetworkServiceEndpoint) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkServiceEndpoint.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkServiceEndpoint proto.InternalMessageInfo

func (m *NetworkServiceEndpoint) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *NetworkServiceEndpoint) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

func (m *NetworkServiceEndpoint) GetNetworkServiceName() string {
	if m != nil {
		return m.NetworkServiceName
	}
	return ""
}

func (m *NetworkServiceEndpoint) GetNetworkServiceManagerName() string {
	if m != nil {
		return m.NetworkServiceManagerName
	}
	return ""
}

func (m *NetworkServiceEndpoint) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *NetworkServiceEndpoint) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

type FindNetworkServiceRequest struct {
	NetworkServiceName   string   `protobuf:"bytes,1,opt,name=network_service_name,json=networkServiceName,proto3" json:"network_service_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FindNetworkServiceRequest) Reset()         { *m = FindNetworkServiceRequest{} }
func (m *FindNetworkServiceRequest) String() string { return proto.CompactTextString(m) }
func (*FindNetworkServiceRequest) ProtoMessage()    {}
func (*FindNetworkServiceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{5}
}

func (m *FindNetworkServiceRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindNetworkServiceRequest.Unmarshal(m, b)
}
func (m *FindNetworkServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindNetworkServiceRequest.Marshal(b, m, deterministic)
}
func (m *FindNetworkServiceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindNetworkServiceRequest.Merge(m, src)
}
func (m *FindNetworkServiceRequest) XXX_Size() int {
	return xxx_messageInfo_FindNetworkServiceRequest.Size(m)
}
func (m *FindNetworkServiceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FindNetworkServiceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FindNetworkServiceRequest proto.InternalMessageInfo

func (m *FindNetworkServiceRequest) GetNetworkServiceName() string {
	if m != nil {
		return m.NetworkServiceName
	}
	return ""
}

type FindNetworkServiceResponse struct {
	Payload                 string                            `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	NetworkService          *NetworkService                   `protobuf:"bytes,2,opt,name=network_service,json=networkService,proto3" json:"network_service,omitempty"`
	NetworkServiceManagers  map[string]*NetworkServiceManager `protobuf:"bytes,3,rep,name=network_service_managers,json=networkServiceManagers,proto3" json:"network_service_managers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NetworkServiceEndpoints []*NetworkServiceEndpoint         `protobuf:"bytes,4,rep,name=network_service_endpoints,json=networkServiceEndpoints,proto3" json:"network_service_endpoints,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                          `json:"-"`
	XXX_unrecognized        []byte                            `json:"-"`
	XXX_sizecache           int32                             `json:"-"`
}

func (m *FindNetworkServiceResponse) Reset()         { *m = FindNetworkServiceResponse{} }
func (m *FindNetworkServiceResponse) String() string { return proto.CompactTextString(m) }
func (*FindNetworkServiceResponse) ProtoMessage()    {}
func (*FindNetworkServiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{6}
}

func (m *FindNetworkServiceResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FindNetworkServiceResponse.Unmarshal(m, b)
}
func (m *FindNetworkServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FindNetworkServiceResponse.Marshal(b, m, deterministic)
}
func (m *FindNetworkServiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FindNetworkServiceResponse.Merge(m, src)
}
func (m *FindNetworkServiceResponse) XXX_Size() int {
	return xxx_messageInfo_FindNetworkServiceResponse.Size(m)
}
func (m *FindNetworkServiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FindNetworkServiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FindNetworkServiceResponse proto.InternalMessageInfo

func (m *FindNetworkServiceResponse) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

func (m *FindNetworkServiceResponse) GetNetworkService() *NetworkService {
	if m != nil {
		return m.NetworkService
	}
	return nil
}

func (m *FindNetworkServiceResponse) GetNetworkServiceManagers() map[string]*NetworkServiceManager {
	if m != nil {
		return m.NetworkServiceManagers
	}
	return nil
}

func (m *FindNetworkServiceResponse) GetNetworkServiceEndpoints() []*NetworkServiceEndpoint {
	if m != nil {
		return m.NetworkServiceEndpoints
	}
	return nil
}

type NSERegistration struct {
	NetworkService         *NetworkService         `protobuf:"bytes,1,opt,name=network_service,json=networkService,proto3" json:"network_service,omitempty"`
	NetworkServiceManager  *NetworkServiceManager  `protobuf:"bytes,2,opt,name=network_service_manager,json=networkServiceManager,proto3" json:"network_service_manager,omitempty"`
	NetworkServiceEndpoint *NetworkServiceEndpoint `protobuf:"bytes,3,opt,name=network_service_endpoint,json=networkServiceEndpoint,proto3" json:"network_service_endpoint,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}                `json:"-"`
	XXX_unrecognized       []byte                  `json:"-"`
	XXX_sizecache          int32                   `json:"-"`
}

func (m *NSERegistration) Reset()         { *m = NSERegistration{} }
func (m *NSERegistration) String() string { return proto.CompactTextString(m) }
func (*NSERegistration) ProtoMessage()    {}
func (*NSERegistration) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{7}
}

func (m *NSERegistration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NSERegistration.Unmarshal(m, b)
}
func (m *NSERegistration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NSERegistration.Marshal(b, m, deterministic)
}
func (m *NSERegistration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NSERegistration.Merge(m, src)
}
func (m *NSERegistration) XXX_Size() int {
	return xxx_messageInfo_NSERegistration.Size(m)
}
func (m *NSERegistration) XXX_DiscardUnknown() {
	xxx_messageInfo_NSERegistration.DiscardUnknown(m)
}

var xxx_messageInfo_NSERegistration proto.InternalMessageInfo

func (m *NSERegistration) GetNetworkService() *NetworkService {
	if m != nil {
		return m.NetworkService
	}
	return nil
}

func (m *NSERegistration) GetNetworkServiceManager() *NetworkServiceManager {
	if m != nil {
		return m.NetworkServiceManager
	}
	return nil
}

func (m *NSERegistration) GetNetworkServiceEndpoint() *NetworkServiceEndpoint {
	if m != nil {
		return m.NetworkServiceEndpoint
	}
	return nil
}

type RemoveNSERequest struct {
	NetworkServiceEndpointName string   `protobuf:"bytes,1,opt,name=network_service_endpoint_name,json=networkServiceEndpointName,proto3" json:"network_service_endpoint_name,omitempty"`
	XXX_NoUnkeyedLiteral       struct{} `json:"-"`
	XXX_unrecognized           []byte   `json:"-"`
	XXX_sizecache              int32    `json:"-"`
}

func (m *RemoveNSERequest) Reset()         { *m = RemoveNSERequest{} }
func (m *RemoveNSERequest) String() string { return proto.CompactTextString(m) }
func (*RemoveNSERequest) ProtoMessage()    {}
func (*RemoveNSERequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{8}
}

func (m *RemoveNSERequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RemoveNSERequest.Unmarshal(m, b)
}
func (m *RemoveNSERequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RemoveNSERequest.Marshal(b, m, deterministic)
}
func (m *RemoveNSERequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveNSERequest.Merge(m, src)
}
func (m *RemoveNSERequest) XXX_Size() int {
	return xxx_messageInfo_RemoveNSERequest.Size(m)
}
func (m *RemoveNSERequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveNSERequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveNSERequest proto.InternalMessageInfo

func (m *RemoveNSERequest) GetNetworkServiceEndpointName() string {
	if m != nil {
		return m.NetworkServiceEndpointName
	}
	return ""
}

type NetworkServiceEndpointList struct {
	NetworkServiceEndpoints []*NetworkServiceEndpoint `protobuf:"bytes,1,rep,name=network_service_endpoints,json=networkServiceEndpoints,proto3" json:"network_service_endpoints,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                  `json:"-"`
	XXX_unrecognized        []byte                    `json:"-"`
	XXX_sizecache           int32                     `json:"-"`
}

func (m *NetworkServiceEndpointList) Reset()         { *m = NetworkServiceEndpointList{} }
func (m *NetworkServiceEndpointList) String() string { return proto.CompactTextString(m) }
func (*NetworkServiceEndpointList) ProtoMessage()    {}
func (*NetworkServiceEndpointList) Descriptor() ([]byte, []int) {
	return fileDescriptor_41af05d40a615591, []int{9}
}

func (m *NetworkServiceEndpointList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NetworkServiceEndpointList.Unmarshal(m, b)
}
func (m *NetworkServiceEndpointList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NetworkServiceEndpointList.Marshal(b, m, deterministic)
}
func (m *NetworkServiceEndpointList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkServiceEndpointList.Merge(m, src)
}
func (m *NetworkServiceEndpointList) XXX_Size() int {
	return xxx_messageInfo_NetworkServiceEndpointList.Size(m)
}
func (m *NetworkServiceEndpointList) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkServiceEndpointList.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkServiceEndpointList proto.InternalMessageInfo

func (m *NetworkServiceEndpointList) GetNetworkServiceEndpoints() []*NetworkServiceEndpoint {
	if m != nil {
		return m.NetworkServiceEndpoints
	}
	return nil
}

func init() {
	proto.RegisterType((*NetworkService)(nil), "registry.NetworkService")
	proto.RegisterType((*Match)(nil), "registry.Match")
	proto.RegisterMapType((map[string]string)(nil), "registry.Match.SourceSelectorEntry")
	proto.RegisterType((*Destination)(nil), "registry.Destination")
	proto.RegisterMapType((map[string]string)(nil), "registry.Destination.DestinationSelectorEntry")
	proto.RegisterType((*NetworkServiceManager)(nil), "registry.NetworkServiceManager")
	proto.RegisterType((*NetworkServiceEndpoint)(nil), "registry.NetworkServiceEndpoint")
	proto.RegisterMapType((map[string]string)(nil), "registry.NetworkServiceEndpoint.LabelsEntry")
	proto.RegisterType((*FindNetworkServiceRequest)(nil), "registry.FindNetworkServiceRequest")
	proto.RegisterType((*FindNetworkServiceResponse)(nil), "registry.FindNetworkServiceResponse")
	proto.RegisterMapType((map[string]*NetworkServiceManager)(nil), "registry.FindNetworkServiceResponse.NetworkServiceManagersEntry")
	proto.RegisterType((*NSERegistration)(nil), "registry.NSERegistration")
	proto.RegisterType((*RemoveNSERequest)(nil), "registry.RemoveNSERequest")
	proto.RegisterType((*NetworkServiceEndpointList)(nil), "registry.NetworkServiceEndpointList")
}

func init() { proto.RegisterFile("registry.proto", fileDescriptor_41af05d40a615591) }

var fileDescriptor_41af05d40a615591 = []byte{
	// 811 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4d, 0x6e, 0xd3, 0x40,
	0x14, 0xd6, 0x24, 0x6d, 0x4a, 0x9f, 0x21, 0xa9, 0xa6, 0x6d, 0xea, 0x18, 0x10, 0x51, 0xca, 0x22,
	0x48, 0x60, 0xaa, 0x20, 0x24, 0x60, 0x53, 0x4a, 0x9b, 0xb2, 0x20, 0x09, 0x92, 0x03, 0x42, 0x42,
	0x48, 0x91, 0x9b, 0x0c, 0xa9, 0xa9, 0xff, 0xf0, 0x4c, 0x52, 0xdc, 0x1b, 0x70, 0x03, 0x0e, 0xc1,
	0x1d, 0x58, 0xb2, 0xed, 0x3d, 0xb8, 0x04, 0xf2, 0x8c, 0x13, 0xdb, 0x89, 0xdd, 0x34, 0xea, 0xa6,
	0x9a, 0x9f, 0xf7, 0xbe, 0xf7, 0xe6, 0xfb, 0x3e, 0xbf, 0x06, 0x8a, 0x1e, 0x19, 0x1a, 0x94, 0x79,
	0xbe, 0xea, 0x7a, 0x0e, 0x73, 0xf0, 0xad, 0xc9, 0x5e, 0x91, 0x5d, 0xe6, 0xbb, 0x84, 0x3e, 0x25,
	0x96, 0xcb, 0x7c, 0xf1, 0x57, 0xc4, 0x28, 0xd5, 0xf0, 0x86, 0x19, 0x16, 0xa1, 0x4c, 0xb7, 0xdc,
	0x68, 0x25, 0x22, 0x6a, 0x06, 0x14, 0x3b, 0x84, 0x9d, 0x3b, 0xde, 0x59, 0x97, 0x78, 0x63, 0xa3,
	0x4f, 0x30, 0x86, 0x15, 0x5b, 0xb7, 0x88, 0x8c, 0xaa, 0xa8, 0xbe, 0xae, 0xf1, 0x35, 0x96, 0x61,
	0xcd, 0xd5, 0x7d, 0xd3, 0xd1, 0x07, 0x72, 0x8e, 0x1f, 0x4f, 0xb6, 0xf8, 0x11, 0xac, 0x59, 0x3a,
	0xeb, 0x9f, 0x12, 0x2a, 0xe7, 0xab, 0xf9, 0xba, 0xd4, 0x28, 0xa9, 0xd3, 0x3e, 0xdb, 0xc1, 0x85,
	0x36, 0xb9, 0xaf, 0xfd, 0x45, 0xb0, 0xca, 0x8f, 0x70, 0x0b, 0x4a, 0xd4, 0x19, 0x79, 0x7d, 0xd2,
	0xa3, 0xc4, 0x24, 0x7d, 0xe6, 0x78, 0x32, 0xe2, 0xc9, 0xbb, 0x33, 0xc9, 0x6a, 0x97, 0x87, 0x75,
	0xc3, 0xa8, 0xa6, 0xcd, 0x3c, 0x5f, 0x2b, 0xd2, 0xc4, 0x21, 0x7e, 0x02, 0x05, 0xcf, 0x19, 0x31,
	0x42, 0xe5, 0x1c, 0x07, 0xd9, 0x8e, 0x40, 0x8e, 0x08, 0x65, 0x86, 0xad, 0x33, 0xc3, 0xb1, 0xb5,
	0x30, 0x48, 0x39, 0x80, 0xcd, 0x14, 0x54, 0xbc, 0x01, 0xf9, 0x33, 0xe2, 0x87, 0xaf, 0x0e, 0x96,
	0x78, 0x0b, 0x56, 0xc7, 0xba, 0x39, 0x22, 0xe1, 0x93, 0xc5, 0xe6, 0x55, 0xee, 0x05, 0xaa, 0x5d,
	0x22, 0x90, 0x62, 0xd0, 0x58, 0x87, 0xad, 0x41, 0xb4, 0x9d, 0x7d, 0x94, 0x9a, 0xda, 0x4f, 0x7c,
	0x9d, 0x7c, 0xdf, 0xe6, 0x60, 0xfe, 0x06, 0x97, 0xa1, 0x70, 0x4e, 0x8c, 0xe1, 0x29, 0xe3, 0xdd,
	0xdc, 0xd1, 0xc2, 0x9d, 0x72, 0x0c, 0x72, 0x16, 0xd0, 0x52, 0x4f, 0xfa, 0x85, 0x60, 0x3b, 0x69,
	0x84, 0xb6, 0x6e, 0xeb, 0x43, 0xe2, 0xa5, 0xfa, 0x61, 0x03, 0xf2, 0x23, 0xcf, 0x0c, 0x51, 0x82,
	0x25, 0x3e, 0x84, 0x12, 0xf9, 0xe1, 0x1a, 0x9e, 0x60, 0x20, 0x70, 0x99, 0x9c, 0xaf, 0xa2, 0xba,
	0xd4, 0x50, 0xd4, 0xa1, 0xe3, 0x0c, 0x4d, 0x22, 0xfc, 0x76, 0x32, 0xfa, 0xaa, 0x7e, 0x98, 0x58,
	0x50, 0x2b, 0x46, 0x29, 0xc1, 0x61, 0xd0, 0x1e, 0x65, 0x3a, 0x23, 0xf2, 0x8a, 0x68, 0x8f, 0x6f,
	0x6a, 0x97, 0x39, 0x28, 0x27, 0x5b, 0x6b, 0xda, 0x03, 0xd7, 0x31, 0x6c, 0xb6, 0xa4, 0x57, 0xf7,
	0x60, 0xcb, 0x16, 0x38, 0x3d, 0x2a, 0x80, 0x7a, 0x3c, 0x3b, 0xcf, 0xc3, 0xb0, 0x9d, 0xa8, 0xd1,
	0x09, 0xb0, 0xf6, 0xe1, 0xde, 0x6c, 0x86, 0x25, 0x68, 0x11, 0x99, 0xa2, 0xcf, 0x8a, 0x9d, 0x46,
	0x1c, 0x07, 0x38, 0x82, 0x82, 0xa9, 0x9f, 0x10, 0x93, 0xca, 0xab, 0xdc, 0x0b, 0x8f, 0x23, 0x2f,
	0xa4, 0x3f, 0x49, 0x6d, 0xf1, 0x70, 0xe1, 0x84, 0x30, 0x37, 0xe2, 0xa5, 0x10, 0xe3, 0x45, 0x79,
	0x09, 0x52, 0x2c, 0x78, 0x29, 0xb5, 0xdb, 0x50, 0x39, 0x36, 0xec, 0x41, 0xb2, 0x05, 0x8d, 0x7c,
	0x1f, 0x11, 0xca, 0x32, 0x69, 0x42, 0x59, 0x34, 0xd5, 0xfe, 0xe4, 0x41, 0x49, 0xc3, 0xa3, 0xae,
	0x63, 0xd3, 0x84, 0x22, 0x28, 0xa9, 0xc8, 0x01, 0x94, 0x66, 0x4a, 0xf1, 0x5e, 0xa5, 0x86, 0x9c,
	0xc5, 0x93, 0x56, 0x4c, 0xd6, 0xc7, 0x17, 0x20, 0x67, 0x48, 0x34, 0x99, 0x48, 0xaf, 0x23, 0xac,
	0xec, 0x26, 0xd5, 0x54, 0xf3, 0x87, 0x3a, 0x94, 0x53, 0x05, 0xa6, 0xf8, 0x0b, 0x54, 0x66, 0x6b,
	0x93, 0x50, 0x47, 0x2a, 0xaf, 0xf0, 0xe2, 0xd5, 0x45, 0x82, 0x6b, 0x3b, 0x76, 0xea, 0x39, 0x55,
	0xbe, 0xc1, 0xdd, 0x2b, 0x9a, 0x4a, 0xd1, 0xfb, 0x79, 0x5c, 0x6f, 0xa9, 0xf1, 0x20, 0xab, 0x74,
	0x88, 0x13, 0x37, 0xc4, 0xcf, 0x1c, 0x94, 0x3a, 0xdd, 0xa6, 0x26, 0x12, 0xc4, 0x54, 0x4b, 0x11,
	0x07, 0x2d, 0x29, 0xce, 0x27, 0xd8, 0xc9, 0x10, 0xe7, 0xba, 0x3d, 0x6e, 0xa7, 0x52, 0x8f, 0x3f,
	0xcf, 0xab, 0x3e, 0x61, 0x3e, 0x9c, 0x3b, 0x8b, 0x89, 0x2f, 0xa7, 0x13, 0x5f, 0xfb, 0x08, 0x1b,
	0x1a, 0xb1, 0x9c, 0x31, 0xe1, 0x84, 0x88, 0x6f, 0xe2, 0x00, 0xee, 0x67, 0xd5, 0x8b, 0x7f, 0x1c,
	0x4a, 0x3a, 0x24, 0xff, 0x48, 0x2e, 0x40, 0x49, 0x6f, 0xa4, 0x65, 0x50, 0x76, 0xb5, 0x95, 0xd0,
	0x0d, 0xad, 0xd4, 0xf8, 0x87, 0x66, 0x47, 0x68, 0xa8, 0xb4, 0x8f, 0x0f, 0x41, 0x12, 0x6b, 0xe2,
	0x75, 0xba, 0x4d, 0x5c, 0x89, 0x15, 0x49, 0xfa, 0x41, 0xc9, 0xbe, 0xc2, 0xef, 0xa0, 0xf4, 0x66,
	0x64, 0x9e, 0xdd, 0x18, 0xa8, 0x8e, 0xf6, 0x10, 0xde, 0x87, 0xf5, 0x29, 0xff, 0x58, 0x89, 0x62,
	0x67, 0x45, 0x51, 0xca, 0x73, 0xff, 0x5a, 0x9a, 0xc1, 0x6f, 0x9f, 0xc6, 0x05, 0xec, 0x24, 0x1f,
	0x7b, 0x64, 0xd0, 0xbe, 0x33, 0x26, 0x9e, 0x8f, 0x7b, 0x80, 0xe7, 0x67, 0x00, 0xde, 0xbd, 0x7a,
	0x42, 0x88, 0x6a, 0x0f, 0xaf, 0x33, 0x46, 0x1a, 0xbf, 0x11, 0x48, 0x1d, 0x6a, 0x4d, 0xe9, 0x7d,
	0x1f, 0xa7, 0xb7, 0x8d, 0x17, 0xf9, 0x5d, 0x59, 0x14, 0x80, 0x5b, 0x70, 0xfb, 0x2d, 0x61, 0x53,
	0x69, 0x71, 0x06, 0x09, 0xf1, 0x76, 0xb3, 0x6d, 0x77, 0x52, 0xe0, 0x59, 0xcf, 0xfe, 0x07, 0x00,
	0x00, 0xff, 0xff, 0x10, 0xd8, 0x69, 0xfe, 0x5d, 0x0a, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// NetworkServiceRegistryClient is the client API for NetworkServiceRegistry service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NetworkServiceRegistryClient interface {
	RegisterNSE(ctx context.Context, in *NSERegistration, opts ...grpc.CallOption) (*NSERegistration, error)
	BulkRegisterNSE(ctx context.Context, opts ...grpc.CallOption) (NetworkServiceRegistry_BulkRegisterNSEClient, error)
	RemoveNSE(ctx context.Context, in *RemoveNSERequest, opts ...grpc.CallOption) (*empty.Empty, error)
}

type networkServiceRegistryClient struct {
	cc grpc.ClientConnInterface
}

func NewNetworkServiceRegistryClient(cc grpc.ClientConnInterface) NetworkServiceRegistryClient {
	return &networkServiceRegistryClient{cc}
}

func (c *networkServiceRegistryClient) RegisterNSE(ctx context.Context, in *NSERegistration, opts ...grpc.CallOption) (*NSERegistration, error) {
	out := new(NSERegistration)
	err := c.cc.Invoke(ctx, "/registry.NetworkServiceRegistry/RegisterNSE", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkServiceRegistryClient) BulkRegisterNSE(ctx context.Context, opts ...grpc.CallOption) (NetworkServiceRegistry_BulkRegisterNSEClient, error) {
	stream, err := c.cc.NewStream(ctx, &_NetworkServiceRegistry_serviceDesc.Streams[0], "/registry.NetworkServiceRegistry/BulkRegisterNSE", opts...)
	if err != nil {
		return nil, err
	}
	x := &networkServiceRegistryBulkRegisterNSEClient{stream}
	return x, nil
}

type NetworkServiceRegistry_BulkRegisterNSEClient interface {
	Send(*NSERegistration) error
	Recv() (*NSERegistration, error)
	grpc.ClientStream
}

type networkServiceRegistryBulkRegisterNSEClient struct {
	grpc.ClientStream
}

func (x *networkServiceRegistryBulkRegisterNSEClient) Send(m *NSERegistration) error {
	return x.ClientStream.SendMsg(m)
}

func (x *networkServiceRegistryBulkRegisterNSEClient) Recv() (*NSERegistration, error) {
	m := new(NSERegistration)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *networkServiceRegistryClient) RemoveNSE(ctx context.Context, in *RemoveNSERequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/registry.NetworkServiceRegistry/RemoveNSE", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NetworkServiceRegistryServer is the server API for NetworkServiceRegistry service.
type NetworkServiceRegistryServer interface {
	RegisterNSE(context.Context, *NSERegistration) (*NSERegistration, error)
	BulkRegisterNSE(NetworkServiceRegistry_BulkRegisterNSEServer) error
	RemoveNSE(context.Context, *RemoveNSERequest) (*empty.Empty, error)
}

// UnimplementedNetworkServiceRegistryServer can be embedded to have forward compatible implementations.
type UnimplementedNetworkServiceRegistryServer struct {
}

func (*UnimplementedNetworkServiceRegistryServer) RegisterNSE(ctx context.Context, req *NSERegistration) (*NSERegistration, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterNSE not implemented")
}
func (*UnimplementedNetworkServiceRegistryServer) BulkRegisterNSE(srv NetworkServiceRegistry_BulkRegisterNSEServer) error {
	return status.Errorf(codes.Unimplemented, "method BulkRegisterNSE not implemented")
}
func (*UnimplementedNetworkServiceRegistryServer) RemoveNSE(ctx context.Context, req *RemoveNSERequest) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveNSE not implemented")
}

func RegisterNetworkServiceRegistryServer(s *grpc.Server, srv NetworkServiceRegistryServer) {
	s.RegisterService(&_NetworkServiceRegistry_serviceDesc, srv)
}

func _NetworkServiceRegistry_RegisterNSE_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NSERegistration)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkServiceRegistryServer).RegisterNSE(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/registry.NetworkServiceRegistry/RegisterNSE",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkServiceRegistryServer).RegisterNSE(ctx, req.(*NSERegistration))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkServiceRegistry_BulkRegisterNSE_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(NetworkServiceRegistryServer).BulkRegisterNSE(&networkServiceRegistryBulkRegisterNSEServer{stream})
}

type NetworkServiceRegistry_BulkRegisterNSEServer interface {
	Send(*NSERegistration) error
	Recv() (*NSERegistration, error)
	grpc.ServerStream
}

type networkServiceRegistryBulkRegisterNSEServer struct {
	grpc.ServerStream
}

func (x *networkServiceRegistryBulkRegisterNSEServer) Send(m *NSERegistration) error {
	return x.ServerStream.SendMsg(m)
}

func (x *networkServiceRegistryBulkRegisterNSEServer) Recv() (*NSERegistration, error) {
	m := new(NSERegistration)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _NetworkServiceRegistry_RemoveNSE_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveNSERequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkServiceRegistryServer).RemoveNSE(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/registry.NetworkServiceRegistry/RemoveNSE",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkServiceRegistryServer).RemoveNSE(ctx, req.(*RemoveNSERequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NetworkServiceRegistry_serviceDesc = grpc.ServiceDesc{
	ServiceName: "registry.NetworkServiceRegistry",
	HandlerType: (*NetworkServiceRegistryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterNSE",
			Handler:    _NetworkServiceRegistry_RegisterNSE_Handler,
		},
		{
			MethodName: "RemoveNSE",
			Handler:    _NetworkServiceRegistry_RemoveNSE_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "BulkRegisterNSE",
			Handler:       _NetworkServiceRegistry_BulkRegisterNSE_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "registry.proto",
}

// NetworkServiceDiscoveryClient is the client API for NetworkServiceDiscovery service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NetworkServiceDiscoveryClient interface {
	FindNetworkService(ctx context.Context, in *FindNetworkServiceRequest, opts ...grpc.CallOption) (*FindNetworkServiceResponse, error)
}

type networkServiceDiscoveryClient struct {
	cc grpc.ClientConnInterface
}

func NewNetworkServiceDiscoveryClient(cc grpc.ClientConnInterface) NetworkServiceDiscoveryClient {
	return &networkServiceDiscoveryClient{cc}
}

func (c *networkServiceDiscoveryClient) FindNetworkService(ctx context.Context, in *FindNetworkServiceRequest, opts ...grpc.CallOption) (*FindNetworkServiceResponse, error) {
	out := new(FindNetworkServiceResponse)
	err := c.cc.Invoke(ctx, "/registry.NetworkServiceDiscovery/FindNetworkService", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NetworkServiceDiscoveryServer is the server API for NetworkServiceDiscovery service.
type NetworkServiceDiscoveryServer interface {
	FindNetworkService(context.Context, *FindNetworkServiceRequest) (*FindNetworkServiceResponse, error)
}

// UnimplementedNetworkServiceDiscoveryServer can be embedded to have forward compatible implementations.
type UnimplementedNetworkServiceDiscoveryServer struct {
}

func (*UnimplementedNetworkServiceDiscoveryServer) FindNetworkService(ctx context.Context, req *FindNetworkServiceRequest) (*FindNetworkServiceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FindNetworkService not implemented")
}

func RegisterNetworkServiceDiscoveryServer(s *grpc.Server, srv NetworkServiceDiscoveryServer) {
	s.RegisterService(&_NetworkServiceDiscovery_serviceDesc, srv)
}

func _NetworkServiceDiscovery_FindNetworkService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FindNetworkServiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkServiceDiscoveryServer).FindNetworkService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/registry.NetworkServiceDiscovery/FindNetworkService",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkServiceDiscoveryServer).FindNetworkService(ctx, req.(*FindNetworkServiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NetworkServiceDiscovery_serviceDesc = grpc.ServiceDesc{
	ServiceName: "registry.NetworkServiceDiscovery",
	HandlerType: (*NetworkServiceDiscoveryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FindNetworkService",
			Handler:    _NetworkServiceDiscovery_FindNetworkService_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "registry.proto",
}

// NsmRegistryClient is the client API for NsmRegistry service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NsmRegistryClient interface {
	RegisterNSM(ctx context.Context, in *NetworkServiceManager, opts ...grpc.CallOption) (*NetworkServiceManager, error)
	GetEndpoints(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*NetworkServiceEndpointList, error)
}

type nsmRegistryClient struct {
	cc grpc.ClientConnInterface
}

func NewNsmRegistryClient(cc grpc.ClientConnInterface) NsmRegistryClient {
	return &nsmRegistryClient{cc}
}

func (c *nsmRegistryClient) RegisterNSM(ctx context.Context, in *NetworkServiceManager, opts ...grpc.CallOption) (*NetworkServiceManager, error) {
	out := new(NetworkServiceManager)
	err := c.cc.Invoke(ctx, "/registry.NsmRegistry/RegisterNSM", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nsmRegistryClient) GetEndpoints(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*NetworkServiceEndpointList, error) {
	out := new(NetworkServiceEndpointList)
	err := c.cc.Invoke(ctx, "/registry.NsmRegistry/GetEndpoints", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NsmRegistryServer is the server API for NsmRegistry service.
type NsmRegistryServer interface {
	RegisterNSM(context.Context, *NetworkServiceManager) (*NetworkServiceManager, error)
	GetEndpoints(context.Context, *empty.Empty) (*NetworkServiceEndpointList, error)
}

// UnimplementedNsmRegistryServer can be embedded to have forward compatible implementations.
type UnimplementedNsmRegistryServer struct {
}

func (*UnimplementedNsmRegistryServer) RegisterNSM(ctx context.Context, req *NetworkServiceManager) (*NetworkServiceManager, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterNSM not implemented")
}
func (*UnimplementedNsmRegistryServer) GetEndpoints(ctx context.Context, req *empty.Empty) (*NetworkServiceEndpointList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEndpoints not implemented")
}

func RegisterNsmRegistryServer(s *grpc.Server, srv NsmRegistryServer) {
	s.RegisterService(&_NsmRegistry_serviceDesc, srv)
}

func _NsmRegistry_RegisterNSM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkServiceManager)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NsmRegistryServer).RegisterNSM(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/registry.NsmRegistry/RegisterNSM",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NsmRegistryServer).RegisterNSM(ctx, req.(*NetworkServiceManager))
	}
	return interceptor(ctx, in, info, handler)
}

func _NsmRegistry_GetEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NsmRegistryServer).GetEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/registry.NsmRegistry/GetEndpoints",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NsmRegistryServer).GetEndpoints(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _NsmRegistry_serviceDesc = grpc.ServiceDesc{
	ServiceName: "registry.NsmRegistry",
	HandlerType: (*NsmRegistryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterNSM",
			Handler:    _NsmRegistry_RegisterNSM_Handler,
		},
		{
			MethodName: "GetEndpoints",
			Handler:    _NsmRegistry_GetEndpoints_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "registry.proto",
}


text:
/*global require*/
'use strict';

require.config({
    shim: {
        underscore: {
            exports: '_'
        },
        backbone: {
            deps: [
                'underscore',
                'jquery'
            ],
            exports: 'Backbone'
        }
    },
    paths: {
        jquery: '../bower_components/jquery/jquery',
        backbone: '../bower_components/backbone/backbone',
        underscore: '../bower_components/underscore/underscore',
        obscura: '../bower_components/backbone.obscura/backbone.obscura'
    }
});

require([
    'backbone', 'routes/movies'
], function (Backbone, MoviesRouter) {
    var router = new MoviesRouter();
    Backbone.history.start();
});


text:
package com.github.commandsconsolegui.spAppOs.misc;

import java.util.Arrays;
import java.util.HashMap;

/**
 *
 * @author Henrique Abdalla <https://github.com/AquariusPower><https://sourceforge.net/u/teike/profile/>
 *
 */
public class ManageDebugDataI {
	private static ManageDebugDataI instance = new ManageDebugDataI();
	public static ManageDebugDataI i(){return instance;}

	public static enum EDbgStkOrigin{
		Constructed,
		Discarded,

		LastSetValue,

		LastCall,

		;

		public String s() {return toString();}
	}

	public static class DebugData{
		HashMap<String,DebugInfo> hm = new HashMap<String,DebugInfo>();

		public DebugInfo get(String eso){
			DebugInfo di = hm.get(eso); //searches

			if(di==null){ //creates
				di=new DebugInfo();
				hm.put(eso,di);
			}

			return di;
		}

		public void setStackForCurrentMethod(DebugInfo di, int iIncIndex){
			StackTraceElement[] aste = Thread.currentThread().getStackTrace();
			/**
			 * skips:
			 * 0 - getStackTrace()
			 * 1 - this method
			 */
			aste = Arrays.copyOfRange(aste, 2+iIncIndex, aste.length);
			di.rh.setHolded(aste);
		}
	}

	private static class DebugInfo{
		EDbgStkOrigin eso;

		/**
		 * {@link RefHolder} to improve stack readability on IDE
		 */
		RefHolder<StackTraceElement[]> rh=new RefHolder<StackTraceElement[]>(null);
	}

	/**
	 * use like if(RunMode.bValidateDevCode)this.di=DebugData.i().(this.di,...)
	 * @param diExisting
	 * @param eso
	 * @return
	 */
	public DebugData setStack(DebugData dbgExisting, EDbgStkOrigin eso){
		return setStack(dbgExisting,eso.s(),1);
	}
	/**
	 * will use as key the fully qualified caller method name
	 * @param dbgExisting
	 * @return
	 */
	public DebugData setStack(DebugData dbgExisting){
		return setStack(dbgExisting, Thread.currentThread().getStackTrace()[2].toString(), 1);
	}
	/**
	 *
	 * @param dbgExisting
	 * @param strKey
	 * @return
	 */
	public DebugData setStack(DebugData dbgExisting, String strKey){
		return setStack(dbgExisting,strKey,1);
	}
	/**
	 * @DevSelfNote IMPORTANT!!! all other related methods here must call this one DIRECTLY!!! because of the stack index!
	 *
	 * @param dbgExisting
	 * @param str
	 * @param iIncStackIndex
	 * @return
	 */
	private DebugData setStack(DebugData dbgExisting, String str, int iIncStackIndex){
		DebugData dbg = dbgExisting;
		if(dbg==null)dbg=new DebugData();
		dbg.setStackForCurrentMethod(dbg.get(str), iIncStackIndex+1);

		return dbg;
	}

	/**
	 *
	 * @param dbg
	 * @param eso
	 * @return {@link RefHolder} is more IDE readable than stack
	 */
	public RefHolder<StackTraceElement[]> getStack(DebugData dbg, EDbgStkOrigin eso){
		return getStack(dbg,eso.s());
	}
	public RefHolder<StackTraceElement[]> getStack(DebugData dbg, String eso){
		if(dbg==null)return null;
		DebugInfo di = dbg.get(eso);
		if(di==null)return null;
		return di.rh;
	}
}


text:
<?php

namespace Bundle\CommonBundle\Entity\Status;

use Doctrine\ORM\Mapping as ORM;
use Bundle\CommonBundle\Entity\Core\BaseEntity;

/**
 * Status
 *
 * @ORM\Table()
 * @ORM\Entity(repositoryClass="Bundle\CommonBundle\Entity\Status\StatusRepository")
 */
class Status extends BaseEntity
{
    /**
     * @var integer
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(name="name", type="string", length=255)
     */
    private $name;

    /**
     * @var string
     *
     * @ORM\Column(name="description", type="text", nullable=true)
     */
    private $description;

    /**
     * @Bundle\CommonBundle\Annotations\isImage(relates="image")
     */
    private $fileImage;

    /**
     * @var string
     * @ORM\Column(name="image", type="string", length=255)
     */
    private $image;

    public function getFileImage()
    {
        return $this->fileImage;
    }

    public function setFileImage($fileImage)
    {
        $this->fileImage = $fileImage;
    }

    /**
     * Get id
     *
     * @return integer
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set name
     *
     * @param string $name
     * @return Status
     */
    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }

    /**
     * Get name
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Set description
     *
     * @param string $description
     * @return Status
     */
    public function setDescription($description)
    {
        $this->description = $description;

        return $this;
    }

    /**
     * Get description
     *
     * @return string
     */
    public function getDescription()
    {
        return $this->description;
    }

    /**
     * Set image
     *
     * @param string $image
     * @return Status
     */
    public function setImage($image)
    {
        $this->image = $image;

        return $this;
    }

    /**
     * Get image
     *
     * @return string
     */
    public function getImage()
    {
        return $this->image;
    }
}


text:
"""Script to download the enclosure of RSS/Atom feed items from a web client."""

__version__ = '1.0.0'


text:
using System.Windows.Media;

namespace CruPhysics.PhysicalObjects
{
    // ReSharper disable once InconsistentNaming
    public static class PhysicalObjectUIResources
    {
        public const int SelectedZIndex = 1000;
        public const int ControllerZIndex = 1001;

        public static Brush NormalStrokeBrush => Brushes.Black;
        public static Brush HoverStrokeBrush => Brushes.Red;
        public static Brush SelectStrokeBrush => Brushes.Blue;

        public const double NormalStrokeThickness = 1.0;
        public const double HoverStrokeThickness = 2.0;
        public const double SelectStrokeThickness = 2.0;
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!--A great place to start to interpert all of this is http://msdn.microsoft.com/en-us/library/ie/dn455106.aspx -->
<browserconfig>
  <msapplication>
    <tile>
      <!--The image here must be at least 56px x 56px, but the recommended size is 128px x 128px. The maximum size you can use is 1024px x 1024px-->
      <square70x70logo src="img/smalltile.png"/>
      <!--This image must be at least 120px x 120px, but the recommended size is 270px x 270px. The maximum available size is 1024px x 1024px-->
      <square150x150logo src="img/mediumtile.png"/>
      <!--The image referenced in the below tag must be at least 280px x 120px, but the recommended size is 558px x 270px. The maximum possible size is 1024px x 1024px-->
      <wide310x150logo src="img/widetile.png"/>
      <!--The image for the largest tile size must be at least 310px x 310px, but the recommended size is 558px x 558px-->
      <square310x310logo src="img/largetile.png"/>
      <!--You can define the background color for the tile with a hex value in this next tag-->
      <TileColor>#FFFFFF</TileColor>
    </tile>
    <!--This next part is what makes a live tile. You can specify 1 notification per file, and you can specify up to 5 files. You can find an example schema for a notification in the same place in this project as the directory specified in the first tag-->
    <notification>
      <polling-uri  src="windowsLiveTiles/example1.xml"/>
      <polling-uri2 src="windowsLiveTiles/example2.xml"/>
      <polling-uri3 src="windowsLiveTiles/example3.xml"/>
      <polling-uri4 src="windowsLiveTiles/example4.xml"/>
      <polling-uri5 src="windowsLiveTiles/example5.xml"/>
      <!--You can specify the frequency in minutes of how often Windows checks for any updates to any of the above schema files. You can use 30, 60, 360 (6 hours), 720 (12 hours), or 1440 (24 hours) intervals-->
      <frequency>30</frequency>
      <!--This specifies the tile sizes that can view notifications. You can use any integer 0-7, where 0 is no notifications are ever show, and 1 is notifications scroll on all possible tile sizes. For information on 2-7, you can visit the page linked at the top of this document-->
      <cycle>1</cycle>
    </notification>
  </msapplication>
</browserconfig>


text:
class Podcast < ActiveRecord::Base
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable
  has_many :episodes

  has_attached_file :thumbnail, styles: {
      thumb: '100x100>',
      square: '200x200#',
      medium: '300x300>'
  }
  validates_attachment_content_type :thumbnail, content_type: /\Aimage\/.*\Z/

end


text:
// ----------------------------------------------------------------------------
// Copyright 2007-2015, GeoTelematic Solutions, Inc.
// All rights reserved
// ----------------------------------------------------------------------------
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ----------------------------------------------------------------------------
// Description:
//  This class provides Tuples
// ----------------------------------------------------------------------------
// Change History:
//  2009/06/01  Martin D. Flynn
//     -Initial release
//  2013/04/08  Martin D. Flynn
//     -Added "Quad"
// ----------------------------------------------------------------------------
package org.opengts.util;

import java.util.*;

/**
*** Tuple a wrapper class for Tuples
**/

public class Tuple
{

    // ------------------------------------------------------------------------

    /**
    *** A wrapper for a single item
    **/
    public static class Single<AA>
    {
        public AA  a = null;
        public Single(AA a) {
            this.a = a;
        }
        public String toString() {
            return (this.a != null)? this.a.toString() : "";
        }
    }

    // ------------------------------------------------------------------------

    /**
    *** A wrapper for a pair of items
    **/
    public static class Pair<AA,BB>
    {
        public AA  a = null;
        public BB  b = null;
        public Pair(AA a, BB b) {
            this.a = a;
            this.b = b;
        }
        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append((this.a != null)? this.a.toString() : "");
            sb.append(",");
            sb.append((this.b != null)? this.b.toString() : "");
            return sb.toString();
        }
    }

    // ------------------------------------------------------------------------

    /**
    *** A wrapper for a triple of items
    **/
    public static class Triple<AA,BB,CC>
    {
        public AA  a = null;
        public BB  b = null;
        public CC  c = null;
        public Triple(AA a, BB b, CC c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append((this.a != null)? this.a.toString() : "");
            sb.append(",");
            sb.append((this.b != null)? this.b.toString() : "");
            sb.append(",");
            sb.append((this.c != null)? this.c.toString() : "");
            return sb.toString();
        }
    }

    // ------------------------------------------------------------------------

    /**
    *** A wrapper for a quadruple of items
    **/
    public static class Quad<AA,BB,CC,DD>
    {
        public AA  a = null;
        public BB  b = null;
        public CC  c = null;
        public DD  d = null;
        public Quad(AA a, BB b, CC c, DD d) {
            this.a = a;
            this.b = b;
            this.c = c;
            this.d = d;
        }
        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append((this.a != null)? this.a.toString() : "");
            sb.append(",");
            sb.append((this.b != null)? this.b.toString() : "");
            sb.append(",");
            sb.append((this.c != null)? this.c.toString() : "");
            sb.append(",");
            sb.append((this.d != null)? this.d.toString() : "");
            return sb.toString();
        }
    }

    // ------------------------------------------------------------------------

}


text:
It's a __presentation tool__
inspired by the idea behind `prezi.com`
and based on the __power of CSS3 transforms and transitions__ in modern browsers.


text:
using Caps.Consumer;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Http;
using Caps.Consumer.Model;

namespace DemoConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            DoStuff();

            Console.WriteLine("Drücke eine beliebige Taste um zu beenden...");
            Console.ReadKey();
        }

        static async void DoStuff()
        {
            using (var client = new CapsHttpClient(new Uri("http://localhost:57004"), "apircher", "p@ssword"))
            {
                var user = await client.GetUserInfo();
                Console.WriteLine("Logged in as: {0} {1}", user.FirstName, user.LastName);

                var websites = await client.GetWebsites();
                Console.WriteLine("Found {0} websites.", websites.Length);

                if (websites.Length == 0)
                    return;

                var website = await client.GetWebsite(websites.First().Id);
                Console.WriteLine("Selected: {0} ({1})", website.Name, website.Url);

                var siteMap = await client.GetCurrentSiteMap(websites.First().Id);
                Console.WriteLine("Current SiteMap Version: {0}", siteMap.Version);

                var rootNode = siteMap.SiteMapNodes.FirstOrDefault(n => n.ParentNodeId == null);
                if (rootNode == null)
                {
                    Console.WriteLine("Startseite nicht gefunden.");
                    return;
                }

                PrintSiteMapNode(rootNode);
            }
        }

        static void PrintSiteMapNode(DbSiteMapNode node, int level = 0)
        {
            String indent = new String(' ', level);
            Console.WriteLine(indent + "{0}: {1}", node.PermanentId, node.Name);

            if (node.ChildNodes != null)
            {
                foreach (var n in node.ChildNodes) PrintSiteMapNode(n, level + 1);
            }
        }
    }

    static class Utilities
    {
        public static async Task<Website[]> GetWebsites(this CapsHttpClient client)
        {
            var response = await client.GetAsync("api/websites");
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsAsync<Website[]>();
            return null;
        }

        public static async Task<Website> GetWebsite(this CapsHttpClient client, int websiteId)
        {
            var response = await client.GetAsync("api/websites/" + websiteId.ToString());
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsAsync<Website>();
            return null;
        }

        public static async Task<DbSiteMap> GetCurrentSiteMap(this CapsHttpClient client, int websiteId)
        {
            var response = await client.GetAsync("api/websites/" + websiteId.ToString() + "/sitemap");
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsAsync<DbSiteMap>();
            return null;
        }
    }
}


text:
@interface MWMAuthorizationOSMLoginViewController : MWMViewController

@end


text:
let fsMock = {};
jest.setMock('fs', {
  existsSync: path => typeof fsMock[path] !== 'undefined',
});
jest.mock('cwd/generators/test.js', () => 'test', { virtual: true });

const path = require('path');
const requireGenerator = require('../requireGenerator');

describe('generator/requireGenerator', () => {
  beforeEach(() => {
    fsMock = {};
  });

  it('should thow error if generator config was not found', () => {
    expect(() => {
      requireGenerator('Test');
    }).toThrowError();
  });

  it('should return generator config', () => {
    const originalProcessCwd = process.cwd.bind(process);
    process.cwd = () => 'cwd';
    fsMock[path.join(process.cwd(), 'generators', 'test.js')] = 'test';
    expect(requireGenerator('test')).toEqual({
      name: 'test',
      config: 'test',
    });
    process.cwd = originalProcessCwd;
  });
});