text:
/**
 * Lembre-se que não é uma boa pratica criar uma class so para armazenar dadis,
 * é mais interessante que a classe alem dos dados tambem tenha funcções e procedimentos
 * sem ser com a funão de servir de variável
 **/

import java.util.Scanner;

class test{

	public static void main(String args[]){

	// variaveis
	Integer i,x;

	// entrada de dados
	Scanner in = new Scanner(System.in);

	// inicialiar classe
	variaveis vetor[] = new variaveis[100]; // criar vetor

	// estrutura do programa
	System.out.println("< Exemplo de Vetores >=========================================");

	System.out.print("Insira a quantidade de Cadastro no vetor: ");
	x = in.nextInt();

	// inserir dados no vetor
	i = 0;
	while(i <= (x-1)){

		vetor[i] = new variaveis(); // inicializar para não ficar nulo

		System.out.print("Insira o Nome: ");
		vetor[i].addNome(in.next());

		System.out.print("Insira a Idade: ");
		vetor[i].addIdade(in.nextInt());

		System.out.print("Insira o Sexo (M/F): ");
		vetor[i].addSexo(in.next().charAt(0));

		System.out.print("\n\n\n");

		i++;
	}

	// exibir vetor
	i=0;
	while(i<=x){

	System.out.println(vetor[i]);

	i++;

	}

	// desalocar vetor da memoria

	i=0;
	while(i<=x){

		vetor[i] = null;

		i++;
	}

	Runtime.getRuntime().gc(); // força a chamada do coletor

	}
}

// variaveis.java
public class variaveis{

	private String nome;
	private Integer idade;
	private Character sexo;

	public void addNome(String Aluno){

		this.nome = Aluno;

		}
	public String getNome(){
		return this.nome;
		}

	public void addIdade(Integer idade){

		this.idade = idade;

		}
	public Integer getIdade(){
		return this.idade;
		}

	public void addSexo(Character sexo){

		this.sexo = sexo;

		}
	public Character getSexo(){
		return this.sexo;
		}

	@Override
	public String toString(){

		String Retorno;

		Retorno = "Aluno: "+ this.getNome() +"; "+
		"Sexo: "+ this.getSexo() +"; "+
		"Idade: "+ this.getIdade()+" anos.";

		return Retorno;
	}

}


text:
USING_NS_CC;
USING_NS_CC_EXT;
using namespace CocosDenshion;

AppDelegate::AppDelegate()
{
}

AppDelegate::~AppDelegate()
{
    ScriptEngineManager::destroyInstance();
}

void AppDelegate::initGLContextAttrs()
{
    GLContextAttrs glContextAttrs = {8, 8, 8, 8, 24, 8};

    GLView::setGLContextAttrs(glContextAttrs);
}

bool AppDelegate::applicationDidFinishLaunching()
{
    // initialize director
    auto director = Director::getInstance();
    auto glview = director->getOpenGLView();
    if(!glview) {
#if(CC_TARGET_PLATFORM == CC_PLATFORM_WP8 || CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
        glview = cocos2d::GLViewImpl::create("js-tests");
#else
        //glview = cocos2d::GLViewImpl::createWithRect("js-tests", Rect(0,0,900,640));
		glview = cocos2d::GLViewImpl::createWithWindowedFullScreen("js-tests", Rect(0,0,1680,1050));
#endif
        director->setOpenGLView(glview);
    }

    // set FPS. the default value is 1.0/60 if you don't call this
    director->setAnimationInterval(1.0 / 60);
	//Application::getInstance()->setThreadRunCpuCore(2);
	Application::getInstance()->setThreadPriority(THREAD_PRIORITY_HIGHEST);
    //Application::getInstance()->setSleepMs(8);
	//Application::getInstance()->setFullSpeedRender(true);

    ScriptingCore* sc = ScriptingCore::getInstance();
    sc->addRegisterCallback(register_all_cocos2dx);
    sc->addRegisterCallback(register_cocos2dx_js_core);
    sc->addRegisterCallback(jsb_register_system);

    sc->addRegisterCallback(register_all_cocos2dx_extension);
    sc->addRegisterCallback(register_all_cocos2dx_extension_manual);

    sc->addRegisterCallback(jsb_register_chipmunk);
    sc->addRegisterCallback(JSB_register_opengl);

    sc->addRegisterCallback(MinXmlHttpRequest::_js_register);
    sc->addRegisterCallback(register_jsb_websocket);
	sc->addRegisterCallback(register_jsb_socketio);

    sc->addRegisterCallback(register_all_cocos2dx_builder);
    sc->addRegisterCallback(register_CCBuilderReader);

    sc->addRegisterCallback(register_all_cocos2dx_ui);
    sc->addRegisterCallback(register_all_cocos2dx_ui_manual);
    sc->addRegisterCallback(register_all_cocos2dx_studio);
    sc->addRegisterCallback(register_all_cocos2dx_studio_manual);

    sc->addRegisterCallback(register_all_cocos2dx_spine);
    sc->addRegisterCallback(register_all_cocos2dx_spine_manual);

    sc->addRegisterCallback(register_all_cocos2dx_3d);
    sc->addRegisterCallback(register_all_cocos2dx_3d_manual);

    sc->addRegisterCallback(register_all_cocos2dx_3d_extension);

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
    sc->addRegisterCallback(register_all_pluginx_protocols);
    sc->addRegisterCallback(register_pluginx_js_extensions);
#endif

#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
    sc->addRegisterCallback(JavascriptJavaBridge::_js_register);
#elif (CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC)
    sc->addRegisterCallback(JavaScriptObjCBridge::_js_register);
#endif

    sc->addRegisterCallback(register_DrawNode3D_bindings);
#if(CC_TARGET_PLATFORM != CC_PLATFORM_WP8)
    sc->addRegisterCallback(register_Effect3D_bindings);
#endif

    sc->start();
    sc->runScript("script/jsb_boot.js");
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
    sc->enableDebugger();
#endif

    auto pEngine = ScriptingCore::getInstance();
    ScriptEngineManager::getInstance()->setScriptEngine(pEngine);

    ScriptingCore::getInstance()->runScript("main.js");

    return true;
}

// This function will be called when the app is inactive. When comes a phone call,it's be invoked too
void AppDelegate::applicationDidEnterBackground()
{
    auto director = Director::getInstance();
    director->stopAnimation();
    director->getEventDispatcher()->dispatchCustomEvent("game_on_hide");
    SimpleAudioEngine::getInstance()->pauseBackgroundMusic();
    SimpleAudioEngine::getInstance()->pauseAllEffects();
}

// this function will be called when the app is active again
void AppDelegate::applicationWillEnterForeground()
{
    auto director = Director::getInstance();
    director->startAnimation();
    director->getEventDispatcher()->dispatchCustomEvent("game_on_show");
    SimpleAudioEngine::getInstance()->resumeBackgroundMusic();
    SimpleAudioEngine::getInstance()->resumeAllEffects();
}

redpajama_set_name: RedPajamaGithub


text:
package gwt.material.design.incubator.client.timer;

import com.google.gwt.dom.client.Element;
import com.google.gwt.user.client.ui.ComplexPanel;
import gwt.material.design.client.MaterialDesignBase;
import gwt.material.design.incubator.client.AddinsIncubator;
import gwt.material.design.incubator.client.base.IncubatorWidget;

//@formatter:off

/**
 * A circular SVG timer component to build a similar
 * interface like {@link gwt.material.design.addins.client.circularprogress.MaterialCircularProgress}
 *
 *

 *     Note: This component is under the incubation process and subject to change.
 *

 *
 * @author kevzlou7979
 */
//@formatter:on
public class CircularSVGTimer extends ComplexPanel {

    static {
        IncubatorWidget.showWarning(CircularSVGTimer.class);
        if (AddinsIncubator.isDebug()) {
            MaterialDesignBase.injectCss(TimerProgressDebugClientBundle.INSTANCE.circularTimerDebugCss());
        } else {
            MaterialDesignBase.injectCss(TimerProgressClientBundle.INSTANCE.circularTimerCss());
        }
    }

    private static final String SVG_NAMESPACE = "http://www.w3.org/2000/svg";

    public CircularSVGTimer() {
        setElement(createElementNS(SVG_NAMESPACE, "svg"));
        getElement().setAttribute("width", "50");
        getElement().setAttribute("height", "50");
        getElement().setAttribute("viewBox", "0 0 66 66");
        showcaseSVG();
    }

    private void showcaseSVG(){
        Element svgElement = createElementNS(SVG_NAMESPACE, "circle");
        svgElement.setAttribute("cx", "33");
        svgElement.setAttribute("cy", "33");
        svgElement.setAttribute("r", "30");
        svgElement.setAttribute("stroke-width", "6");
        svgElement.setAttribute("stroke-linecap", "round");
        svgElement.setAttribute("fill", "none");
        svgElement.setAttribute("class", "path");
        getElement().appendChild(svgElement);
    }

    @Override
    protected void onLoad() {
        super.onLoad();

        getElement().setAttribute("class", "spinner");
    }

    //TODO: Convert to JSInterop
    private static native Element createElementNS(final String ns,
                                                  final String name)/*-{
        return document.createElementNS(ns, name);
    }-*/;
}


text:
<!DOCTYPE html>

            <iframe id='iframe-100' frameborder='0px' src='data:text/html;charset=utf-8,'>


text:
module.exports.listen = function(app) {
  var http = require('http').Server(app);
var socketio = require('socket.io')(http);

    io = socketio.listen(app)

    io.on('connection', function(socket) {
        console.log('a user connected');
    });

    return io
}


text:
"use strict";

var f = require('util').format;

exports['Should correctly connect with MongoClient.connect using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=100')
      : f('%s?%s', url, 'maxPoolSize=100');

    MongoClient.connect(url).then(function(db) {
      test.equal(100, db.serverConfig.connections().length);

      db.close();
      test.done();
    });
  }
}

exports['Should correctly connect using Db.open and promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var db = configuration.newDbInstance({w:1}, {poolSize:1});
    db.open().then(function(db) {
      db.close();
      test.done();
    });
  }
}

exports['Should correctly execute ismaster using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      // Execute ismaster
      db.command({ismaster:true}).then(function(result) {
        test.ok(result != null);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly catch command error using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      // Execute ismaster
      db.command({nosuchcommand:true}).then(function(result) {
      }).catch(function(err) {

        // Execute close using promise
        db.close().then(function() {
          test.done();
        });
      });
    });
  }
}

exports['Should correctly createCollecton using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.createCollection('promiseCollection').then(function(col) {
        test.ok(col != null);

        db.close();
        test.done();
      }).catch(function(err) {
        console.log(err.stack)
      });
    });
  }
}

exports['Should correctly execute stats using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.stats().then(function(stats) {
        test.ok(stats != null);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly execute eval using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.eval('function (x) {return x;}', [3], {nolock:true}).then(function(result) {
        test.ok(result != null);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly rename and drop collection using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.createCollection('promiseCollection1').then(function(col) {
        test.ok(col != null);

        db.renameCollection('promiseCollection1', 'promiseCollection2').then(function(col) {
          test.ok(col != null);

          db.dropCollection('promiseCollection2').then(function(r) {
            test.ok(r);

            db.close();
            test.done();
          });
        });
      });
    });
  }
}

exports['Should correctly drop database using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.dropDatabase().then(function(r) {
        test.ok(r);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly createCollections and call collections with Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.createCollection('promiseCollectionCollections1').then(function(col) {
        test.ok(col != null);

        db.createCollection('promiseCollectionCollections2').then(function(col) {
          test.ok(col != null);

          db.collections().then(function(r) {
            test.ok(Array.isArray(r));

            db.close();
            test.done();
          });
        });
      });
    });
  }
}

exports['Should correctly execute executeDbAdminCommand using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      db.executeDbAdminCommand({ismaster:true}).then(function(r) {
        test.ok(r);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly execute creatIndex using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      // Create an index
      db.createIndex('promiseCollectionCollections1', {a:1}).then(function(r) {
        test.ok(r != null);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly execute ensureIndex using Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var url = configuration.url();
    url = url.indexOf('?') != -1
      ? f('%s&%s', url, 'maxPoolSize=5')
      : f('%s?%s', url, 'maxPoolSize=5');

    MongoClient.connect(url).then(function(db) {
      // Create an index
      db.ensureIndex('promiseCollectionCollections2', {a:1}).then(function(r) {
        test.ok(r != null);

        db.close();
        test.done();
      });
    });
  }
}

exports['Should correctly execute createCollection using passed down bluebird Promise'] = {
  metadata: {
    requires: {
      promises: true,
      node: ">0.8.0",
      topology: ['single']
    }
  },

  // The actual test we wish to run
  test: function(configuration, test) {
    var MongoClient = configuration.require.MongoClient;
    var db = null;
    var BlueBird = require('bluebird');

    MongoClient.connect(configuration.url(), {promiseLibrary: BlueBird}).then(function(conn) {
      db = conn;
      return db.createCollection('test');
    }).then(function(col) {
      test.ok(col.s.options.promiseLibrary != null);

      db.close();
      test.done();
    });
  }
}


text:
package org.genericsystem.cdi;

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Alternative;
import javax.enterprise.inject.Specializes;

/**
 * Persistence is not activated by default if you want to persist, you have to set a specialized mock persistentDirectoryProvider in your project :
 *
 * @Specializes public class PersistentDirectoryConfig extends PersitentDirectoryProvider { @Override String getDirectoryPath() { return DIRECTORY_PATH; } }
 *
 * @author Nicolas Feybesse
 *
 */

@Specializes
@Alternative
@ApplicationScoped
public class PersistentDirectoryConfig extends PersistentDirectoryProvider {
	@Override
	public String getDirectoryPath() {
		return DEFAULT_DIRECTORY_PATH;
	}
}


text:
<!DOCTYPE html>

     <meta charset="UTF-8">
     <title>ADM solution submission server</title>

     <link href="/static/codemirror/lib/codemirror.css" rel="stylesheet">
     <link href="/static/admserver.css" rel="Stylesheet" type="text/css">

      {% if items["useSSL"] %}

      {% end %}

Assignment

Admin

Profile

Logout: {{ items["name"] }}

Daedline	Description

 Days left

    {{ items["assignment"][2] }}

{{ items["assignment"][3] }}

    {% for task in items["tasks"] %}

	    task{{ task[1] }}

    {% end %}

	* new task *

Attempts	Description	Command

    {% for task in items["tasks"] %}

		    		{% if task[8] == 0 %}

Unlimited

		    		{% else %}

Allowed: {{ task[8] }}
		    			Left: {{ task[8] }}

		    		{% end %}

	    <form id="frmTask{{ task[1] }}" action="/admin/{{ items["assignment"][0] }}" method="post">
		    <input type="hidden" name="assignment" value="{{ items["assignment"][2] }}">
		    <input type="hidden" name="task" value="{{ task[1] }}">
		    <input id="task{{ task[1] }}attempts" type="hidden" name="attempts" value="inf">
		    Attempts: <input type="number" name="attempts" value="{{ task[8] }}">

			Description:
	    	<textarea id="desc{{ task[1] }}" cols="80" rows="4" name="description">{{ task[2] }}</textarea>

		   	Template:
		    <textarea id="code{{ task[1]}}" cols="80" rows="4" name="template">{{ task[11] }}</textarea>

			Testcase:
			<textarea id="tests{{ task[1] }}" class="lined" cols="80" rows="17" name="tests">{{ task[3] }}</textarea>

			{% raw xsrf_form_html() %}

		<input type="submit" value="Update task">
	    </form>

	    <form action="/deletetask" method="post">
		    <input type="hidden" name="assignment" value="{{ items["assignment"][2] }}">
		    <input type="hidden" name="task" value="{{ task[1] }}">
		    <input type="submit" value="Delete task">
			{% raw xsrf_form_html() %}
		</form>

    {% end %}

*new*

	    <form action="/admin/{{ items["assignment"][0] }}" method="post">
		    <input type="hidden" name="assignment" value="{{ items["assignment"][2] }}">
		    <input type="hidden" name="task" value="new">
		    Attempts: <input type="number" name="attempts" value="0">

			Description:
	    	<textarea id="desc0" cols="80" rows="4" name="description">Enter a clear description of the programming task
	    	</textarea>

		   	Template:
		    <textarea id="code0" cols="80" rows="4" name="template">Enter a template for a student solution.
		    </textarea>

			Testcase:
			<textarea id="tests0" class="lined" cols="80" rows="17" name="tests">{{ items["testTemplate"] }}</textarea>

			{% raw xsrf_form_html() %}

	<input type="submit" value="Create task">
    </form>


text:
<!doctype html>

<meta charset="UTF-8">
<title>Untitled Document</title>

<link rel="stylesheet" type="text/css" href="css/styles.min.css" />

<form action="" method="post" enctype="multipart/form-data" id="xid">

	<input type="file" name="thefile" id="thebox">

		<button type="submit">Submit</button>

</form>


text:
\documentclass[crop,tikz,border=1px]{standalone}

\usetikzlibrary{arrows,positioning,scopes,automata,calc,chains}

\begin{document}
\begin{tikzpicture}[->,>=stealth',shorten >=1pt,auto,node
  distance=.8cm,inner sep=2pt,,
  mystate/.style={state,text centered,minimum size=.5cm}]

  \node[initial,mystate] (q0) {};
  \node[mystate] (q1) [right=of q0] {};
  \node[mystate,accepting] (q2) [below=of q1] {};

  \draw (q0) edge node {a} (q1)
        (q1) edge node {b} (q2)
        (q0) edge node {\(\epsilon\)} (q2);

\end{tikzpicture}
\end{document}


text:
[« OpenStreetMap Guide](https://github.com/mapbox/data/wiki/OpenStreetMap-Guide)

This is a walkthrough of the most important features you will map as part of the Mapbox data team. It's an introduction to get you started mapping but not meant to be comprehensive. We're going to use some OpenStreetMap specific terms here, if you're not familiar with what "nodes", "way" and "relations" are, read up first on the [Introduction to mapping](/data/wiki/Introduction-to-mapping-on-OpenStreetMap).

*How do I map X?*

We're focusing in this section on the features that matter most in the day-to-day work at Mapbox. For a full documentation, refer to the [OpenStreetMap Map Features](http://wiki.openstreetmap.org/wiki/Map_Features) guide. To look up a specific map feature fast, for instance how to map a railway station, google with a query like "tag bus stop site:wiki.openstreetmap.org":

![](https://s3.amazonaws.com/f.cl.ly/items/3C3A0S3k011k1P3b2J0N/google.gif)

A valuable complimentary resource is [taginfo.openstreetmap.org](http://taginfo.openstreetmap.org/). Tag info shows you the number of times a specific tag has been used which lets you find out how established a tag is.

## Roads and paths

Roads are some of the most significant features we map. While roads are easy to trace off of Satellite imagery there is a large vocabulary for classifying different types of roads.

### Tracing roads

Tracing a road is simple. Use the Draw (A) tool in JOSM or the Line tool in iD and draw the road following its course. The trick is to use the right amount of nodes to describe a way. Too few make the road appear very jagged. Too many are unnecessary data and make the road hard to edit later.

Look at the picture below, the first example was traced with too few nodes, it is too jagged, the second example was traced with too many nodes adding redundant information, the last one is traced right:

![Too few / too many / right amount of nodes in a curve](https://s3.amazonaws.com/f.cl.ly/items/2h33142Q181p071C1O14/Screen%20Shot%202015-01-04%20at%208.32.37%20PM.png)

Roads must be connected where they intersect. On the left you can see two roads just crossing each other, on the right note how a node connects the two roads. This is important for navigation, where vehicles must be able to be guided from one road to the other.

![](https://s3.amazonaws.com/f.cl.ly/items/180r0E2l0P2H0m0Z3m07/Screen%20Shot%202015-01-04%20at%208.55.14%20PM.png)

And follow the flow of roads where possible. On the left the road was traced with a "detour" for no apparant reason. On the right you see how the road tracing follows the logical flow of the road.

![wrong: "map around corners", right: follow flow](https://s3.amazonaws.com/f.cl.ly/items/0k1F3Y0m0y081H3v0W07/Screen%20Shot%202015-01-04%20at%208.48.54%20PM.png)

Trace every *physically* separated lane as a separate way. See for example this dual carriage way (orange):

![dual carriage way](https://s3.amazonaws.com/f.cl.ly/items/0f0z0i391l0C0e0X3d0b/Screen%20Shot%202015-01-04%20at%209.01.42%20PM.png)

When mapping a dual carriage way, make sure that connecting roads are properly connecting to both carriages *if* this connection is possible in reality:

![show 2 examples of connecting roads to a carriage way: one connecting to both lanes, one to only one lane](https://s3.amazonaws.com/f.cl.ly/items/07043M2U0H093c2q1r3m/Screen%20Shot%202015-01-04%20at%209.01.4222%20PM.png)

### Everything's a highway

No matter whether it's an overland road, a city street, a foot path or a cycleway, you'll find it tagged with the `highway` key. Here are some examples of common tags:

- `highway=residential` - a residential road in a city
- `highway=motorway` - a fast restricted access road
- `highway=footway` - a foot path
- `highway=cycleway` - a cycleway

Roads often come with secondary tags, further specifying type or attribute of a road:

- `oneway=yes` says a road is a one way
- `lanes=2` says how many lanes a road has
- `name=Broadway` designates a street name
- `access=private|permissive` describes the level of access on a road
- `service=parking_aisle|driveway` further specifies the type of `highway=service`

### Oneways

Oneways are mapped by simply adding a `oneway=yes` tag to the road's way. Keep in mind that ways have a directionality. So the road will be a oneway in the direction of the way. If you need to change the flow of the one way, you have two options:

- Change the direction of the way (Tool > Revers ways in JOSM or the `<<` context icon on iD)
- Or tag with `oneway=-1` - use this approach where the way's directionality already governs another attribute such as bus route.

![tagging a oneway](https://s3.amazonaws.com/f.cl.ly/items/1W0M081C2W3K0j0p1I2r/oneway.gif)

OpenStreetMap Wiki: [Key:oneway](http://wiki.openstreetmap.org/wiki/Key:oneway)

### Turn restrictions

Turn restrictions are rules that disallow certain turn maneuvers. Here's for instance a "no right turn" sign.

![](https://farm3.staticflickr.com/2900/14360050862_ef35f7ffa8_b.jpg)

To map turn restrictions in JOSM, use the **turnrestrictions** plugin. Once enabled, you can activate a new turn restriction panel from the `Windows > Turn Restriction` menu item.

Once enabled, create new turn restrictions or edit exiting ones from the panel. Here is an example of how to create a simple "no right turn" restriction. We're selecting the way we can't take the right turn from as "from" object, the way we can't take the right turn to as "to" object and then we specify that the restriction is a "no right turn" restriction. As we save the turnrestrictions dialog warns us that there is no "via" object defined. It is not strictly required to have one, but is good practice, so we define one.

![](https://s3.amazonaws.com/f.cl.ly/items/24173W1U033a193q2l1F/turn.gif)

Turn restrictions can get more complex quickly, so before you create or edit turn restrictions, make sure you read through and understand all available documentation on the OpenStreetMap wiki.

Video: [How to edit turn restrictions in JOSM](https://www.youtube.com/watch?v=0SdixDJAED0)

OpenStreetMap Wiki: [Relation:restriction](http://wiki.openstreetmap.org/wiki/Relation:restriction)

### Simple classification guide

One of the more subtle skills to learn in OpenStreetMap is how to properly classify roads. The `highway` tag has more than eight values for roads, another five-plus for non-vehicular traffic, and a series of secondary tags. What's more highway classifications are highly country specific and follow different conventions on a country by country basis.

Here's a quick guide on how to go about working with road classifications on OpenStreetMap.

1. Follow existing classifications. Don't change classifications and follow the conventions you see on the local map for new data.
2. The smallest roads in a network are the easiest ones to identify and also the ones you'll wind up adding most. For minor roads, prefer `highway=residential` in built up residential areas, `highway=unclassified` for everything else.
3. For all other cases, use `highway=road`

For a full reference on highway mapping, look at the [wiki entry for the highway tag](http://wiki.openstreetmap.org/wiki/Key:highway).

### Intersections

The intersection between a roads and another feature always must be defined. Where they meet, there is either an intersection, a tunnel or a bridge.

#### Simple intersections beween two roads

To create a simple intersection between two roads, just make sure to connect the two roads with a node.

![show how 2 roads connect](https://s3.amazonaws.com/f.cl.ly/items/1b0K0E2b401E0U2U1H1A/intersect.gif)

#### Tunnel

A tunnel carries the `tunnel=yes` and a `layer=` tag that is one lower than the `layer=` tag of the feature it intersects with (default `layer` value is 0). The road is *not* connected with the other feature. Split ways where the tunnel starts

![show how to map a tunnel](https://s3.amazonaws.com/f.cl.ly/items/0e3S3F3j1N000w1R1d2x/tunnel.gif)

A building passage is a special type of tunnel that passes through a building. To map a building passage, connect the road where it intersects with the building outline with nodes, then tag the portion of the road that intersects with the building with `tunnel=building_passage`.

![map a building passage](https://s3.amazonaws.com/f.cl.ly/items/1v1E0Z2P0C3X1K1h0Q1M/building-passage.gif)

OpenStreetMap Wiki: [Key:tunnel](http://wiki.openstreetmap.org/wiki/Key:tunnel)

#### Bridge

In addition to the road's `highway=*` tag, a bridge carries the `bridge=yes` and a `layer=` tag that is one higher than the `layer=` tag of the feature it intersects with (default `layer` value is 0).

![show how to map a bridge](https://s3.amazonaws.com/f.cl.ly/items/1v1P2S3P35292a1m2a0m/bridge.gif)

OpenStreetMap Wiki: [Key:bridge](http://wiki.openstreetmap.org/wiki/Key:bridge)

#### Railroad crossing

Map a railroad crossing similar to an intersection between two roads by connecting the road and the railroad with a node. Then tag the node with `railway=level_crossing`. Do not confuse this tag with `railway=crossing` which is only for pedestrian crossings.

![map a level crossing](https://s3.amazonaws.com/f.cl.ly/items/1q3o381b0K3r3x291J0E/level_crossing.gif)

OpenStreetMap Wiki: [Tag:railway=level_crossing](http://wiki.openstreetmap.org/wiki/Tag:railway%3Dlevel_crossing)

#### Roundabouts

Map a roundabout by tracing the circular road and tag it with `junction=roundabout`. For the road classification, use the highest classification of all roads connected to the roundabout. The `junction=roundabout` tag implies a oneway - make sure that the directionality of the way is correct.

![how to map a roundabout](https://s3.amazonaws.com/f.cl.ly/items/1d0z472I3x2i2v2q0G2y/Screen%20Shot%202015-01-04%20at%2010.27.09%20PM.png)

#### Complex intersections

In a complex intersection involving multiple carriage ways trace the roads so that they reflect the flow along the main carriages and make sure that oneways make sense.

![](https://s3.amazonaws.com/f.cl.ly/items/0M3S232n2V342Y3T2n1Y/Screen%20Shot%202015-01-04%20at%2010.34.51%20PM.png)

## Buildings

Tracing buildings takes good imagery and patience. Take your time and pay attention to angularity, alignment between buildings and reflecting the regularities between buildings. Buildings are traced as outlines of *where the building meets the ground*. This last piece is important. The roof outline is often easier to see in the imagery so you'll find it often traced in OpenStreetMap but it's wrong. The main challenge with tracing buildings is lack of detail in imagery. Where you don't find good enough imagery for tracing a building, just don't trace it.

Here are a couple of JOSM specific tips to trace buildings effectively.

For tracing buildings, use the **buildings plugin**. Once enabled, a new building tool will be available in the edit toolbar on the left. The building tool will draw rectangular shapes tagged `building=yes` for you. To draw buildings parallel to each other, draw the first building, select it, then draw subsequent buildings.

![](https://s3.amazonaws.com/f.cl.ly/items/3A2T0l0Y3x0N030w090F/building.gif)

If you draw closed ways free hand, use `Tools > Orthogonalize Shape` or press "**Q**" to square out buildings like so:

![](https://s3.amazonaws.com/f.cl.ly/items/3U3c1S1V2X1Q1h3s0845/Screen%20Shot%202014-12-15%20at%206.35.04%20PM.png)

Use auxiliary lines to align protruding portions of a building:

![](https://s3.amazonaws.com/f.cl.ly/items/0s3G3T200b1C3d3i0x2Y/buildingalignment.gif)

You can use split buildings temporarily with `Tools > Split Way` or pressing "**P**" to orthogonalize portions of a building before reconnecting the with `Tools > Connect Way` or pressing "**C**":

![](https://s3.amazonaws.com/f.cl.ly/items/151R161W3i2c043q1z0B/straightenc.gif)

Here is a quick end to end walkthrough of how to trace a building:

![](https://s3.amazonaws.com/f.cl.ly/items/3T0Y0h390L3l19000s2h/buildings.gif)

OpenStreetMap Wiki: [Key:building](http://wiki.openstreetmap.org/wiki/Key:building)

Video: [Tracing buildings with JOSM](https://www.youtube.com/watch?v=9GRIHSAAkSs)

## Points of interest

"Point of interest" is a general term for a real world point-like feature noteworthy enough to include it on a map. Some examples are restaurants, cafés, shops, banks, churches, public toilets and water fountains. There's not a single point of interest tag key in OpenStreetMap but a variety that can be used for mapping a point of interest: `amenity=`, `shop=`, `tourism=` are some examples.

OpenStreetMap Wiki: [Key:amenity](http://wiki.openstreetmap.org/wiki/Key:amenity), [Key:tourism](http://wiki.openstreetmap.org/wiki/Key:tourism), [Key:shop](http://wiki.openstreetmap.org/wiki/Key:shop), [Key:leisure](http://wiki.openstreetmap.org/wiki/Key:leisure)

### Simple point of interest

The simplest way to map a point of interest is to create a single node and add corresponding tags. Here's an example of a fountain mapped in OpenStreetMap:

![](https://s3.amazonaws.com/f.cl.ly/items/2a0E2w0u2U0D0t2b1Z3Y/fountain.gif)

Here's an example of a restaurant:

![](https://s3.amazonaws.com/f.cl.ly/items/1R3K0A1p0C1G043n1o3d/komi.gif)

### Areas as pionts of interest

Wherever you can clearly determine the extent of a "point" of interest, map it. A good example are parks, here is Folger Park in Washington DC. The Park is mapped as a closed way tagged `leisure=park`. Note how the way follows the exact outline of the park.

![](https://s3.amazonaws.com/f.cl.ly/items/0V2N0n290Z1L0H1h2b1e/Screen%20Shot%202015-01-10%20at%208.29.39%20AM.png)

### Building as point of interest

Sometimes the building itself is considered the point of interest. Think for instance of a MacDonalds restaurant in an urban multi-use building versus a MacDonalds drive through in a suburban strip mall. Or - often easy to spot from satellite imagery - think of a place of worship like a church. In such cases the building itself should be tagged as a point of interest. Here's a church that has first been mapped as a single node in a building. The example shows how all tags from the node are transferred to the building and then the node is removed.

![](https://s3.amazonaws.com/f.cl.ly/items/2m0k0v333M1H0i1t3p1V/church.gif)

### Schools and universities

Schools can just be mapped as a simple node tagged `amenity=school`. But often schools occupy an entire building or a piece of land. School grounds, the terrain on which a school sits, are mapped as `amenity=school`. The buildings of a school are mapped as `building=school`. Mapping schools as just a simple node is fine. However, wherever appropriate, map a school's ground and buildings as ways.

An example where a school *does not* occupy the entire building:

![](https://s3.amazonaws.com/f.cl.ly/items/0H2W3b401X3H0r0O011s/Screen%20Shot%202015-01-09%20at%206.09.01%20PM.png)

An example where a school *does* occupy an entire building:

![](https://s3.amazonaws.com/f.cl.ly/items/0r3q0C0w2L0C3n3d2f11/Screen%20Shot%202015-01-09%20at%206.18.28%20PM.png)

An example where a school occupies its own school grounds:

![](https://s3.amazonaws.com/f.cl.ly/items/1W1A1p0U3z3D3E3g183M/highschool.gif)

Universities are similar:

![](https://s3.amazonaws.com/f.cl.ly/items/102S1D1Z472x213M2b0Y/university.gif)

OpenStreetMap Wiki: [Tag:amenity=school](http://wiki.openstreetmap.org/wiki/Tag:amenity%3Dschool), [Tag:building=school](http://wiki.openstreetmap.org/wiki/Tag:building%3Dschool), [Tag:amenity=university](http://wiki.openstreetmap.org/wiki/Tag:amenity%3Duniversity), [Tag:building=university](http://wiki.openstreetmap.org/wiki/Tag:building%3Duniversity), [Tag:amenity=college](http://wiki.openstreetmap.org/wiki/Tag:amenity%3Dcollege)

## Streams and Rivers

Trace small streams as just a way tagged with `waterway=stream`. The way's direction signals the direction in which the water flows. For larger rivers, trace the center of the river as `waterway=river` and in addition the river banks with `natural=water` and `water=river` tags. The name of the river always sits on the waterway. See here for an example:

![](https://s3.amazonaws.com/f.cl.ly/items/460R352M0H301L2Y1Q3T/river.gif)

Islands in rivers are mapped as relations of `type=multipolygon`. Observe how on a multipolygon the `natural=water` and `water=river` tags sit on the multipolygon relation and not on the way:

![](https://s3.amazonaws.com/f.cl.ly/items/0t0A0q06130m0O1c3I19/multiriver.gif)

Video: [Map a river island](http://cl.ly/0M0m2C2t2T3g)

OpenStreetMap Wiki: [Tag:waterway=river](http://wiki.openstreetmap.org/wiki/Tag:waterway%3Driver)

## Coming soon

- Walking and cycling paths
- Places (city versus village versus suburb versus neighborhood)
- Lakes


text:
<!DOCTYPE html>

		<title>Otter Squad - Chat</title>
    <link rel="icon" type="image/png" href="images/aquaotter.png"/>

		<link rel="stylesheet" type="text/css" href="css/animate.css">
		<link rel="stylesheet" type="text/css" href="css/main.css">

Otter Squad

Error: Can't load taglines.js!

Home

Projects

Chat

About


text:
#include "Text.h"
#include "Log/Log.h"
#include "ResourceManager/ResourceManager.h"
#include "Renderer/Renderer/Renderer.h"

#include "Math/Vector3.h"
#include "Renderer/Renderer/Mesh.h"
#include "Renderer/Renderer/Material.h"

#include "Utils/BufferReader.h"

#include <ft2build.h>
#include FT_FREETYPE_H

#include <algorithm>
#include <cstdint>
#include <memory>
#include <cmath>

namespace oakvr
{
	namespace core
	{
		// --------------------------------------------------------------------------------
		Text::Text()
			: m_pFTLib{ nullptr }
		{
			FT_Error err = FT_Init_FreeType(&m_pFTLib);
			if (err)
				Log::Error("Could not initialize OakVR text manager.");
		}

		// --------------------------------------------------------------------------------
		Text::~Text()
		{

		}

		// --------------------------------------------------------------------------------
		auto Text::AddFontFace(sp<MemoryBuffer> fontFileBuff) -> void
		{
			m_fontFaces.emplace_back(m_pFTLib, fontFileBuff);	// add new text::FontFace object to m_fontFaces
			auto face = m_fontFaces.back();
			auto buff = face.GetMemoryBuffer();
			m_pRM->CreateResourceFromMemory(face.GetName() + "_texture", buff);
		}

		// --------------------------------------------------------------------------------
		auto Text::RenderText(std::string text, oakvr::math::Vector3 position, oakvr::render::Color color, std::string fontName, float scale /* = 1.0f */, float angle /*= 0.f*/) const -> void
		{
			float scaleFactor = 0.05f;

			auto it = FindFontFace(fontName);

			if (it != m_fontFaces.end())
			{
				std::vector<oakvr::render::VertexElementDescriptor> ved{
					oakvr::render::VertexElementDescriptor::Semantic::position,
					oakvr::render::VertexElementDescriptor::Semantic::tex_coord,
					oakvr::render::VertexElementDescriptor::Semantic::color
				};

				int vertexStride = ComputeVertexStride(ved);
				oakvr::core::MemoryBuffer vb{ text.length() * 4 * vertexStride };
				oakvr::core::MemoryBuffer ib{ text.length() * 6 * sizeof(uint32_t) };

				auto cm = it->GetCharacterMap();

				float posX = 0.0f;
				float posY = 0.0f;

				// create the mesh for this text
				int vertexStrideInFloats = vertexStride / sizeof(float);
				std::unique_ptr<float[]> pVertices = std::make_unique<float[]>(text.length() * 4 * vertexStrideInFloats);
				std::unique_ptr<uint32_t[]> pIndices = std::make_unique<uint32_t[]>(text.length() * 6);
				for (int i = 0; i < text.length(); ++i)
				{
					if (text[i] < ' ')
					{
						oakvr::Log::Warning("Trying to output a character that is not in the range 32-127! [%c]", text[i]);
						continue;
					}

					const auto &charProps = cm[text[i] - ' '];

					float horizontalNormalizationFactor = 1.f / it->GetTextureWidth();
					float verticalNormalizationFactor = 1.f / it->GetTextureHeight();
					float cwPixels = fabs(charProps.texCoords2.x - charProps.texCoords1.x) * scaleFactor;
					float chPixels = fabs(charProps.texCoords2.y - charProps.texCoords1.y) * scaleFactor;
					float clPixels = charProps.leftTopFromBaseline.x * scaleFactor;
					float ctPixels = charProps.leftTopFromBaseline.y * scaleFactor;

					// Vertex # layout
					//	position.x
					//	position.y
					//	position.z
					//	texcoord.u
					//	texcoord.v
					//	color.r
					//	color.g
					//	color.b

					int offset = i * 4 * vertexStrideInFloats;

					// Vertex #1
					pVertices[offset + 0 * vertexStrideInFloats + 0] = posX + clPixels;
					pVertices[offset + 0 * vertexStrideInFloats + 1] = posY - chPixels + ctPixels;
					pVertices[offset + 0 * vertexStrideInFloats + 2] = 0.0f;
					pVertices[offset + 0 * vertexStrideInFloats + 3] = charProps.texCoords1.x * horizontalNormalizationFactor;
					pVertices[offset + 0 * vertexStrideInFloats + 4] = charProps.texCoords2.y * verticalNormalizationFactor;
					pVertices[offset + 0 * vertexStrideInFloats + 5] = color.r;
					pVertices[offset + 0 * vertexStrideInFloats + 6] = color.g;
					pVertices[offset + 0 * vertexStrideInFloats + 7] = color.b;
					pVertices[offset + 0 * vertexStrideInFloats + 8] = color.a;

					// Vertex #2
					pVertices[offset + 1 * vertexStrideInFloats + 0] = posX + cwPixels + clPixels;
					pVertices[offset + 1 * vertexStrideInFloats + 1] = posY - chPixels + ctPixels;
					pVertices[offset + 1 * vertexStrideInFloats + 2] = 0.0f;
					pVertices[offset + 1 * vertexStrideInFloats + 3] = charProps.texCoords2.x * horizontalNormalizationFactor;
					pVertices[offset + 1 * vertexStrideInFloats + 4] = charProps.texCoords2.y * verticalNormalizationFactor;
					pVertices[offset + 1 * vertexStrideInFloats + 5] = color.r;
					pVertices[offset + 1 * vertexStrideInFloats + 6] = color.g;
					pVertices[offset + 1 * vertexStrideInFloats + 7] = color.b;
					pVertices[offset + 1 * vertexStrideInFloats + 8] = color.a;

					// Vertex #3
					pVertices[offset + 2 * vertexStrideInFloats + 0] = posX + cwPixels + clPixels;
					pVertices[offset + 2 * vertexStrideInFloats + 1] = posY + ctPixels;
					pVertices[offset + 2 * vertexStrideInFloats + 2] = 0.0f;
					pVertices[offset + 2 * vertexStrideInFloats + 3] = charProps.texCoords2.x * horizontalNormalizationFactor;
					pVertices[offset + 2 * vertexStrideInFloats + 4] = charProps.texCoords1.y * verticalNormalizationFactor;
					pVertices[offset + 2 * vertexStrideInFloats + 5] = color.r;
					pVertices[offset + 2 * vertexStrideInFloats + 6] = color.g;
					pVertices[offset + 2 * vertexStrideInFloats + 7] = color.b;
					pVertices[offset + 2 * vertexStrideInFloats + 8] = color.a;

					// Vertex #4
					pVertices[offset + 3 * vertexStrideInFloats + 0] = posX + clPixels;
					pVertices[offset + 3 * vertexStrideInFloats + 1] = posY + ctPixels;
					pVertices[offset + 3 * vertexStrideInFloats + 2] = 0.0f;
					pVertices[offset + 3 * vertexStrideInFloats + 3] = charProps.texCoords1.x * horizontalNormalizationFactor;
					pVertices[offset + 3 * vertexStrideInFloats + 4] = charProps.texCoords1.y * verticalNormalizationFactor;
					pVertices[offset + 3 * vertexStrideInFloats + 5] = color.r;
					pVertices[offset + 3 * vertexStrideInFloats + 6] = color.g;
					pVertices[offset + 3 * vertexStrideInFloats + 7] = color.b;
					pVertices[offset + 3 * vertexStrideInFloats + 8] = color.a;

					offset = i * 6;
					// Index #1
					pIndices[offset + 0] = i * 4;
					pIndices[offset + 1] = i * 4 + 1;
					pIndices[offset + 2] = i * 4 + 2;
					pIndices[offset + 3] = i * 4;
					pIndices[offset + 4] = i * 4 + 2;
					pIndices[offset + 5] = i * 4 + 3;

					posX += 1.1f * cwPixels;	// advance horrizontally (small hack to limit glyphs from overlapping)
				}

				memcpy(vb.GetDataPtr(), pVertices.get(), vb.Size());
				memcpy(ib.GetDataPtr(), pIndices.get(), ib.Size());

				std::vector<StringId> vecTextures = { it->GetName() + "_texture" };
				auto pMaterial = std::make_shared<oakvr::render::Material>("DefaultText");

				auto pMeshElem = std::make_shared<oakvr::render::MeshElement>(ved, vb, static_cast<uint8_t>(sizeof(uint32_t)), ib, pMaterial, vecTextures);

				auto pMesh = std::make_shared<oakvr::render::Mesh>();
				pMesh->AddMeshElement(pMeshElem);
				pMesh->SetWorldMatrix(oakvr::math::Matrix::Translation(position) * oakvr::math::Matrix::RotationZ(angle) * oakvr::math::Matrix::Scale(scale));
				m_pRenderer->RegisterOneFrameMesh(pMesh);
				m_pRenderer->RegisterShaderProgram("DefaultText");

			}
			else
			{
				Log::Warning("Could not find font face \"%s\" for rendering.", fontName.c_str());
			}
		}

		auto Text::GetGlyphWidth(char character, std::string fontName, float scale) -> float
		{
			auto it = FindFontFace(fontName);

			if (it != m_fontFaces.end())
			{
				auto cm = it->GetCharacterMap();
				if (character < ' ')
					return -1;

				auto charProps = cm[character];
				return 1.1f * fabs(charProps.texCoords2.x - charProps.texCoords1.x) * 0.05f * scale; //(1.1 hack from renderText and 0.05 scalefactor from renderText)
			}

			return 0.0f;
		}

		auto Text::GetGlyphHeight(char character, std::string fontName, float scale) -> float
		{
			auto it = FindFontFace(fontName);

			if (it != m_fontFaces.end())
			{
				auto cm = it->GetCharacterMap();
				if (character < ' ')
					return -1;

				auto charProps = cm[character];
				return 1.1f * fabs(charProps.texCoords2.y - charProps.texCoords1.y) * 0.05f * scale; //(1.1 hack from renderText and 0.05 scalefactor from renderText)
			}
			return 0.0f;
		}

		// --------------------------------------------------------------------------------
		auto Text::FindFontFace(const std::string &name) const -> std::vector<text::FontFace>::const_iterator
		{
			return std::find_if(m_fontFaces.begin(), m_fontFaces.end(), [&](const text::FontFace &face)
			{
				return name == std::string(face.GetName());
			});
		}

		// --------------------------------------------------------------------------------
		auto Text::FindFontFace(const std::string &name) -> std::vector<text::FontFace>::iterator
		{
			return std::find_if(m_fontFaces.begin(), m_fontFaces.end(), [&](const text::FontFace &face)
			{
				return name == std::string(face.GetName());
			});
		}
	}
}


text:
<?php

$l['forums_and_posts'] = "Forums & Posts";

$l['forum_management'] = "Forum Management";
$l['forum_announcements'] = "Forum Announcements";
$l['moderation_queue'] = "Moderation Queue";
$l['attachments'] = "Attachments";

$l['can_manage_forums'] = "Can manage forums?";
$l['can_manage_forum_announcements'] = "Can manage forum announcements?";
$l['can_moderate'] = "Can moderate posts, threads, and attachments?";
$l['can_manage_attachments'] = "Can manage attachments?";

?>


text:
  {% assign cats = site.posts | sort: 'section' | group_by: 'categories' %}
  {% assign page_cat = page.categories | first %}
  {% for category in cats %}
    {% assign cat = category.name | remove: '["' | remove: '"]' %}
    {% capture selected_category %}{% if page_cat == cat %}selected-category{% else %}closed-category{% endif %}{% endcapture %}

      {{ site.data.categories[cat] }}

        {% for post in category.items %}
        {% capture selected %}{% if page.url == post.url %}selected-section{% endif %}{% endcapture %}

{{post.title}}

        {% endfor %}

  {% endfor %}


text:
package org.apereo.cas.web.support;

import org.apache.commons.lang3.StringUtils;
import org.apereo.cas.CipherExecutor;
import org.apereo.cas.util.cipher.NoOpCipherExecutor;
import org.apereo.inspektr.common.web.ClientInfo;
import org.apereo.inspektr.common.web.ClientInfoHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

/**
 * The {@link DefaultCasCookieValueManager} is responsible creating
 * the CAS SSO cookie and encrypting and signing its value.
 *
 * @author Misagh Moayyed
 * @since 4.1
 */
public class DefaultCasCookieValueManager implements CookieValueManager {
    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultCasCookieValueManager.class);
    private static final char COOKIE_FIELD_SEPARATOR = '@';
    private static final int COOKIE_FIELDS_LENGTH = 3;

    /**
     * The cipher exec that is responsible for encryption and signing of the cookie.
     */
    private CipherExecutor<String, String> cipherExecutor = new NoOpCipherExecutor();

    /**
     * Instantiates a new Cas cookie value manager.
     *
     * @param cipherExecutor the cipher executor
     */
    public DefaultCasCookieValueManager(final CipherExecutor cipherExecutor) {
        this.cipherExecutor = cipherExecutor;
    }

    @Override
    public String buildCookieValue(final String givenCookieValue, final HttpServletRequest request) {
        final StringBuilder builder = new StringBuilder(givenCookieValue);

        final ClientInfo clientInfo = ClientInfoHolder.getClientInfo();
        builder.append(COOKIE_FIELD_SEPARATOR);
        builder.append(clientInfo.getClientIpAddress());

        final String userAgent = WebUtils.getHttpServletRequestUserAgent(request);
        if (StringUtils.isBlank(userAgent)) {
            throw new IllegalStateException("Request does not specify a user-agent");
        }
        builder.append(COOKIE_FIELD_SEPARATOR);
        builder.append(userAgent);

        final String res = builder.toString();
        LOGGER.debug("Encoding cookie value [{}]", res);
        return this.cipherExecutor.encode(res);
    }

    @Override
    public String obtainCookieValue(final Cookie cookie, final HttpServletRequest request) {
        final String cookieValue = this.cipherExecutor.decode(cookie.getValue());
        LOGGER.debug("Decoded cookie value is [{}]", cookieValue);
        if (StringUtils.isBlank(cookieValue)) {
            LOGGER.debug("Retrieved decoded cookie value is blank. Failed to decode cookie [{}]", cookie.getName());
            return null;
        }

        final String[] cookieParts = cookieValue.split(String.valueOf(COOKIE_FIELD_SEPARATOR));
        if (cookieParts.length != COOKIE_FIELDS_LENGTH) {
            throw new IllegalStateException("Invalid cookie. Required fields are missing");
        }
        final String value = cookieParts[0];
        final String remoteAddr = cookieParts[1];
        final String userAgent = cookieParts[2];

        if (StringUtils.isBlank(value) || StringUtils.isBlank(remoteAddr) || StringUtils.isBlank(userAgent)) {
            throw new IllegalStateException("Invalid cookie. Required fields are empty");
        }

        final ClientInfo clientInfo = ClientInfoHolder.getClientInfo();
        if (!remoteAddr.equals(clientInfo.getClientIpAddress())) {
            throw new IllegalStateException("Invalid cookie. Required remote address does not match " + clientInfo.getClientIpAddress());
        }

        final String agent = WebUtils.getHttpServletRequestUserAgent(request);
        if (!userAgent.equals(agent)) {
            throw new IllegalStateException("Invalid cookie. Required user-agent does not match " + agent);
        }
        return value;
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="mx.com.redcup.redcup">

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

    <application
        android:name="android.support.multidex.MultiDexApplication"
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="Redcupa"
        android:roundIcon="@mipmap/ic_launcher"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <meta-data
            android:name="com.facebook.sdk.ApplicationId"
            android:value="@string/facebook_app_id" />

        <activity
            android:name=".LoginActivity"
            android:theme="@style/AppTheme.NoActionBar" />
        <!--
             The API key for Google Maps-based APIs is defined as a string resource.
             (See the file "res/values/google_maps_api.xml").
             Note that the API key is linked to the encryption key used to sign the APK.
             You need a different API key for each encryption key, including the release key that is used to
             sign the APK for publishing.
             You can define the keys for the debug and release targets in src/debug/ and src/release/.
        -->
        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="@string/google_maps_key" />

        <activity
            android:name=".NavActivity"
            android:label="Redcupa"
            android:theme="@style/AppTheme.NoActionBar"
            android:windowSoftInputMode="adjustNothing">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <meta-data
                android:name="android.app.searchable"
                android:resource="@xml/searchable" />
        </activity>
        <activity
            android:name=".NewPostActivity"
            android:label="Create a new event"
            android:windowSoftInputMode="adjustResize" />
        <activity
            android:name=".EventDetailsActivity"
            android:theme="@style/AppTheme.NoActionBar"
            android:windowSoftInputMode="adjustResize" />
        <activity
            android:name=".ProfileDetailsActivity"
            android:theme="@style/AppTheme.NoActionBar" />
        <activity
            android:name=".UserCreationActivity"
            android:label="Sign Up"
            android:theme="@style/AppTheme.NoActionBar" />
        <activity android:name=".SearchableActivity">
            <intent-filter>
                <action android:name="android.intent.action.SEARCH" />
            </intent-filter>
            <meta-data android:name="android.app.searchable"
                android:resource="@xml/searchable"/>
        </activity>
    </application>

</manifest>


text:
import React from 'react';
import { Component } from 'react';
import RaisedButton from 'material-ui/lib/raised-button';
import { Link } from 'react-router';
import SignInModal from '../modals/userSigninModal';
import StreamsUL from '../streamsList/listOfStreams';

let artistButton = {
  'margin-top': "45px",
  'margin-left': "35%",
};

let fanButton = {
  'margin-top': '45px',
  'margin-left': "10%",
};

let windowWidth = window.innerWidth;

if(windowWidth < 1600){
  artistButton['margin-left'] = '29%';
}

export default class Landing extends Component {
  render(){
    return(

 <Link to="router/nowStreaming" style={{"color": "orange"}}>Currently Streaming</Link>

            <StreamsUL />

 Pick up the mic!

Broadcast your GIGG now!

            <RaisedButton
              label="Artists"
              secondary={true}
              style={artistButton}
              linkButton={true}
              containerElement={<Link to="/router/artistAuthenticate/signup" >Sign in/Up </Link>}
            />
            <RaisedButton
               label="Fans"
               secondary={true}
               style={fanButton}
               linkButton={true}
               containerElement={<Link to="/router/nowStreaming" className="logoLink"> Now Streaming </Link>}
            />

      )
  }
}


text:
<?php

namespace Happyr\DoctrineSpecification\Filter;

class Like extends Comparison
{
    const CONTAINS = "%%%s%%";
    const ENDS_WITH = "%%%s";
    const STARTS_WITH = "%s%%";

    public function __construct($field, $value, $format = self::CONTAINS, $dqlAlias = null)
    {
        $formattedValue = $this->formatValue($format, $value);
        parent::__construct(self::LIKE, $field, $formattedValue, $dqlAlias);
    }

    /**
     * @param string $format
     */
    private function formatValue($format, $value)
    {
        return sprintf($format, $value);
    }
}


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

    <solid android:color="@color/indigo_alpha" />

</shape>


text:
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
package bsh.org.objectweb.asm;

/**
 * The JVM opcodes, access flags and array type codes. This interface does not define all the JVM
 * opcodes because some opcodes are automatically handled. For example, the xLOAD and xSTORE opcodes
 * are automatically replaced by xLOAD_n and xSTORE_n opcodes when possible. The xLOAD_n and
 * xSTORE_n opcodes are therefore not defined in this interface. Likewise for LDC, automatically
 * replaced by LDC_W or LDC2_W when necessary, WIDE, GOTO_W and JSR_W.
 *
 * @see JVMS 6
 * @author Eric Bruneton
 * @author Eugene Kuleshov
 */
public interface Opcodes {

  // ASM API versions.

  int ASM4 = 4 << 16 | 0 << 8;
  int ASM5 = 5 << 16 | 0 << 8;
  int ASM6 = 6 << 16 | 0 << 8;

  // Java ClassFile versions (the minor version is stored in the 16 most
  // significant bits, and the
  // major version in the 16 least significant bits).

  int V1_1 = 3 << 16 | 45;
  int V1_2 = 0 << 16 | 46;
  int V1_3 = 0 << 16 | 47;
  int V1_4 = 0 << 16 | 48;
  int V1_5 = 0 << 16 | 49;
  int V1_6 = 0 << 16 | 50;
  int V1_7 = 0 << 16 | 51;
  int V1_8 = 0 << 16 | 52;
  int V9 = 0 << 16 | 53;
  int V10 = 0 << 16 | 54;
  int V11 = 0 << 16 | 55;

  /**
   * Version flag indicating that the class is using 'preview' features.
   *
   *
{@code version & V_PREVIEW_EXPERIMENTAL == V_PREVIEW_EXPERIMENTAL} tests if a version is
   * flagged with {@code V_PREVIEW_EXPERIMENTAL}.
   *
   * @deprecated This API is experimental.
   */
  @Deprecated int V_PREVIEW_EXPERIMENTAL = 0xFFFF0000;

  // Access flags values, defined in
  // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.1-200-E.1
  // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.5-200-A.1
  // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.6-200-A.1
  // - https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.25

  int ACC_PUBLIC = 0x0001; // class, field, method
  int ACC_PRIVATE = 0x0002; // class, field, method
  int ACC_PROTECTED = 0x0004; // class, field, method
  int ACC_STATIC = 0x0008; // field, method
  int ACC_FINAL = 0x0010; // class, field, method, parameter
  int ACC_SUPER = 0x0020; // class
  int ACC_SYNCHRONIZED = 0x0020; // method
  int ACC_OPEN = 0x0020; // module
  int ACC_TRANSITIVE = 0x0020; // module requires
  int ACC_VOLATILE = 0x0040; // field
  int ACC_BRIDGE = 0x0040; // method
  int ACC_STATIC_PHASE = 0x0040; // module requires
  int ACC_VARARGS = 0x0080; // method
  int ACC_TRANSIENT = 0x0080; // field
  int ACC_NATIVE = 0x0100; // method
  int ACC_INTERFACE = 0x0200; // class
  int ACC_ABSTRACT = 0x0400; // class, method
  int ACC_STRICT = 0x0800; // method
  int ACC_SYNTHETIC = 0x1000; // class, field, method, parameter, module *
  int ACC_ANNOTATION = 0x2000; // class
  int ACC_ENUM = 0x4000; // class(?) field inner
  int ACC_MANDATED = 0x8000; // parameter, module, module *
  int ACC_MODULE = 0x8000; // class

  // ASM specific access flags.
  // WARNING: the 16 least significant bits must NOT be used, to avoid conflicts with standard
  // access flags, and also to make sure that these flags are automatically filtered out when
  // written in class files (because access flags are stored using 16 bits only).

  int ACC_DEPRECATED = 0x20000; // class, field, method

  // Possible values for the type operand of the NEWARRAY instruction.
  // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-6.html#jvms-6.5.newarray.

  int T_BOOLEAN = 4;
  int T_CHAR = 5;
  int T_FLOAT = 6;
  int T_DOUBLE = 7;
  int T_BYTE = 8;
  int T_SHORT = 9;
  int T_INT = 10;
  int T_LONG = 11;

  // Possible values for the reference_kind field of CONSTANT_MethodHandle_info structures.
  // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.4.8.

  int H_GETFIELD = 1;
  int H_GETSTATIC = 2;
  int H_PUTFIELD = 3;
  int H_PUTSTATIC = 4;
  int H_INVOKEVIRTUAL = 5;
  int H_INVOKESTATIC = 6;
  int H_INVOKESPECIAL = 7;
  int H_NEWINVOKESPECIAL = 8;
  int H_INVOKEINTERFACE = 9;

  // ASM specific stack map frame types, used in {@link ClassVisitor#visitFrame}.

  /** An expanded frame. See {@link ClassReader#EXPAND_FRAMES}. */
  int F_NEW = -1;

  /** A compressed frame with complete frame data. */
  int F_FULL = 0;

  /**
   * A compressed frame where locals are the same as the locals in the previous frame, except that
   * additional 1-3 locals are defined, and with an empty stack.
   */
  int F_APPEND = 1;

  /**
   * A compressed frame where locals are the same as the locals in the previous frame, except that
   * the last 1-3 locals are absent and with an empty stack.
   */
  int F_CHOP = 2;

  /**
   * A compressed frame with exactly the same locals as the previous frame and with an empty stack.
   */
  int F_SAME = 3;

  /**
   * A compressed frame with exactly the same locals as the previous frame and with a single value
   * on the stack.
   */
  int F_SAME1 = 4;

  // Standard stack map frame element types, used in {@link ClassVisitor#visitFrame}.

  Integer TOP = Frame.ITEM_TOP;
  Integer INTEGER = Frame.ITEM_INTEGER;
  Integer FLOAT = Frame.ITEM_FLOAT;
  Integer DOUBLE = Frame.ITEM_DOUBLE;
  Integer LONG = Frame.ITEM_LONG;
  Integer NULL = Frame.ITEM_NULL;
  Integer UNINITIALIZED_THIS = Frame.ITEM_UNINITIALIZED_THIS;

  // The JVM opcode values (with the MethodVisitor method name used to visit them in comment, and
  // where '-' means 'same method name as on the previous line').
  // See https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-6.html.

  int NOP = 0; // visitInsn
  int ACONST_NULL = 1; // -
  int ICONST_M1 = 2; // -
  int ICONST_0 = 3; // -
  int ICONST_1 = 4; // -
  int ICONST_2 = 5; // -
  int ICONST_3 = 6; // -
  int ICONST_4 = 7; // -
  int ICONST_5 = 8; // -
  int LCONST_0 = 9; // -
  int LCONST_1 = 10; // -
  int FCONST_0 = 11; // -
  int FCONST_1 = 12; // -
  int FCONST_2 = 13; // -
  int DCONST_0 = 14; // -
  int DCONST_1 = 15; // -
  int BIPUSH = 16; // visitIntInsn
  int SIPUSH = 17; // -
  int LDC = 18; // visitLdcInsn
  int ILOAD = 21; // visitVarInsn
  int LLOAD = 22; // -
  int FLOAD = 23; // -
  int DLOAD = 24; // -
  int ALOAD = 25; // -
  int IALOAD = 46; // visitInsn
  int LALOAD = 47; // -
  int FALOAD = 48; // -
  int DALOAD = 49; // -
  int AALOAD = 50; // -
  int BALOAD = 51; // -
  int CALOAD = 52; // -
  int SALOAD = 53; // -
  int ISTORE = 54; // visitVarInsn
  int LSTORE = 55; // -
  int FSTORE = 56; // -
  int DSTORE = 57; // -
  int ASTORE = 58; // -
  int IASTORE = 79; // visitInsn
  int LASTORE = 80; // -
  int FASTORE = 81; // -
  int DASTORE = 82; // -
  int AASTORE = 83; // -
  int BASTORE = 84; // -
  int CASTORE = 85; // -
  int SASTORE = 86; // -
  int POP = 87; // -
  int POP2 = 88; // -
  int DUP = 89; // -
  int DUP_X1 = 90; // -
  int DUP_X2 = 91; // -
  int DUP2 = 92; // -
  int DUP2_X1 = 93; // -
  int DUP2_X2 = 94; // -
  int SWAP = 95; // -
  int IADD = 96; // -
  int LADD = 97; // -
  int FADD = 98; // -
  int DADD = 99; // -
  int ISUB = 100; // -
  int LSUB = 101; // -
  int FSUB = 102; // -
  int DSUB = 103; // -
  int IMUL = 104; // -
  int LMUL = 105; // -
  int FMUL = 106; // -
  int DMUL = 107; // -
  int IDIV = 108; // -
  int LDIV = 109; // -
  int FDIV = 110; // -
  int DDIV = 111; // -
  int IREM = 112; // -
  int LREM = 113; // -
  int FREM = 114; // -
  int DREM = 115; // -
  int INEG = 116; // -
  int LNEG = 117; // -
  int FNEG = 118; // -
  int DNEG = 119; // -
  int ISHL = 120; // -
  int LSHL = 121; // -
  int ISHR = 122; // -
  int LSHR = 123; // -
  int IUSHR = 124; // -
  int LUSHR = 125; // -
  int IAND = 126; // -
  int LAND = 127; // -
  int IOR = 128; // -
  int LOR = 129; // -
  int IXOR = 130; // -
  int LXOR = 131; // -
  int IINC = 132; // visitIincInsn
  int I2L = 133; // visitInsn
  int I2F = 134; // -
  int I2D = 135; // -
  int L2I = 136; // -
  int L2F = 137; // -
  int L2D = 138; // -
  int F2I = 139; // -
  int F2L = 140; // -
  int F2D = 141; // -
  int D2I = 142; // -
  int D2L = 143; // -
  int D2F = 144; // -
  int I2B = 145; // -
  int I2C = 146; // -
  int I2S = 147; // -
  int LCMP = 148; // -
  int FCMPL = 149; // -
  int FCMPG = 150; // -
  int DCMPL = 151; // -
  int DCMPG = 152; // -
  int IFEQ = 153; // visitJumpInsn
  int IFNE = 154; // -
  int IFLT = 155; // -
  int IFGE = 156; // -
  int IFGT = 157; // -
  int IFLE = 158; // -
  int IF_ICMPEQ = 159; // -
  int IF_ICMPNE = 160; // -
  int IF_ICMPLT = 161; // -
  int IF_ICMPGE = 162; // -
  int IF_ICMPGT = 163; // -
  int IF_ICMPLE = 164; // -
  int IF_ACMPEQ = 165; // -
  int IF_ACMPNE = 166; // -
  int GOTO = 167; // -
  int JSR = 168; // -
  int RET = 169; // visitVarInsn
  int TABLESWITCH = 170; // visiTableSwitchInsn
  int LOOKUPSWITCH = 171; // visitLookupSwitch
  int IRETURN = 172; // visitInsn
  int LRETURN = 173; // -
  int FRETURN = 174; // -
  int DRETURN = 175; // -
  int ARETURN = 176; // -
  int RETURN = 177; // -
  int GETSTATIC = 178; // visitFieldInsn
  int PUTSTATIC = 179; // -
  int GETFIELD = 180; // -
  int PUTFIELD = 181; // -
  int INVOKEVIRTUAL = 182; // visitMethodInsn
  int INVOKESPECIAL = 183; // -
  int INVOKESTATIC = 184; // -
  int INVOKEINTERFACE = 185; // -
  int INVOKEDYNAMIC = 186; // visitInvokeDynamicInsn
  int NEW = 187; // visitTypeInsn
  int NEWARRAY = 188; // visitIntInsn
  int ANEWARRAY = 189; // visitTypeInsn
  int ARRAYLENGTH = 190; // visitInsn
  int ATHROW = 191; // -
  int CHECKCAST = 192; // visitTypeInsn
  int INSTANCEOF = 193; // -
  int MONITORENTER = 194; // visitInsn
  int MONITOREXIT = 195; // -
  int MULTIANEWARRAY = 197; // visitMultiANewArrayInsn
  int IFNULL = 198; // visitJumpInsn
  int IFNONNULL = 199; // -
}


text:
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/dataflow/v1beta3/snapshots.proto

package com.google.dataflow.v1beta3;

/**
 *
 *
 *

 * List of snapshots.
 *

 *
 * Protobuf type {@code google.dataflow.v1beta3.ListSnapshotsResponse}
 */
public final class ListSnapshotsResponse extends com.google.protobuf.GeneratedMessageV3
    implements
    // @@protoc_insertion_point(message_implements:google.dataflow.v1beta3.ListSnapshotsResponse)
    ListSnapshotsResponseOrBuilder {
  private static final long serialVersionUID = 0L;
  // Use ListSnapshotsResponse.newBuilder() to construct.
  private ListSnapshotsResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
    super(builder);
  }

  private ListSnapshotsResponse() {
    snapshots_ = java.util.Collections.emptyList();
  }

  @java.lang.Override
  @SuppressWarnings({"unused"})
  protected java.lang.Object newInstance(UnusedPrivateParameter unused) {
    return new ListSnapshotsResponse();
  }

  @java.lang.Override
  public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
    return this.unknownFields;
  }

  public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.google.dataflow.v1beta3.SnapshotsProto
        .internal_static_google_dataflow_v1beta3_ListSnapshotsResponse_descriptor;
  }

  @java.lang.Override
  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internalGetFieldAccessorTable() {
    return com.google.dataflow.v1beta3.SnapshotsProto
        .internal_static_google_dataflow_v1beta3_ListSnapshotsResponse_fieldAccessorTable
        .ensureFieldAccessorsInitialized(
            com.google.dataflow.v1beta3.ListSnapshotsResponse.class,
            com.google.dataflow.v1beta3.ListSnapshotsResponse.Builder.class);
  }

  public static final int SNAPSHOTS_FIELD_NUMBER = 1;
  private java.util.List<com.google.dataflow.v1beta3.Snapshot> snapshots_;
  /**
   *
   *
   *

   * Returned snapshots.
   *

   *
   * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
   */
  @java.lang.Override
  public java.util.List<com.google.dataflow.v1beta3.Snapshot> getSnapshotsList() {
    return snapshots_;
  }
  /**
   *
   *
   *

   * Returned snapshots.
   *

   *
   * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
   */
  @java.lang.Override
  public java.util.List<? extends com.google.dataflow.v1beta3.SnapshotOrBuilder>
      getSnapshotsOrBuilderList() {
    return snapshots_;
  }
  /**
   *
   *
   *

   * Returned snapshots.
   *

   *
   * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
   */
  @java.lang.Override
  public int getSnapshotsCount() {
    return snapshots_.size();
  }
  /**
   *
   *
   *

   * Returned snapshots.
   *

   *
   * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
   */
  @java.lang.Override
  public com.google.dataflow.v1beta3.Snapshot getSnapshots(int index) {
    return snapshots_.get(index);
  }
  /**
   *
   *
   *

   * Returned snapshots.
   *

   *
   * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
   */
  @java.lang.Override
  public com.google.dataflow.v1beta3.SnapshotOrBuilder getSnapshotsOrBuilder(int index) {
    return snapshots_.get(index);
  }

  private byte memoizedIsInitialized = -1;

  @java.lang.Override
  public final boolean isInitialized() {
    byte isInitialized = memoizedIsInitialized;
    if (isInitialized == 1) return true;
    if (isInitialized == 0) return false;

    memoizedIsInitialized = 1;
    return true;
  }

  @java.lang.Override
  public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException {
    for (int i = 0; i < snapshots_.size(); i++) {
      output.writeMessage(1, snapshots_.get(i));
    }
    getUnknownFields().writeTo(output);
  }

  @java.lang.Override
  public int getSerializedSize() {
    int size = memoizedSize;
    if (size != -1) return size;

    size = 0;
    for (int i = 0; i < snapshots_.size(); i++) {
      size += com.google.protobuf.CodedOutputStream.computeMessageSize(1, snapshots_.get(i));
    }
    size += getUnknownFields().getSerializedSize();
    memoizedSize = size;
    return size;
  }

  @java.lang.Override
  public boolean equals(final java.lang.Object obj) {
    if (obj == this) {
      return true;
    }
    if (!(obj instanceof com.google.dataflow.v1beta3.ListSnapshotsResponse)) {
      return super.equals(obj);
    }
    com.google.dataflow.v1beta3.ListSnapshotsResponse other =
        (com.google.dataflow.v1beta3.ListSnapshotsResponse) obj;

    if (!getSnapshotsList().equals(other.getSnapshotsList())) return false;
    if (!getUnknownFields().equals(other.getUnknownFields())) return false;
    return true;
  }

  @java.lang.Override
  public int hashCode() {
    if (memoizedHashCode != 0) {
      return memoizedHashCode;
    }
    int hash = 41;
    hash = (19 * hash) + getDescriptor().hashCode();
    if (getSnapshotsCount() > 0) {
      hash = (37 * hash) + SNAPSHOTS_FIELD_NUMBER;
      hash = (53 * hash) + getSnapshotsList().hashCode();
    }
    hash = (29 * hash) + getUnknownFields().hashCode();
    memoizedHashCode = hash;
    return hash;
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data, extensionRegistry);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      com.google.protobuf.ByteString data)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      com.google.protobuf.ByteString data,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data, extensionRegistry);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(byte[] data)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws com.google.protobuf.InvalidProtocolBufferException {
    return PARSER.parseFrom(data, extensionRegistry);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      java.io.InputStream input) throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3.parseWithIOException(
        PARSER, input, extensionRegistry);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseDelimitedFrom(
      java.io.InputStream input) throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseDelimitedFrom(
      java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(
        PARSER, input, extensionRegistry);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      com.google.protobuf.CodedInputStream input) throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input);
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse parseFrom(
      com.google.protobuf.CodedInputStream input,
      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
      throws java.io.IOException {
    return com.google.protobuf.GeneratedMessageV3.parseWithIOException(
        PARSER, input, extensionRegistry);
  }

  @java.lang.Override
  public Builder newBuilderForType() {
    return newBuilder();
  }

  public static Builder newBuilder() {
    return DEFAULT_INSTANCE.toBuilder();
  }

  public static Builder newBuilder(com.google.dataflow.v1beta3.ListSnapshotsResponse prototype) {
    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
  }

  @java.lang.Override
  public Builder toBuilder() {
    return this == DEFAULT_INSTANCE ? new Builder() : new Builder().mergeFrom(this);
  }

  @java.lang.Override
  protected Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
    Builder builder = new Builder(parent);
    return builder;
  }
  /**
   *
   *
   *

   * List of snapshots.
   *

   *
   * Protobuf type {@code google.dataflow.v1beta3.ListSnapshotsResponse}
   */
  public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder<Builder>
      implements
      // @@protoc_insertion_point(builder_implements:google.dataflow.v1beta3.ListSnapshotsResponse)
      com.google.dataflow.v1beta3.ListSnapshotsResponseOrBuilder {
    public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
      return com.google.dataflow.v1beta3.SnapshotsProto
          .internal_static_google_dataflow_v1beta3_ListSnapshotsResponse_descriptor;
    }

    @java.lang.Override
    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return com.google.dataflow.v1beta3.SnapshotsProto
          .internal_static_google_dataflow_v1beta3_ListSnapshotsResponse_fieldAccessorTable
          .ensureFieldAccessorsInitialized(
              com.google.dataflow.v1beta3.ListSnapshotsResponse.class,
              com.google.dataflow.v1beta3.ListSnapshotsResponse.Builder.class);
    }

    // Construct using com.google.dataflow.v1beta3.ListSnapshotsResponse.newBuilder()
    private Builder() {}

    private Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
      super(parent);
    }

    @java.lang.Override
    public Builder clear() {
      super.clear();
      if (snapshotsBuilder_ == null) {
        snapshots_ = java.util.Collections.emptyList();
      } else {
        snapshots_ = null;
        snapshotsBuilder_.clear();
      }
      bitField0_ = (bitField0_ & ~0x00000001);
      return this;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
      return com.google.dataflow.v1beta3.SnapshotsProto
          .internal_static_google_dataflow_v1beta3_ListSnapshotsResponse_descriptor;
    }

    @java.lang.Override
    public com.google.dataflow.v1beta3.ListSnapshotsResponse getDefaultInstanceForType() {
      return com.google.dataflow.v1beta3.ListSnapshotsResponse.getDefaultInstance();
    }

    @java.lang.Override
    public com.google.dataflow.v1beta3.ListSnapshotsResponse build() {
      com.google.dataflow.v1beta3.ListSnapshotsResponse result = buildPartial();
      if (!result.isInitialized()) {
        throw newUninitializedMessageException(result);
      }
      return result;
    }

    @java.lang.Override
    public com.google.dataflow.v1beta3.ListSnapshotsResponse buildPartial() {
      com.google.dataflow.v1beta3.ListSnapshotsResponse result =
          new com.google.dataflow.v1beta3.ListSnapshotsResponse(this);
      int from_bitField0_ = bitField0_;
      if (snapshotsBuilder_ == null) {
        if (((bitField0_ & 0x00000001) != 0)) {
          snapshots_ = java.util.Collections.unmodifiableList(snapshots_);
          bitField0_ = (bitField0_ & ~0x00000001);
        }
        result.snapshots_ = snapshots_;
      } else {
        result.snapshots_ = snapshotsBuilder_.build();
      }
      onBuilt();
      return result;
    }

    @java.lang.Override
    public Builder clone() {
      return super.clone();
    }

    @java.lang.Override
    public Builder setField(
        com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) {
      return super.setField(field, value);
    }

    @java.lang.Override
    public Builder clearField(com.google.protobuf.Descriptors.FieldDescriptor field) {
      return super.clearField(field);
    }

    @java.lang.Override
    public Builder clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof) {
      return super.clearOneof(oneof);
    }

    @java.lang.Override
    public Builder setRepeatedField(
        com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value) {
      return super.setRepeatedField(field, index, value);
    }

    @java.lang.Override
    public Builder addRepeatedField(
        com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) {
      return super.addRepeatedField(field, value);
    }

    @java.lang.Override
    public Builder mergeFrom(com.google.protobuf.Message other) {
      if (other instanceof com.google.dataflow.v1beta3.ListSnapshotsResponse) {
        return mergeFrom((com.google.dataflow.v1beta3.ListSnapshotsResponse) other);
      } else {
        super.mergeFrom(other);
        return this;
      }
    }

    public Builder mergeFrom(com.google.dataflow.v1beta3.ListSnapshotsResponse other) {
      if (other == com.google.dataflow.v1beta3.ListSnapshotsResponse.getDefaultInstance())
        return this;
      if (snapshotsBuilder_ == null) {
        if (!other.snapshots_.isEmpty()) {
          if (snapshots_.isEmpty()) {
            snapshots_ = other.snapshots_;
            bitField0_ = (bitField0_ & ~0x00000001);
          } else {
            ensureSnapshotsIsMutable();
            snapshots_.addAll(other.snapshots_);
          }
          onChanged();
        }
      } else {
        if (!other.snapshots_.isEmpty()) {
          if (snapshotsBuilder_.isEmpty()) {
            snapshotsBuilder_.dispose();
            snapshotsBuilder_ = null;
            snapshots_ = other.snapshots_;
            bitField0_ = (bitField0_ & ~0x00000001);
            snapshotsBuilder_ =
                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders
                    ? getSnapshotsFieldBuilder()
                    : null;
          } else {
            snapshotsBuilder_.addAllMessages(other.snapshots_);
          }
        }
      }
      this.mergeUnknownFields(other.getUnknownFields());
      onChanged();
      return this;
    }

    @java.lang.Override
    public final boolean isInitialized() {
      return true;
    }

    @java.lang.Override
    public Builder mergeFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      if (extensionRegistry == null) {
        throw new java.lang.NullPointerException();
      }
      try {
        boolean done = false;
        while (!done) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              done = true;
              break;
            case 10:
              {
                com.google.dataflow.v1beta3.Snapshot m =
                    input.readMessage(
                        com.google.dataflow.v1beta3.Snapshot.parser(), extensionRegistry);
                if (snapshotsBuilder_ == null) {
                  ensureSnapshotsIsMutable();
                  snapshots_.add(m);
                } else {
                  snapshotsBuilder_.addMessage(m);
                }
                break;
              } // case 10
            default:
              {
                if (!super.parseUnknownField(input, extensionRegistry, tag)) {
                  done = true; // was an endgroup tag
                }
                break;
              } // default:
          } // switch (tag)
        } // while (!done)
      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
        throw e.unwrapIOException();
      } finally {
        onChanged();
      } // finally
      return this;
    }

    private int bitField0_;

    private java.util.List<com.google.dataflow.v1beta3.Snapshot> snapshots_ =
        java.util.Collections.emptyList();

    private void ensureSnapshotsIsMutable() {
      if (!((bitField0_ & 0x00000001) != 0)) {
        snapshots_ = new java.util.ArrayList<com.google.dataflow.v1beta3.Snapshot>(snapshots_);
        bitField0_ |= 0x00000001;
      }
    }

    private com.google.protobuf.RepeatedFieldBuilderV3<
            com.google.dataflow.v1beta3.Snapshot,
            com.google.dataflow.v1beta3.Snapshot.Builder,
            com.google.dataflow.v1beta3.SnapshotOrBuilder>
        snapshotsBuilder_;

    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public java.util.List<com.google.dataflow.v1beta3.Snapshot> getSnapshotsList() {
      if (snapshotsBuilder_ == null) {
        return java.util.Collections.unmodifiableList(snapshots_);
      } else {
        return snapshotsBuilder_.getMessageList();
      }
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public int getSnapshotsCount() {
      if (snapshotsBuilder_ == null) {
        return snapshots_.size();
      } else {
        return snapshotsBuilder_.getCount();
      }
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public com.google.dataflow.v1beta3.Snapshot getSnapshots(int index) {
      if (snapshotsBuilder_ == null) {
        return snapshots_.get(index);
      } else {
        return snapshotsBuilder_.getMessage(index);
      }
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder setSnapshots(int index, com.google.dataflow.v1beta3.Snapshot value) {
      if (snapshotsBuilder_ == null) {
        if (value == null) {
          throw new NullPointerException();
        }
        ensureSnapshotsIsMutable();
        snapshots_.set(index, value);
        onChanged();
      } else {
        snapshotsBuilder_.setMessage(index, value);
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder setSnapshots(
        int index, com.google.dataflow.v1beta3.Snapshot.Builder builderForValue) {
      if (snapshotsBuilder_ == null) {
        ensureSnapshotsIsMutable();
        snapshots_.set(index, builderForValue.build());
        onChanged();
      } else {
        snapshotsBuilder_.setMessage(index, builderForValue.build());
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder addSnapshots(com.google.dataflow.v1beta3.Snapshot value) {
      if (snapshotsBuilder_ == null) {
        if (value == null) {
          throw new NullPointerException();
        }
        ensureSnapshotsIsMutable();
        snapshots_.add(value);
        onChanged();
      } else {
        snapshotsBuilder_.addMessage(value);
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder addSnapshots(int index, com.google.dataflow.v1beta3.Snapshot value) {
      if (snapshotsBuilder_ == null) {
        if (value == null) {
          throw new NullPointerException();
        }
        ensureSnapshotsIsMutable();
        snapshots_.add(index, value);
        onChanged();
      } else {
        snapshotsBuilder_.addMessage(index, value);
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder addSnapshots(com.google.dataflow.v1beta3.Snapshot.Builder builderForValue) {
      if (snapshotsBuilder_ == null) {
        ensureSnapshotsIsMutable();
        snapshots_.add(builderForValue.build());
        onChanged();
      } else {
        snapshotsBuilder_.addMessage(builderForValue.build());
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder addSnapshots(
        int index, com.google.dataflow.v1beta3.Snapshot.Builder builderForValue) {
      if (snapshotsBuilder_ == null) {
        ensureSnapshotsIsMutable();
        snapshots_.add(index, builderForValue.build());
        onChanged();
      } else {
        snapshotsBuilder_.addMessage(index, builderForValue.build());
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder addAllSnapshots(
        java.lang.Iterable<? extends com.google.dataflow.v1beta3.Snapshot> values) {
      if (snapshotsBuilder_ == null) {
        ensureSnapshotsIsMutable();
        com.google.protobuf.AbstractMessageLite.Builder.addAll(values, snapshots_);
        onChanged();
      } else {
        snapshotsBuilder_.addAllMessages(values);
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder clearSnapshots() {
      if (snapshotsBuilder_ == null) {
        snapshots_ = java.util.Collections.emptyList();
        bitField0_ = (bitField0_ & ~0x00000001);
        onChanged();
      } else {
        snapshotsBuilder_.clear();
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public Builder removeSnapshots(int index) {
      if (snapshotsBuilder_ == null) {
        ensureSnapshotsIsMutable();
        snapshots_.remove(index);
        onChanged();
      } else {
        snapshotsBuilder_.remove(index);
      }
      return this;
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public com.google.dataflow.v1beta3.Snapshot.Builder getSnapshotsBuilder(int index) {
      return getSnapshotsFieldBuilder().getBuilder(index);
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public com.google.dataflow.v1beta3.SnapshotOrBuilder getSnapshotsOrBuilder(int index) {
      if (snapshotsBuilder_ == null) {
        return snapshots_.get(index);
      } else {
        return snapshotsBuilder_.getMessageOrBuilder(index);
      }
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public java.util.List<? extends com.google.dataflow.v1beta3.SnapshotOrBuilder>
        getSnapshotsOrBuilderList() {
      if (snapshotsBuilder_ != null) {
        return snapshotsBuilder_.getMessageOrBuilderList();
      } else {
        return java.util.Collections.unmodifiableList(snapshots_);
      }
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public com.google.dataflow.v1beta3.Snapshot.Builder addSnapshotsBuilder() {
      return getSnapshotsFieldBuilder()
          .addBuilder(com.google.dataflow.v1beta3.Snapshot.getDefaultInstance());
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public com.google.dataflow.v1beta3.Snapshot.Builder addSnapshotsBuilder(int index) {
      return getSnapshotsFieldBuilder()
          .addBuilder(index, com.google.dataflow.v1beta3.Snapshot.getDefaultInstance());
    }
    /**
     *
     *
     *

     * Returned snapshots.
     *

     *
     * repeated .google.dataflow.v1beta3.Snapshot snapshots = 1;
     */
    public java.util.List<com.google.dataflow.v1beta3.Snapshot.Builder> getSnapshotsBuilderList() {
      return getSnapshotsFieldBuilder().getBuilderList();
    }

    private com.google.protobuf.RepeatedFieldBuilderV3<
            com.google.dataflow.v1beta3.Snapshot,
            com.google.dataflow.v1beta3.Snapshot.Builder,
            com.google.dataflow.v1beta3.SnapshotOrBuilder>
        getSnapshotsFieldBuilder() {
      if (snapshotsBuilder_ == null) {
        snapshotsBuilder_ =
            new com.google.protobuf.RepeatedFieldBuilderV3<
                com.google.dataflow.v1beta3.Snapshot,
                com.google.dataflow.v1beta3.Snapshot.Builder,
                com.google.dataflow.v1beta3.SnapshotOrBuilder>(
                snapshots_, ((bitField0_ & 0x00000001) != 0), getParentForChildren(), isClean());
        snapshots_ = null;
      }
      return snapshotsBuilder_;
    }

    @java.lang.Override
    public final Builder setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) {
      return super.setUnknownFields(unknownFields);
    }

    @java.lang.Override
    public final Builder mergeUnknownFields(
        final com.google.protobuf.UnknownFieldSet unknownFields) {
      return super.mergeUnknownFields(unknownFields);
    }

    // @@protoc_insertion_point(builder_scope:google.dataflow.v1beta3.ListSnapshotsResponse)
  }

  // @@protoc_insertion_point(class_scope:google.dataflow.v1beta3.ListSnapshotsResponse)
  private static final com.google.dataflow.v1beta3.ListSnapshotsResponse DEFAULT_INSTANCE;

  static {
    DEFAULT_INSTANCE = new com.google.dataflow.v1beta3.ListSnapshotsResponse();
  }

  public static com.google.dataflow.v1beta3.ListSnapshotsResponse getDefaultInstance() {
    return DEFAULT_INSTANCE;
  }

  private static final com.google.protobuf.Parser<ListSnapshotsResponse> PARSER =
      new com.google.protobuf.AbstractParser<ListSnapshotsResponse>() {
        @java.lang.Override
        public ListSnapshotsResponse parsePartialFrom(
            com.google.protobuf.CodedInputStream input,
            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
            throws com.google.protobuf.InvalidProtocolBufferException {
          Builder builder = newBuilder();
          try {
            builder.mergeFrom(input, extensionRegistry);
          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
            throw e.setUnfinishedMessage(builder.buildPartial());
          } catch (com.google.protobuf.UninitializedMessageException e) {
            throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
          } catch (java.io.IOException e) {
            throw new com.google.protobuf.InvalidProtocolBufferException(e)
                .setUnfinishedMessage(builder.buildPartial());
          }
          return builder.buildPartial();
        }
      };

  public static com.google.protobuf.Parser<ListSnapshotsResponse> parser() {
    return PARSER;
  }

  @java.lang.Override
  public com.google.protobuf.Parser<ListSnapshotsResponse> getParserForType() {
    return PARSER;
  }

  @java.lang.Override
  public com.google.dataflow.v1beta3.ListSnapshotsResponse getDefaultInstanceForType() {
    return DEFAULT_INSTANCE;
  }
}