text:
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>MongoDB Node.js Driver</title>
    <link>/node-mongodb-native/2.2/</link>
    <description>Recent content on MongoDB Node.js Driver</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Wed, 01 Jun 2016 12:53:30 -0400</lastBuildDate>

	<atom:link href="/node-mongodb-native/2.2/index.xml" rel="self" type="application/rss+xml" />

    <item>
      <title>Projections</title>
      <link>/node-mongodb-native/2.2/tutorials/projections/</link>
      <pubDate>Wed, 01 Jun 2016 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/projections/</guid>
      <description>Projections By default, queries in MongoDB return all fields in matching documents. To limit the amount of data that MongoDB sends to applications, you can include a projection document in the query operation.
Projection Document The projection document limits the fields to return for all matching documents. The projection document can specify the inclusion of fields or the exclusion of field and has the following form:
{ field1: &lt;value&gt;, field2: &lt;value&gt; .</description>
    </item>

    <item>
      <title>GridFS API</title>
      <link>/node-mongodb-native/2.2/tutorials/gridfs/streaming/</link>
      <pubDate>Thu, 15 Oct 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/gridfs/streaming/</guid>
      <description>The GridFS API The MongoDB Node.js driver now supports a stream-based API for GridFS that&rsquo;s compatible with Node.js&rsquo; streams3, so you can .pipe() directly from file streams to MongoDB. In this tutorial, you&rsquo;ll see how to use the new GridFS streaming API to upload a CC-licensed 28 MB recording of the overture from Richard Wagner&rsquo;s opera Die Meistersinger von Nurnberg to MongoDB using streams.
Getting Set Up The new GridFS streaming functionality is part of the 2.</description>
    </item>

    <item>
      <title>GridFS</title>
      <link>/node-mongodb-native/2.2/tutorials/gridfs/</link>
      <pubDate>Wed, 05 Aug 2015 12:00:00 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/gridfs/</guid>
      <description>GridFS GridFS is a specification for storing and retrieving files that exceed the BSON-document size limit of 16 megabytes.
Instead of storing a file in a single document, GridFS divides a file into parts, or chunks, and stores each of those chunks as a separate document. By default, GridFS limits chunk size to 255 kilobytes. GridFS uses two collections to store files: the chunks collection which stores the file chunks, and the files collection that stores the file metadata.</description>
    </item>

    <item>
      <title>Authentication</title>
      <link>/node-mongodb-native/2.2/tutorials/connect/authenticating/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/connect/authenticating/</guid>
      <description>Authentication The Node.js driver supports all MongoDB authentication mechanisms, including those only available in the MongoDB Enterprise Edition.
DEFAULT Note Starting in MongoDB 3.0, MongoDB changed the default authentication mechanism from MONGODB-CR to SCRAM-SHA-1.
 To use the default mechanism, either omit the authentication mechanism specification or specify DEFAULT as the mechanism in the URI ConnectionString. The driver will attempt to authenticate using the SCRAM-SHA-1 authentication method if it is available on the MongoDB server.</description>
    </item>

    <item>
      <title>Collections</title>
      <link>/node-mongodb-native/2.2/tutorials/collections/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/collections/</guid>
      <description>Collections MongoDB stores documents in collections. If a collection does not exist, MongoDB creates the collection when you first store data for that collection.
You can also explicitly create a collection with various options, such as setting the maximum size or the documentation validation rules.
Capped Collection Capped collections have maximum size or document counts that prevent them from growing beyond maximum thresholds. All capped collections must specify a maximum size and may also specify a maximum document count.</description>
    </item>

    <item>
      <title>Database Commands</title>
      <link>/node-mongodb-native/2.2/tutorials/commands/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/commands/</guid>
      <description>Database Commands Database commands allow you to perform a wide range of diagnostic and administrative tasks with the Node.js driver. For example, the dbStats command returns storage statistics for a given database. Use the command function to access database commands.
// set up a command function var getDbStats = function(db, callback) { db.command({'dbStats': 1}, function(err, results) { console.log(results); callback(); } ); }; // use the function var MongoClient = require('mongodb').</description>
    </item>

    <item>
      <title>Geospatial Search</title>
      <link>/node-mongodb-native/2.2/tutorials/geospatial-search/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/geospatial-search/</guid>
      <description>Geospatial Search You can query against geospatial indexes in several ways via the Node.js driver, using geospatial query operators.
To create a 2dsphere index on a collection, pass a document containing the name of the field to be indexed with the value &lsquo;2dsphere&rsquo; to the createIndex() method.
var create2dSphereIndex = function(db, callback) { // Get the restaurants collection var collection = db.collection('restaurants'); // Create the index collection.createIndex( { 'address.coord' : &quot;2dsphere&quot; }, function(err, result) { console.</description>
    </item>

    <item>
      <title>Legacy GridStore</title>
      <link>/node-mongodb-native/2.2/tutorials/gridfs/gridstore/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/gridfs/gridstore/</guid>
      <description>Note The GridStore API is deprecated. Driver version 2.0 and later uses the GridFS API.
 GridStore GridStore is a single file inside GridFS that can be managed by the script.
Open a GridFS file Opening a GridStore is similar to opening a database. First you create a GridStore object, then open it.
var gs = new GridStore(db, filename, mode[, options])  Where:
 db is the database object filename is the name of the file in GridFS that needs to be accessed/created mode indicates the operation, can be one of:  &ldquo;r&rdquo; (Read): Looks for the file information in fs.</description>
    </item>

    <item>
      <title>Management</title>
      <link>/node-mongodb-native/2.2/reference/management/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/management/</guid>
      <description> Management The driver provides two mechanisms for examining its state:
 Logging: Comprehensive logging of all operations. Application Performance Monitoring: The Application Performance Monitoring API is an API developers to tap into the commands issues to MongoDB to record performance metrics and/or inspect the commands sent to MongoDB.  </description>
    </item>

    <item>
      <title>Text Search</title>
      <link>/node-mongodb-native/2.2/tutorials/text-search/</link>
      <pubDate>Thu, 19 Mar 2015 14:27:51 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/text-search/</guid>
      <description>Text Search Use the $text operator to perform text searches on fields which have a text index.
To create a text index on a collection, pass a document containing the name of the field to be indexed with the value &lsquo;text&rsquo; to the createIndex() method.
var createTextIndex = function(db, callback) { // Get the restaurants collection var collection = db.collection('restaurants'); // Create the index collection.createIndex( { name : &quot;text&quot; }, function(err, result) { console.</description>
    </item>

    <item>
      <title>Upgrading to 2.x</title>
      <link>/node-mongodb-native/2.2/upgrade-migration/upgrading/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:39 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/upgrade-migration/upgrading/</guid>
      <description>Migrating Your Application To 2.x There are some key changes in the driver that you should be aware of before migrating your application from version 1.x to 2.x. Some APIs are cleaned up, and some 1.x features have been deprecated.
Design differences in 2.x One major change is that the driver has been split into two pieces. There is a new mongodb-core that contains the low-level MongoDB APIs while mongodb contains the high-level driver.</description>
    </item>

    <item>
      <title>Upgrade Guide</title>
      <link>/node-mongodb-native/2.2/upgrade-migration/main/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:35 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/upgrade-migration/main/</guid>
      <description>What&rsquo;s New in 2.3 Key features of the 2.3 driver include:
 Implements Decimal128, a decimal floating-point numbering format that occupies 16 bytes (128 bits). See the CRUD tutorial for an example.   What&rsquo;s New in 2.2 Key features of the 2.2 driver include:
 Redesigned Connection Pool. Connection close will drain any outstanding operations. replicaSet parameter MUST be specified if using MongoClient to connect to replicaset, due to SDAM specification implementation.</description>
    </item>

    <item>
      <title>CRUD Operations</title>
      <link>/node-mongodb-native/2.2/reference/ecmascript6/crud/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/ecmascript6/crud/</guid>
      <description>ECMAScript 6 CRUD Let&rsquo;s take a look at the CRUD operations from the perspective of ECMAScript 6. In this guide we will be using the same examples as in the general CRUD specification overview but rewrite them to use the new ECMAScript 6 features. For all method options refer to the main CRUD tutorial.
 CRUD: CRUD Specification.  This reference also omits methods that no longer make sense when using ECMAScript 6 such as the each and forEach methods.</description>
    </item>

    <item>
      <title>CRUD Operations</title>
      <link>/node-mongodb-native/2.2/tutorials/crud/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/crud/</guid>
      <description>CRUD Operations For a walkthrough of the main CRUD operations please refer to the Quick Start guide.
Driver CRUD operations are defined as the operations performed to create, read, update, and delete documents. This tutorial covers both the basic CRUD methods and the specialized findAndModify based methods as well as the new Bulk API methods for efficient bulk write operations.
 Write Methods Write methods are divided into those which insert documents into a collection, those which update documents in a collection, and those which remove documents from a collection.</description>
    </item>

    <item>
      <title>Collations</title>
      <link>/node-mongodb-native/2.2/tutorials/collations/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/collations/</guid>
      <description>Overview Collations provide a set of rules which comply with the conventions of a particular language when comparing strings.
For example, in Canadian French, the last accent in a given word determines the sorting order.
Consider the following French words:
cote &lt; coté &lt; côte &lt; côté  The sort order using the Canadian French collation would result in the following:
cote &lt; côte &lt; coté &lt; côté  If collation is unspecified, MongoDB uses the simple binary comparison for strings.</description>
    </item>

    <item>
      <title>Connect to MongoDB</title>
      <link>/node-mongodb-native/2.2/tutorials/connect/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/connect/</guid>
      <description>Connect to MongoDB Note This reference applies to 2.1.11 or higher. For 2.1.10 or earlier, refer to the legacy connection settings. 2.1.11 is backward compatible with the legacy settings as well as the simplified settings.
 Use the MongoClient.connect method to connect to a running MongoDB deployment.
Connect to a Single MongoDB Instance To connect to a single MongoDB instance, specify the URI of the MongoDB instance to connect to.</description>
    </item>

    <item>
      <title>Connecting</title>
      <link>/node-mongodb-native/2.2/reference/ecmascript6/connecting/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/ecmascript6/connecting/</guid>
      <description>Connecting The MongoClient connection method returns a Promise if no callback is passed to it. Below is an example using the co package to run a generator function, which is one of the most exciting innovations of ECMAScript 6.
var MongoClient = require('mongodb').MongoClient, co = require('co'), assert = require('assert'); co(function*() { // Connection URL var url = 'mongodb://localhost:27017/myproject'; // Use connect method to connect to the Server var db = yield MongoClient.</description>
    </item>

    <item>
      <title>Connection Options</title>
      <link>/node-mongodb-native/2.2/reference/connecting/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/connecting/</guid>
      <description> Connection Options For more information on the connection options:
 URI Connection String: MongoDB connection string URI. Connection Settings: Reference on the driver-specific connection settings.  </description>
    </item>

    <item>
      <title>Connection Settings</title>
      <link>/node-mongodb-native/2.2/reference/connecting/connection-settings/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/connecting/connection-settings/</guid>
      <description>URI Connection Settings Optional connection settings are settings not covered by the URI Connection String . The following options are passed in the options parameter in the MongoClient.connect function.
var MongoClient = require('mongodb').MongoClient , assert = require('assert'); // Connection URL var url = 'mongodb://localhost:50000,localhost:50001/myproject'; // Use connect method to connect to the Server passing in // additional options MongoClient.connect(url, { poolSize: 10, ssl: true }, function(err, db) { assert.equal(null, err); console.</description>
    </item>

    <item>
      <title>ECMAScript 6</title>
      <link>/node-mongodb-native/2.2/reference/ecmascript6/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/ecmascript6/</guid>
      <description>ECMAScript 6 ECMAScript 6 or JavaScript 6 as it&rsquo;s more commonly known is the new future of the Javascript language. It introduces fundamental changes in JavaScript while maintaining backward compatibility with ECMAScript 5.
The MongoDB Node.js driver embraces the new JavaScript version to provide the end user with much improved functionality. We do this primarily by exposing Promises for all async methods without breaking backward compatibility with existing code using the driver.</description>
    </item>

    <item>
      <title>Frequently Asked Questions</title>
      <link>/node-mongodb-native/2.2/reference/faq/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/faq/</guid>
      <description>What is the difference between connectTimeoutMS, socketTimeoutMS and maxTimeMS ?    Setting Default Value MongoClient.connect Description     connectTimeoutMS 30000 The connectTimeoutMS sets the number of milliseconds a socket stays inactive before closing during the connection phase of the driver. That is to say, when the application initiates a connection, when a replica set connects to new members, or when a replica set reconnects to members.</description>
    </item>

    <item>
      <title>Legacy Connection Settings</title>
      <link>/node-mongodb-native/2.2/reference/connecting/legacy-connection-settings/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/connecting/legacy-connection-settings/</guid>
      <description>Connect To MongoDB (Legacy) Note For 2.1.10 or earlier. For newer versions, see Connect to MongoDB
 Connecting to MongoDB using the driver is primarily done using the MongoClient.connect method and a URI. Let&rsquo;s look at how we connect to a couple of different server topologies.
Single Server Connection We have a single MongoDB server instance running on the port 27017 Let&rsquo;s connect using the driver and MongoClient.connect
var MongoClient = require('mongodb').</description>
    </item>

    <item>
      <title>Pool Design</title>
      <link>/node-mongodb-native/2.2/reference/pool/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:30 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/pool/</guid>
      <description>Driver Pool Design The 2.0 series of the mongodb-core module introduces a newly re-designed pool that will grow and contract based on the usage pattern. This reference outlines how the growing/shrinking of the pool works, how authentication is handled and how operations are executed.
Operations are executed using a work-queue. That means the Pool is responsible for scheduling the execution of operations on connections. The benefit of this is that one avoids slow operations holding up fast operations as long as the following holds true.</description>
    </item>

    <item>
      <title>APM</title>
      <link>/node-mongodb-native/2.2/reference/management/apm/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:26 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/management/apm/</guid>
      <description>APM Application Performance Monitoring support is a driver feature that allows monitoring services to hook into the driver in a forward compatible and stable way. The API is not applied to the driver unless explicitly initialized to avoid any performance penalties.
API The following code example hooks into all the available features of the APM API.
var listener = require('mongodb').instrument({ operationIdGenerator: { operationId: 1, next: function() { return this.operationId++; } }, timestampGenerator: { current: function() { return new Date().</description>
    </item>

    <item>
      <title>SSL Settings</title>
      <link>/node-mongodb-native/2.2/tutorials/connect/ssl/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:26 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/connect/ssl/</guid>
      <description>TLS/SSL The Node.js driver supports TLS/SSL connections to MongoDB that support TLS/SSL support.
No Certificate Validation If the MongoDB instance does not perform any validation of the certificate chain, include the ssl=true in the URI Connection String .
var MongoClient = require('mongodb').MongoClient; MongoClient.connect(&quot;mongodb://localhost:27017/test?ssl=true&quot;, function(err, db) { db.close(); });  Validate Server Certificate If the MongoDB instance presents a certificate, to validate the server&rsquo;s certificate, pass to the MongoClient.connect method:</description>
    </item>

    <item>
      <title>Topology Monitoring</title>
      <link>/node-mongodb-native/2.2/reference/management/sdam-monitoring/</link>
      <pubDate>Thu, 19 Mar 2015 12:53:26 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/management/sdam-monitoring/</guid>
      <description>Topology Management The Node.js driver 2.1.10 or higher features SDAM Monitoring events, allowing an application or tool to monitor changes in the drivers view of a single server, replica set or mongos. This allows an application to react to changes of topology, such as a secondary joining or leaving a replica set.
Overview of SDAM events    Event Applies To Description     serverOpening Server, Replicaset, Mongos Emitted when server connection is established.</description>
    </item>

    <item>
      <title>Aggregation</title>
      <link>/node-mongodb-native/2.2/tutorials/aggregation/</link>
      <pubDate>Wed, 18 Mar 2015 21:14:20 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/aggregation/</guid>
      <description>Aggregation Overview Aggregation operations process data records and return computed results. Aggregation operations group values from multiple documents together, and can perform a variety of operations on the grouped data to return a single result.
The Aggregation Pipeline The aggregation pipeline is a framework for data aggregation modeled on the concept of data processing pipelines. Documents enter a multi-stage pipeline that transforms the documents into aggregated results.
For a full explanation and a complete list of pipeline stages and operators, see the manual:</description>
    </item>

    <item>
      <title>Logging</title>
      <link>/node-mongodb-native/2.2/reference/management/logging/</link>
      <pubDate>Wed, 18 Mar 2015 21:14:20 -0400</pubDate>

      <guid>/node-mongodb-native/2.2/reference/management/logging/</guid>
      <description>Logging You can change the log level, filter on classes to allow only specific classes to log, and provide your own logger implementation.
Setting Log level The driver allows logging at three different levels: debug, info and error. The default level is error. The following example demonstrates how to set the logger to debug.
var MongoClient = require('mongodb').MongoClient , Logger = require('mongodb').Logger , assert = require('assert'); // Connection URL var url = 'mongodb://localhost:27017/myproject'; // Use connect method to connect to the Server MongoClient.</description>
    </item>

    <item>
      <title>Issues & Help</title>
      <link>/node-mongodb-native/2.2/issues-help/</link>
      <pubDate>Wed, 18 Mar 2015 16:56:14 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/issues-help/</guid>
      <description>Issues &amp; Help Our developer community is vibrant and highly engaged, with wide experience using Node.js with MongoDB. Often, the quickest way to get support for general questions is through the mongodb-user google group or through stackoverflow.
Refer to our support channels documentation for more information.
Bugs / Feature Requests To report a bug or to request a new feature in the Node.js driver, please open a case in our issue management tool, JIRA:</description>
    </item>

    <item>
      <title>Create Indexes</title>
      <link>/node-mongodb-native/2.2/tutorials/create-indexes/</link>
      <pubDate>Tue, 17 Mar 2015 15:36:56 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/create-indexes/</guid>
      <description>Create Indexes To create an index on a field or fields, pass an index specification document to the createIndex() method:
{ &lt;field1&gt;: &lt;type1&gt;, &lt;field2&gt;: &lt;type2&gt; ... }  Create an Ascending Index For an ascending index type, specify 1 for &lt;type&gt;.
The following example creates an ascending index key for the dateOfBirth field:
var createAscendingIndex = function(db, callback) { // Get the users collection var collection = db.collection('users'); // Create the index collection.</description>
    </item>

    <item>
      <title>Installation Guide</title>
      <link>/node-mongodb-native/2.2/installation-guide/installation-guide/</link>
      <pubDate>Tue, 17 Mar 2015 15:36:56 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/installation-guide/installation-guide/</guid>
      <description>Installation The recommended way to get started using the Node.js 2.0 driver is by using NPM (Node Package Manager) to install the dependency in your project.
MongoDB Driver After you&rsquo;ve created your project with npm init, you can install the MongoDB driver and its dependencies with the command:
npm install mongodb --save  This will download the MongoDB driver and add a dependency entry in your package.json file.
Troubleshooting The MongoDB driver depends on several other packages, including:</description>
    </item>

    <item>
      <title>Quick Start</title>
      <link>/node-mongodb-native/2.2/quick-start/quick-start/</link>
      <pubDate>Tue, 17 Mar 2015 15:36:56 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/quick-start/quick-start/</guid>
      <description>Quick Start This guide will show you how to set up a simple application using Node.js and MongoDB. Its scope is only how to set up the driver and perform the simple CRUD operations. For more in-depth coverage, see the tutorials.
Create the package.json file First, create a directory where your application will live.
mkdir myproject cd myproject  Enter the following command and answer the questions to create the initial structure for your new project:</description>
    </item>

    <item>
      <title>Reference</title>
      <link>/node-mongodb-native/2.2/reference/main/</link>
      <pubDate>Tue, 17 Mar 2015 15:36:56 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/reference/main/</guid>
      <description> Reference The reference documentation for the Node.js driver driver focuses on high-level documentation and use-cases.
 Connect to MongoDB: Documentation of the driver&rsquo;s support for connecting to MongoDB servers ECMAScript 6: Using the driver with Javascript 6. Management: Documentation of the driver&rsquo;s support for logging and monitoring of its internal state  </description>
    </item>

    <item>
      <title>Tutorials</title>
      <link>/node-mongodb-native/2.2/tutorials/main/</link>
      <pubDate>Tue, 17 Mar 2015 15:36:56 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/tutorials/main/</guid>
      <description>Tutorials The tutorials in this section provide examples of some frequently used operations. This section is not meant to be an exhaustive list of all operations available in the Node.js driver.
Connect to MongoDB
Collections
Create Indexes
CRUD Operations
Collations
Projections
Aggregation
Text Search
Geospatial Search
Database Commands
GridFS</description>
    </item>

    <item>
      <title>index</title>
      <link>/node-mongodb-native/2.2/</link>
      <pubDate>Tue, 17 Mar 2015 15:36:56 +0000</pubDate>

      <guid>/node-mongodb-native/2.2/</guid>
      <description>MongoDB Node.js Driver Documentation Welcome to the MongoDB Node.js 2.x driver documentation.
What&rsquo;s New The What&rsquo;s New guide explains the major new features of the driver.
If you are upgrading from the 1.x series of the driver, consult the Upgrading documentation for information on recent changes.
Starting points  Installing the driver Quick start CRUD operations Connect  Developing with ECMAScript 6 If you&rsquo;d like to use the MongoDB driver with ES6 features such as Promises and Generators, here are some good starting points.</description>
    </item>

  </channel>
</rss>


text:
using System;
using System.Collections.Generic;
using System.Reflection;
using Newtonsoft.Json.Linq;
using Veil;
using Veil.Helper;

namespace TerrificNet.ViewEngine.TemplateHandler
{
	internal class PlaceholderHelperHandler : IHelperHandler
	{
		private readonly ITerrificTemplateHandler _handler;

		public PlaceholderHelperHandler(ITerrificTemplateHandler handler)
		{
			_handler = handler;
		}

		public bool IsSupported(string name)
		{
			return name.StartsWith("placeholder", StringComparison.OrdinalIgnoreCase);
		}

		public void Evaluate(object model, RenderingContext context, IDictionary<string, string> parameters)
		{
			var key = parameters["key"].Trim('"');
			var index = TryGetIndex(parameters, model);
			_handler.RenderPlaceholder(model, key, index, context);
		}

		private static string TryGetIndex(IDictionary<string, string> parameters, object model)
		{
			string indexProperty;
			if (!parameters.TryGetValue("index", out indexProperty))
				return null;

			indexProperty = indexProperty.Trim('"');

			string index = null;
			string indexLocal;
			if (TryGetPropValue(model, indexProperty, out indexLocal))
				index = indexLocal;

			return index;
		}

		private static bool TryGetPropValue<TValue>(object src, string propertyName, out TValue value)
		{
			value = default(TValue);

			//JObject
			var jObject = src as JObject;
			JToken jValue;
			if (jObject != null && jObject.TryGetValue(propertyName, StringComparison.InvariantCultureIgnoreCase, out jValue))
			{
				value = jValue.Value<TValue>();
				return true;
			}

			//Dictionary
			var dictionaryObject = src as IDictionary<string, object>;
			object dictionaryValue;
			if (dictionaryObject != null && dictionaryObject.TryGetValue(propertyName, out dictionaryValue) && dictionaryValue is TValue)
			{
				value = (TValue)dictionaryValue;
				return true;
			}

			var property = src.GetType().GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
			if (property != null)
			{
				value = (TValue)property.GetValue(src, null);

				return true;
			}

			return false;
		}
	}
}

redpajama_set_name: RedPajamaGithub


text:
package org.springframework.shell.core;

import java.util.ArrayList;
import java.util.List;

import jline.console.completer.Completer;

import org.springframework.util.Assert;

/**
 * An implementation of JLine's {@link Completer} interface that delegates to a {@link Parser}.
 *
 * @author Ben Alex
 * @since 1.0
 */
public class ParserCompleter implements Completer {

	// Fields
	private final Parser parser;

	public ParserCompleter(final Parser parser) {
		Assert.notNull(parser, "Parser required");
		this.parser = parser;
	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public int complete(final String buffer, final int cursor, final List candidates) {
		int result;
		try {
			JLineLogHandler.cancelRedrawProhibition();
			List<Completion> completions = new ArrayList<Completion>();
			result = parser.completeAdvanced(buffer, cursor, completions);
			for (Completion completion : completions) {
				candidates.add(completion.getValue());
			}
		}
		finally {
			JLineLogHandler.prohibitRedraw();
		}
		return result;
	}
}


text:
package google_storagetransfer_v1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "go.pedge.io/pb/gogo/google/api"
import google_protobuf3 "github.com/gogo/protobuf/types"
import google_protobuf4 "github.com/gogo/protobuf/types"
import google_rpc "go.pedge.io/pb/gogo/google/rpc"
import google_type "go.pedge.io/pb/gogo/google/type"
import google_type1 "go.pedge.io/pb/gogo/google/type"

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

// The status of the transfer job.
type TransferJob_Status int32

const (
	// Zero is an illegal value.
	TransferJob_STATUS_UNSPECIFIED TransferJob_Status = 0
	// New transfers will be performed based on the schedule.
	TransferJob_ENABLED TransferJob_Status = 1
	// New transfers will not be scheduled.
	TransferJob_DISABLED TransferJob_Status = 2
	// This is a soft delete state. After a transfer job is set to this
	// state, the job and all the transfer executions are subject to
	// garbage collection.
	TransferJob_DELETED TransferJob_Status = 3
)

var TransferJob_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "ENABLED",
	2: "DISABLED",
	3: "DELETED",
}
var TransferJob_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"ENABLED":            1,
	"DISABLED":           2,
	"DELETED":            3,
}

func (x TransferJob_Status) String() string {
	return proto.EnumName(TransferJob_Status_name, int32(x))
}
func (TransferJob_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorTransferTypes, []int{9, 0}
}

// The status of a TransferOperation.
type TransferOperation_Status int32

const (
	// Zero is an illegal value.
	TransferOperation_STATUS_UNSPECIFIED TransferOperation_Status = 0
	// In progress.
	TransferOperation_IN_PROGRESS TransferOperation_Status = 1
	// Paused.
	TransferOperation_PAUSED TransferOperation_Status = 2
	// Completed successfully.
	TransferOperation_SUCCESS TransferOperation_Status = 3
	// Terminated due to an unrecoverable failure.
	TransferOperation_FAILED TransferOperation_Status = 4
	// Aborted by the user.
	TransferOperation_ABORTED TransferOperation_Status = 5
)

var TransferOperation_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "IN_PROGRESS",
	2: "PAUSED",
	3: "SUCCESS",
	4: "FAILED",
	5: "ABORTED",
}
var TransferOperation_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"IN_PROGRESS":        1,
	"PAUSED":             2,
	"SUCCESS":            3,
	"FAILED":             4,
	"ABORTED":            5,
}

func (x TransferOperation_Status) String() string {
	return proto.EnumName(TransferOperation_Status_name, int32(x))
}
func (TransferOperation_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorTransferTypes, []int{13, 0}
}

// Google service account
type GoogleServiceAccount struct {
	// Required.
	AccountEmail string `protobuf:"bytes,1,opt,name=account_email,json=accountEmail,proto3" json:"account_email,omitempty"`
}

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

func (m *GoogleServiceAccount) GetAccountEmail() string {
	if m != nil {
		return m.AccountEmail
	}
	return ""
}

// AWS access key (see
// [AWS Security Credentials](http://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)).
type AwsAccessKey struct {
	// AWS access key ID.
	// Required.
	AccessKeyId string `protobuf:"bytes,1,opt,name=access_key_id,json=accessKeyId,proto3" json:"access_key_id,omitempty"`
	// AWS secret access key. This field is not returned in RPC responses.
	// Required.
	SecretAccessKey string `protobuf:"bytes,2,opt,name=secret_access_key,json=secretAccessKey,proto3" json:"secret_access_key,omitempty"`
}

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

func (m *AwsAccessKey) GetAccessKeyId() string {
	if m != nil {
		return m.AccessKeyId
	}
	return ""
}

func (m *AwsAccessKey) GetSecretAccessKey() string {
	if m != nil {
		return m.SecretAccessKey
	}
	return ""
}

// Conditions that determine which objects will be transferred.
type ObjectConditions struct {
	// If unspecified, `minTimeElapsedSinceLastModification` takes a zero value
	// and `maxTimeElapsedSinceLastModification` takes the maximum possible
	// value of Duration. Objects that satisfy the object conditions
	// must either have a `lastModificationTime` greater or equal to
	// `NOW` - `maxTimeElapsedSinceLastModification` and less than
	// `NOW` - `minTimeElapsedSinceLastModification`, or not have a
	// `lastModificationTime`.
	MinTimeElapsedSinceLastModification *google_protobuf3.Duration `protobuf:"bytes,1,opt,name=min_time_elapsed_since_last_modification,json=minTimeElapsedSinceLastModification" json:"min_time_elapsed_since_last_modification,omitempty"`
	// `maxTimeElapsedSinceLastModification` is the complement to
	// `minTimeElapsedSinceLastModification`.
	MaxTimeElapsedSinceLastModification *google_protobuf3.Duration `protobuf:"bytes,2,opt,name=max_time_elapsed_since_last_modification,json=maxTimeElapsedSinceLastModification" json:"max_time_elapsed_since_last_modification,omitempty"`
	// If `includePrefixes` is specified, objects that satisfy the object
	// conditions must have names that start with one of the `includePrefixes`
	// and that do not start with any of the `excludePrefixes`. If `includePrefixes`
	// is not specified, all objects except those that have names starting with
	// one of the `excludePrefixes` must satisfy the object conditions.
	//
	// Requirements:
	//
	//   * Each include-prefix and exclude-prefix can contain any sequence of
	//     Unicode characters, of max length 1024 bytes when UTF8-encoded, and
	//     must not contain Carriage Return or Line Feed characters.  Wildcard
	//     matching and regular expression matching are not supported.
	//
	//   * Each include-prefix and exclude-prefix must omit the leading slash.
	//     For example, to include the `requests.gz` object in a transfer from
	//     `s3://my-aws-bucket/logs/y=2015/requests.gz`, specify the include
	//     prefix as `logs/y=2015/requests.gz`.
	//
	//   * None of the include-prefix or the exclude-prefix values can be empty,
	//     if specified.
	//
	//   * Each include-prefix must include a distinct portion of the object
	//     namespace, i.e., no include-prefix may be a prefix of another
	//     include-prefix.
	//
	//   * Each exclude-prefix must exclude a distinct portion of the object
	//     namespace, i.e., no exclude-prefix may be a prefix of another
	//     exclude-prefix.
	//
	//   * If `includePrefixes` is specified, then each exclude-prefix must start
	//     with the value of a path explicitly included by `includePrefixes`.
	//
	// The max size of `includePrefixes` is 1000.
	IncludePrefixes []string `protobuf:"bytes,3,rep,name=include_prefixes,json=includePrefixes" json:"include_prefixes,omitempty"`
	// `excludePrefixes` must follow the requirements described for
	// `includePrefixes`.
	//
	// The max size of `excludePrefixes` is 1000.
	ExcludePrefixes []string `protobuf:"bytes,4,rep,name=exclude_prefixes,json=excludePrefixes" json:"exclude_prefixes,omitempty"`
}

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

func (m *ObjectConditions) GetMinTimeElapsedSinceLastModification() *google_protobuf3.Duration {
	if m != nil {
		return m.MinTimeElapsedSinceLastModification
	}
	return nil
}

func (m *ObjectConditions) GetMaxTimeElapsedSinceLastModification() *google_protobuf3.Duration {
	if m != nil {
		return m.MaxTimeElapsedSinceLastModification
	}
	return nil
}

func (m *ObjectConditions) GetIncludePrefixes() []string {
	if m != nil {
		return m.IncludePrefixes
	}
	return nil
}

func (m *ObjectConditions) GetExcludePrefixes() []string {
	if m != nil {
		return m.ExcludePrefixes
	}
	return nil
}

// In a GcsData, an object's name is the Google Cloud Storage object's name and
// its `lastModificationTime` refers to the object's updated time, which changes
// when the content or the metadata of the object is updated.
type GcsData struct {
	// Google Cloud Storage bucket name (see
	// [Bucket Name Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
	// Required.
	BucketName string `protobuf:"bytes,1,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"`
}

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

func (m *GcsData) GetBucketName() string {
	if m != nil {
		return m.BucketName
	}
	return ""
}

// An AwsS3Data can be a data source, but not a data sink.
// In an AwsS3Data, an object's name is the S3 object's key name.
type AwsS3Data struct {
	// S3 Bucket name (see
	// [Creating a bucket](http://docs.aws.amazon.com/AmazonS3/latest/dev/create-bucket-get-location-example.html)).
	// Required.
	BucketName string `protobuf:"bytes,1,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"`
	// AWS access key used to sign the API requests to the AWS S3 bucket.
	// Permissions on the bucket must be granted to the access ID of the
	// AWS access key.
	// Required.
	AwsAccessKey *AwsAccessKey `protobuf:"bytes,2,opt,name=aws_access_key,json=awsAccessKey" json:"aws_access_key,omitempty"`
}

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

func (m *AwsS3Data) GetBucketName() string {
	if m != nil {
		return m.BucketName
	}
	return ""
}

func (m *AwsS3Data) GetAwsAccessKey() *AwsAccessKey {
	if m != nil {
		return m.AwsAccessKey
	}
	return nil
}

// An HttpData specifies a list of objects on the web to be transferred over
// HTTP.  The information of the objects to be transferred is contained in a
// file referenced by a URL. The first line in the file must be
// "TsvHttpData-1.0", which specifies the format of the file.  Subsequent lines
// specify the information of the list of objects, one object per list entry.
// Each entry has the following tab-delimited fields:
//
// * HTTP URL - The location of the object.
//
// * Length - The size of the object in bytes.
//
// * MD5 - The base64-encoded MD5 hash of the object.
//
// For an example of a valid TSV file, see
// [Transferring data from URLs](https://cloud.google.com/storage/transfer/create-url-list).
//
// When transferring data based on a URL list, keep the following in mind:
//
// * When an object located at `http(s)://hostname:port/<URL-path>` is transferred
// to a data sink, the name of the object at the data sink is
// `<hostname>/<URL-path>`.
//
// * If the specified size of an object does not match the actual size of the
// object fetched, the object will not be transferred.
//
// * If the specified MD5 does not match the MD5 computed from the transferred
// bytes, the object transfer will fail. For more information, see
// [Generating MD5 hashes](https://cloud.google.com/storage/transfer/#md5)
//
// * Ensure that each URL you specify is publicly accessible. For
// example, in Google Cloud Storage you can
// [share an object publicly]
// (https://cloud.google.com/storage/docs/cloud-console#_sharingdata) and get
// a link to it.
//
// * Storage Transfer Service obeys `robots.txt` rules and requires the source
// HTTP server to support `Range` requests and to return a `Content-Length`
// header in each response.
//
// * [ObjectConditions](#ObjectConditions) have no effect when filtering objects
// to transfer.
type HttpData struct {
	// The URL that points to the file that stores the object list entries.
	// This file must allow public access.  Currently, only URLs with HTTP and
	// HTTPS schemes are supported.
	// Required.
	ListUrl string `protobuf:"bytes,1,opt,name=list_url,json=listUrl,proto3" json:"list_url,omitempty"`
}

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

func (m *HttpData) GetListUrl() string {
	if m != nil {
		return m.ListUrl
	}
	return ""
}

// TransferOptions uses three boolean parameters to define the actions
// to be performed on objects in a transfer.
type TransferOptions struct {
	// Whether overwriting objects that already exist in the sink is allowed.
	OverwriteObjectsAlreadyExistingInSink bool `protobuf:"varint,1,opt,name=overwrite_objects_already_existing_in_sink,json=overwriteObjectsAlreadyExistingInSink,proto3" json:"overwrite_objects_already_existing_in_sink,omitempty"`
	// Whether objects that exist only in the sink should be deleted.  Note that
	// this option and `deleteObjectsFromSourceAfterTransfer` are mutually
	// exclusive.
	DeleteObjectsUniqueInSink bool `protobuf:"varint,2,opt,name=delete_objects_unique_in_sink,json=deleteObjectsUniqueInSink,proto3" json:"delete_objects_unique_in_sink,omitempty"`
	// Whether objects should be deleted from the source after they are
	// transferred to the sink.  Note that this option and
	// `deleteObjectsUniqueInSink` are mutually exclusive.
	DeleteObjectsFromSourceAfterTransfer bool `protobuf:"varint,3,opt,name=delete_objects_from_source_after_transfer,json=deleteObjectsFromSourceAfterTransfer,proto3" json:"delete_objects_from_source_after_transfer,omitempty"`
}

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

func (m *TransferOptions) GetOverwriteObjectsAlreadyExistingInSink() bool {
	if m != nil {
		return m.OverwriteObjectsAlreadyExistingInSink
	}
	return false
}

func (m *TransferOptions) GetDeleteObjectsUniqueInSink() bool {
	if m != nil {
		return m.DeleteObjectsUniqueInSink
	}
	return false
}

func (m *TransferOptions) GetDeleteObjectsFromSourceAfterTransfer() bool {
	if m != nil {
		return m.DeleteObjectsFromSourceAfterTransfer
	}
	return false
}

// Configuration for running a transfer.
type TransferSpec struct {
	// The read source of the data.
	//
	// Types that are valid to be assigned to DataSource:
	//	*TransferSpec_GcsDataSource
	//	*TransferSpec_AwsS3DataSource
	//	*TransferSpec_HttpDataSource
	DataSource isTransferSpec_DataSource `protobuf_oneof:"data_source"`
	// The write sink for the data.
	//
	// Types that are valid to be assigned to DataSink:
	//	*TransferSpec_GcsDataSink
	DataSink isTransferSpec_DataSink `protobuf_oneof:"data_sink"`
	// Only objects that satisfy these object conditions are included in the set
	// of data source and data sink objects.  Object conditions based on
	// objects' `lastModificationTime` do not exclude objects in a data sink.
	ObjectConditions *ObjectConditions `protobuf:"bytes,5,opt,name=object_conditions,json=objectConditions" json:"object_conditions,omitempty"`
	// If the option `deleteObjectsUniqueInSink` is `true`, object conditions
	// based on objects' `lastModificationTime` are ignored and do not exclude
	// objects in a data source or a data sink.
	TransferOptions *TransferOptions `protobuf:"bytes,6,opt,name=transfer_options,json=transferOptions" json:"transfer_options,omitempty"`
}

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

type isTransferSpec_DataSource interface {
	isTransferSpec_DataSource()
}
type isTransferSpec_DataSink interface {
	isTransferSpec_DataSink()
}

type TransferSpec_GcsDataSource struct {
	GcsDataSource *GcsData `protobuf:"bytes,1,opt,name=gcs_data_source,json=gcsDataSource,oneof"`
}
type TransferSpec_AwsS3DataSource struct {
	AwsS3DataSource *AwsS3Data `protobuf:"bytes,2,opt,name=aws_s3_data_source,json=awsS3DataSource,oneof"`
}
type TransferSpec_HttpDataSource struct {
	HttpDataSource *HttpData `protobuf:"bytes,3,opt,name=http_data_source,json=httpDataSource,oneof"`
}
type TransferSpec_GcsDataSink struct {
	GcsDataSink *GcsData `protobuf:"bytes,4,opt,name=gcs_data_sink,json=gcsDataSink,oneof"`
}

func (*TransferSpec_GcsDataSource) isTransferSpec_DataSource()   {}
func (*TransferSpec_AwsS3DataSource) isTransferSpec_DataSource() {}
func (*TransferSpec_HttpDataSource) isTransferSpec_DataSource()  {}
func (*TransferSpec_GcsDataSink) isTransferSpec_DataSink()       {}

func (m *TransferSpec) GetDataSource() isTransferSpec_DataSource {
	if m != nil {
		return m.DataSource
	}
	return nil
}
func (m *TransferSpec) GetDataSink() isTransferSpec_DataSink {
	if m != nil {
		return m.DataSink
	}
	return nil
}

func (m *TransferSpec) GetGcsDataSource() *GcsData {
	if x, ok := m.GetDataSource().(*TransferSpec_GcsDataSource); ok {
		return x.GcsDataSource
	}
	return nil
}

func (m *TransferSpec) GetAwsS3DataSource() *AwsS3Data {
	if x, ok := m.GetDataSource().(*TransferSpec_AwsS3DataSource); ok {
		return x.AwsS3DataSource
	}
	return nil
}

func (m *TransferSpec) GetHttpDataSource() *HttpData {
	if x, ok := m.GetDataSource().(*TransferSpec_HttpDataSource); ok {
		return x.HttpDataSource
	}
	return nil
}

func (m *TransferSpec) GetGcsDataSink() *GcsData {
	if x, ok := m.GetDataSink().(*TransferSpec_GcsDataSink); ok {
		return x.GcsDataSink
	}
	return nil
}

func (m *TransferSpec) GetObjectConditions() *ObjectConditions {
	if m != nil {
		return m.ObjectConditions
	}
	return nil
}

func (m *TransferSpec) GetTransferOptions() *TransferOptions {
	if m != nil {
		return m.TransferOptions
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*TransferSpec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TransferSpec_OneofMarshaler, _TransferSpec_OneofUnmarshaler, _TransferSpec_OneofSizer, []interface{}{
		(*TransferSpec_GcsDataSource)(nil),
		(*TransferSpec_AwsS3DataSource)(nil),
		(*TransferSpec_HttpDataSource)(nil),
		(*TransferSpec_GcsDataSink)(nil),
	}
}

func _TransferSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TransferSpec)
	// data_source
	switch x := m.DataSource.(type) {
	case *TransferSpec_GcsDataSource:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GcsDataSource); err != nil {
			return err
		}
	case *TransferSpec_AwsS3DataSource:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AwsS3DataSource); err != nil {
			return err
		}
	case *TransferSpec_HttpDataSource:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.HttpDataSource); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TransferSpec.DataSource has unexpected type %T", x)
	}
	// data_sink
	switch x := m.DataSink.(type) {
	case *TransferSpec_GcsDataSink:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GcsDataSink); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TransferSpec.DataSink has unexpected type %T", x)
	}
	return nil
}

func _TransferSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TransferSpec)
	switch tag {
	case 1: // data_source.gcs_data_source
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GcsData)
		err := b.DecodeMessage(msg)
		m.DataSource = &TransferSpec_GcsDataSource{msg}
		return true, err
	case 2: // data_source.aws_s3_data_source
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(AwsS3Data)
		err := b.DecodeMessage(msg)
		m.DataSource = &TransferSpec_AwsS3DataSource{msg}
		return true, err
	case 3: // data_source.http_data_source
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(HttpData)
		err := b.DecodeMessage(msg)
		m.DataSource = &TransferSpec_HttpDataSource{msg}
		return true, err
	case 4: // data_sink.gcs_data_sink
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GcsData)
		err := b.DecodeMessage(msg)
		m.DataSink = &TransferSpec_GcsDataSink{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TransferSpec_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TransferSpec)
	// data_source
	switch x := m.DataSource.(type) {
	case *TransferSpec_GcsDataSource:
		s := proto.Size(x.GcsDataSource)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TransferSpec_AwsS3DataSource:
		s := proto.Size(x.AwsS3DataSource)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TransferSpec_HttpDataSource:
		s := proto.Size(x.HttpDataSource)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	// data_sink
	switch x := m.DataSink.(type) {
	case *TransferSpec_GcsDataSink:
		s := proto.Size(x.GcsDataSink)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Transfers can be scheduled to recur or to run just once.
type Schedule struct {
	// The first day the recurring transfer is scheduled to run. If
	// `scheduleStartDate` is in the past, the transfer will run for the first
	// time on the following day.
	// Required.
	ScheduleStartDate *google_type.Date `protobuf:"bytes,1,opt,name=schedule_start_date,json=scheduleStartDate" json:"schedule_start_date,omitempty"`
	// The last day the recurring transfer will be run. If `scheduleEndDate`
	// is the same as `scheduleStartDate`, the transfer will be executed only
	// once.
	ScheduleEndDate *google_type.Date `protobuf:"bytes,2,opt,name=schedule_end_date,json=scheduleEndDate" json:"schedule_end_date,omitempty"`
	// The time in UTC at which the transfer will be scheduled to start in a day.
	// Transfers may start later than this time. If not specified, recurring and
	// one-time transfers that are scheduled to run today will run immediately;
	// recurring transfers that are scheduled to run on a future date will start
	// at approximately midnight UTC on that date. Note that when configuring a
	// transfer with the Cloud Platform Console, the transfer's start time in a
	// day is specified in your local timezone.
	StartTimeOfDay *google_type1.TimeOfDay `protobuf:"bytes,3,opt,name=start_time_of_day,json=startTimeOfDay" json:"start_time_of_day,omitempty"`
}

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

func (m *Schedule) GetScheduleStartDate() *google_type.Date {
	if m != nil {
		return m.ScheduleStartDate
	}
	return nil
}

func (m *Schedule) GetScheduleEndDate() *google_type.Date {
	if m != nil {
		return m.ScheduleEndDate
	}
	return nil
}

func (m *Schedule) GetStartTimeOfDay() *google_type1.TimeOfDay {
	if m != nil {
		return m.StartTimeOfDay
	}
	return nil
}

// This resource represents the configuration of a transfer job that runs
// periodically.
type TransferJob struct {
	// A globally unique name assigned by Storage Transfer Service when the
	// job is created. This field should be left empty in requests to create a new
	// transfer job; otherwise, the requests result in an `INVALID_ARGUMENT`
	// error.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A description provided by the user for the job. Its max length is 1024
	// bytes when Unicode-encoded.
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// The ID of the Google Cloud Platform Console project that owns the job.
	ProjectId string `protobuf:"bytes,3,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// Transfer specification.
	TransferSpec *TransferSpec `protobuf:"bytes,4,opt,name=transfer_spec,json=transferSpec" json:"transfer_spec,omitempty"`
	// Schedule specification.
	Schedule *Schedule `protobuf:"bytes,5,opt,name=schedule" json:"schedule,omitempty"`
	// Status of the job. This value MUST be specified for
	// `CreateTransferJobRequests`.
	//
	// NOTE: The effect of the new job status takes place during a subsequent job
	// run. For example, if you change the job status from `ENABLED` to
	// `DISABLED`, and an operation spawned by the transfer is running, the status
	// change would not affect the current operation.
	Status TransferJob_Status `protobuf:"varint,6,opt,name=status,proto3,enum=google.storagetransfer.v1.TransferJob_Status" json:"status,omitempty"`
	// This field cannot be changed by user requests.
	CreationTime *google_protobuf4.Timestamp `protobuf:"bytes,7,opt,name=creation_time,json=creationTime" json:"creation_time,omitempty"`
	// This field cannot be changed by user requests.
	LastModificationTime *google_protobuf4.Timestamp `protobuf:"bytes,8,opt,name=last_modification_time,json=lastModificationTime" json:"last_modification_time,omitempty"`
	// This field cannot be changed by user requests.
	DeletionTime *google_protobuf4.Timestamp `protobuf:"bytes,9,opt,name=deletion_time,json=deletionTime" json:"deletion_time,omitempty"`
}

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

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

func (m *TransferJob) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *TransferJob) GetProjectId() string {
	if m != nil {
		return m.ProjectId
	}
	return ""
}

func (m *TransferJob) GetTransferSpec() *TransferSpec {
	if m != nil {
		return m.TransferSpec
	}
	return nil
}

func (m *TransferJob) GetSchedule() *Schedule {
	if m != nil {
		return m.Schedule
	}
	return nil
}

func (m *TransferJob) GetStatus() TransferJob_Status {
	if m != nil {
		return m.Status
	}
	return TransferJob_STATUS_UNSPECIFIED
}

func (m *TransferJob) GetCreationTime() *google_protobuf4.Timestamp {
	if m != nil {
		return m.CreationTime
	}
	return nil
}

func (m *TransferJob) GetLastModificationTime() *google_protobuf4.Timestamp {
	if m != nil {
		return m.LastModificationTime
	}
	return nil
}

func (m *TransferJob) GetDeletionTime() *google_protobuf4.Timestamp {
	if m != nil {
		return m.DeletionTime
	}
	return nil
}

// An entry describing an error that has occurred.
type ErrorLogEntry struct {
	// A URL that refers to the target (a data source, a data sink,
	// or an object) with which the error is associated.
	// Required.
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// A list of messages that carry the error details.
	ErrorDetails []string `protobuf:"bytes,3,rep,name=error_details,json=errorDetails" json:"error_details,omitempty"`
}

func (m *ErrorLogEntry) Reset()                    { *m = ErrorLogEntry{} }
func (m *ErrorLogEntry) String() string            { return proto.CompactTextString(m) }
func (*ErrorLogEntry) ProtoMessage()               {}
func (*ErrorLogEntry) Descriptor() ([]byte, []int) { return fileDescriptorTransferTypes, []int{10} }

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

func (m *ErrorLogEntry) GetErrorDetails() []string {
	if m != nil {
		return m.ErrorDetails
	}
	return nil
}

// A summary of errors by error code, plus a count and sample error log
// entries.
type ErrorSummary struct {
	// Required.
	ErrorCode google_rpc.Code `protobuf:"varint,1,opt,name=error_code,json=errorCode,proto3,enum=google.rpc.Code" json:"error_code,omitempty"`
	// Count of this type of error.
	// Required.
	ErrorCount int64 `protobuf:"varint,2,opt,name=error_count,json=errorCount,proto3" json:"error_count,omitempty"`
	// Error samples.
	ErrorLogEntries []*ErrorLogEntry `protobuf:"bytes,3,rep,name=error_log_entries,json=errorLogEntries" json:"error_log_entries,omitempty"`
}

func (m *ErrorSummary) Reset()                    { *m = ErrorSummary{} }
func (m *ErrorSummary) String() string            { return proto.CompactTextString(m) }
func (*ErrorSummary) ProtoMessage()               {}
func (*ErrorSummary) Descriptor() ([]byte, []int) { return fileDescriptorTransferTypes, []int{11} }

func (m *ErrorSummary) GetErrorCode() google_rpc.Code {
	if m != nil {
		return m.ErrorCode
	}
	return google_rpc.Code_OK
}

func (m *ErrorSummary) GetErrorCount() int64 {
	if m != nil {
		return m.ErrorCount
	}
	return 0
}

func (m *ErrorSummary) GetErrorLogEntries() []*ErrorLogEntry {
	if m != nil {
		return m.ErrorLogEntries
	}
	return nil
}

// A collection of counters that report the progress of a transfer operation.
type TransferCounters struct {
	// Objects found in the data source that are scheduled to be transferred,
	// excluding any that are filtered based on object conditions or skipped due
	// to sync.
	ObjectsFoundFromSource int64 `protobuf:"varint,1,opt,name=objects_found_from_source,json=objectsFoundFromSource,proto3" json:"objects_found_from_source,omitempty"`
	// Bytes found in the data source that are scheduled to be transferred,
	// excluding any that are filtered based on object conditions or skipped due
	// to sync.
	BytesFoundFromSource int64 `protobuf:"varint,2,opt,name=bytes_found_from_source,json=bytesFoundFromSource,proto3" json:"bytes_found_from_source,omitempty"`
	// Objects found only in the data sink that are scheduled to be deleted.
	ObjectsFoundOnlyFromSink int64 `protobuf:"varint,3,opt,name=objects_found_only_from_sink,json=objectsFoundOnlyFromSink,proto3" json:"objects_found_only_from_sink,omitempty"`
	// Bytes found only in the data sink that are scheduled to be deleted.
	BytesFoundOnlyFromSink int64 `protobuf:"varint,4,opt,name=bytes_found_only_from_sink,json=bytesFoundOnlyFromSink,proto3" json:"bytes_found_only_from_sink,omitempty"`
	// Objects in the data source that are not transferred because they already
	// exist in the data sink.
	ObjectsFromSourceSkippedBySync int64 `protobuf:"varint,5,opt,name=objects_from_source_skipped_by_sync,json=objectsFromSourceSkippedBySync,proto3" json:"objects_from_source_skipped_by_sync,omitempty"`
	// Bytes in the data source that are not transferred because they already
	// exist in the data sink.
	BytesFromSourceSkippedBySync int64 `protobuf:"varint,6,opt,name=bytes_from_source_skipped_by_sync,json=bytesFromSourceSkippedBySync,proto3" json:"bytes_from_source_skipped_by_sync,omitempty"`
	// Objects that are copied to the data sink.
	ObjectsCopiedToSink int64 `protobuf:"varint,7,opt,name=objects_copied_to_sink,json=objectsCopiedToSink,proto3" json:"objects_copied_to_sink,omitempty"`
	// Bytes that are copied to the data sink.
	BytesCopiedToSink int64 `protobuf:"varint,8,opt,name=bytes_copied_to_sink,json=bytesCopiedToSink,proto3" json:"bytes_copied_to_sink,omitempty"`
	// Objects that are deleted from the data source.
	ObjectsDeletedFromSource int64 `protobuf:"varint,9,opt,name=objects_deleted_from_source,json=objectsDeletedFromSource,proto3" json:"objects_deleted_from_source,omitempty"`
	// Bytes that are deleted from the data source.
	BytesDeletedFromSource int64 `protobuf:"varint,10,opt,name=bytes_deleted_from_source,json=bytesDeletedFromSource,proto3" json:"bytes_deleted_from_source,omitempty"`
	// Objects that are deleted from the data sink.
	ObjectsDeletedFromSink int64 `protobuf:"varint,11,opt,name=objects_deleted_from_sink,json=objectsDeletedFromSink,proto3" json:"objects_deleted_from_sink,omitempty"`
	// Bytes that are deleted from the data sink.
	BytesDeletedFromSink int64 `protobuf:"varint,12,opt,name=bytes_deleted_from_sink,json=bytesDeletedFromSink,proto3" json:"bytes_deleted_from_sink,omitempty"`
	// Objects in the data source that failed during the transfer.
	ObjectsFromSourceFailed int64 `protobuf:"varint,13,opt,name=objects_from_source_failed,json=objectsFromSourceFailed,proto3" json:"objects_from_source_failed,omitempty"`
	// Bytes in the data source that failed during the transfer.
	BytesFromSourceFailed int64 `protobuf:"varint,14,opt,name=bytes_from_source_failed,json=bytesFromSourceFailed,proto3" json:"bytes_from_source_failed,omitempty"`
	// Objects that failed to be deleted from the data sink.
	ObjectsFailedToDeleteFromSink int64 `protobuf:"varint,15,opt,name=objects_failed_to_delete_from_sink,json=objectsFailedToDeleteFromSink,proto3" json:"objects_failed_to_delete_from_sink,omitempty"`
	// Bytes that failed to be deleted from the data sink.
	BytesFailedToDeleteFromSink int64 `protobuf:"varint,16,opt,name=bytes_failed_to_delete_from_sink,json=bytesFailedToDeleteFromSink,proto3" json:"bytes_failed_to_delete_from_sink,omitempty"`
}

func (m *TransferCounters) Reset()                    { *m = TransferCounters{} }
func (m *TransferCounters) String() string            { return proto.CompactTextString(m) }
func (*TransferCounters) ProtoMessage()               {}
func (*TransferCounters) Descriptor() ([]byte, []int) { return fileDescriptorTransferTypes, []int{12} }

func (m *TransferCounters) GetObjectsFoundFromSource() int64 {
	if m != nil {
		return m.ObjectsFoundFromSource
	}
	return 0
}

func (m *TransferCounters) GetBytesFoundFromSource() int64 {
	if m != nil {
		return m.BytesFoundFromSource
	}
	return 0
}

func (m *TransferCounters) GetObjectsFoundOnlyFromSink() int64 {
	if m != nil {
		return m.ObjectsFoundOnlyFromSink
	}
	return 0
}

func (m *TransferCounters) GetBytesFoundOnlyFromSink() int64 {
	if m != nil {
		return m.BytesFoundOnlyFromSink
	}
	return 0
}

func (m *TransferCounters) GetObjectsFromSourceSkippedBySync() int64 {
	if m != nil {
		return m.ObjectsFromSourceSkippedBySync
	}
	return 0
}

func (m *TransferCounters) GetBytesFromSourceSkippedBySync() int64 {
	if m != nil {
		return m.BytesFromSourceSkippedBySync
	}
	return 0
}

func (m *TransferCounters) GetObjectsCopiedToSink() int64 {
	if m != nil {
		return m.ObjectsCopiedToSink
	}
	return 0
}

func (m *TransferCounters) GetBytesCopiedToSink() int64 {
	if m != nil {
		return m.BytesCopiedToSink
	}
	return 0
}

func (m *TransferCounters) GetObjectsDeletedFromSource() int64 {
	if m != nil {
		return m.ObjectsDeletedFromSource
	}
	return 0
}

func (m *TransferCounters) GetBytesDeletedFromSource() int64 {
	if m != nil {
		return m.BytesDeletedFromSource
	}
	return 0
}

func (m *TransferCounters) GetObjectsDeletedFromSink() int64 {
	if m != nil {
		return m.ObjectsDeletedFromSink
	}
	return 0
}

func (m *TransferCounters) GetBytesDeletedFromSink() int64 {
	if m != nil {
		return m.BytesDeletedFromSink
	}
	return 0
}

func (m *TransferCounters) GetObjectsFromSourceFailed() int64 {
	if m != nil {
		return m.ObjectsFromSourceFailed
	}
	return 0
}

func (m *TransferCounters) GetBytesFromSourceFailed() int64 {
	if m != nil {
		return m.BytesFromSourceFailed
	}
	return 0
}

func (m *TransferCounters) GetObjectsFailedToDeleteFromSink() int64 {
	if m != nil {
		return m.ObjectsFailedToDeleteFromSink
	}
	return 0
}

func (m *TransferCounters) GetBytesFailedToDeleteFromSink() int64 {
	if m != nil {
		return m.BytesFailedToDeleteFromSink
	}
	return 0
}

// A description of the execution of a transfer.
type TransferOperation struct {
	// A globally unique ID assigned by the system.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The ID of the Google Cloud Platform Console project that owns the operation.
	// Required.
	ProjectId string `protobuf:"bytes,2,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
	// Transfer specification.
	// Required.
	TransferSpec *TransferSpec `protobuf:"bytes,3,opt,name=transfer_spec,json=transferSpec" json:"transfer_spec,omitempty"`
	// Start time of this transfer execution.
	StartTime *google_protobuf4.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime" json:"start_time,omitempty"`
	// End time of this transfer execution.
	EndTime *google_protobuf4.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime" json:"end_time,omitempty"`
	// Status of the transfer operation.
	Status TransferOperation_Status `protobuf:"varint,6,opt,name=status,proto3,enum=google.storagetransfer.v1.TransferOperation_Status" json:"status,omitempty"`
	// Information about the progress of the transfer operation.
	Counters *TransferCounters `protobuf:"bytes,7,opt,name=counters" json:"counters,omitempty"`
	// Summarizes errors encountered with sample error log entries.
	ErrorBreakdowns []*ErrorSummary `protobuf:"bytes,8,rep,name=error_breakdowns,json=errorBreakdowns" json:"error_breakdowns,omitempty"`
	// The name of the transfer job that triggers this transfer operation.
	TransferJobName string `protobuf:"bytes,9,opt,name=transfer_job_name,json=transferJobName,proto3" json:"transfer_job_name,omitempty"`
}

func (m *TransferOperation) Reset()                    { *m = TransferOperation{} }
func (m *TransferOperation) String() string            { return proto.CompactTextString(m) }
func (*TransferOperation) ProtoMessage()               {}
func (*TransferOperation) Descriptor() ([]byte, []int) { return fileDescriptorTransferTypes, []int{13} }

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

func (m *TransferOperation) GetProjectId() string {
	if m != nil {
		return m.ProjectId
	}
	return ""
}

func (m *TransferOperation) GetTransferSpec() *TransferSpec {
	if m != nil {
		return m.TransferSpec
	}
	return nil
}

func (m *TransferOperation) GetStartTime() *google_protobuf4.Timestamp {
	if m != nil {
		return m.StartTime
	}
	return nil
}

func (m *TransferOperation) GetEndTime() *google_protobuf4.Timestamp {
	if m != nil {
		return m.EndTime
	}
	return nil
}

func (m *TransferOperation) GetStatus() TransferOperation_Status {
	if m != nil {
		return m.Status
	}
	return TransferOperation_STATUS_UNSPECIFIED
}

func (m *TransferOperation) GetCounters() *TransferCounters {
	if m != nil {
		return m.Counters
	}
	return nil
}

func (m *TransferOperation) GetErrorBreakdowns() []*ErrorSummary {
	if m != nil {
		return m.ErrorBreakdowns
	}
	return nil
}

func (m *TransferOperation) GetTransferJobName() string {
	if m != nil {
		return m.TransferJobName
	}
	return ""
}

func init() {
	proto.RegisterType((*GoogleServiceAccount)(nil), "google.storagetransfer.v1.GoogleServiceAccount")
	proto.RegisterType((*AwsAccessKey)(nil), "google.storagetransfer.v1.AwsAccessKey")
	proto.RegisterType((*ObjectConditions)(nil), "google.storagetransfer.v1.ObjectConditions")
	proto.RegisterType((*GcsData)(nil), "google.storagetransfer.v1.GcsData")
	proto.RegisterType((*AwsS3Data)(nil), "google.storagetransfer.v1.AwsS3Data")
	proto.RegisterType((*HttpData)(nil), "google.storagetransfer.v1.HttpData")
	proto.RegisterType((*TransferOptions)(nil), "google.storagetransfer.v1.TransferOptions")
	proto.RegisterType((*TransferSpec)(nil), "google.storagetransfer.v1.TransferSpec")
	proto.RegisterType((*Schedule)(nil), "google.storagetransfer.v1.Schedule")
	proto.RegisterType((*TransferJob)(nil), "google.storagetransfer.v1.TransferJob")
	proto.RegisterType((*ErrorLogEntry)(nil), "google.storagetransfer.v1.ErrorLogEntry")
	proto.RegisterType((*ErrorSummary)(nil), "google.storagetransfer.v1.ErrorSummary")
	proto.RegisterType((*TransferCounters)(nil), "google.storagetransfer.v1.TransferCounters")
	proto.RegisterType((*TransferOperation)(nil), "google.storagetransfer.v1.TransferOperation")
	proto.RegisterEnum("google.storagetransfer.v1.TransferJob_Status", TransferJob_Status_name, TransferJob_Status_value)
	proto.RegisterEnum("google.storagetransfer.v1.TransferOperation_Status", TransferOperation_Status_name, TransferOperation_Status_value)
}

func init() {
	proto.RegisterFile("google/storagetransfer/v1/transfer_types.proto", fileDescriptorTransferTypes)
}

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


text:
about activate

Calling all students! Ignite your future beyond the classroom. Join local professionals from the growing interactive community to learn more about the opportunities of the future at Activate Conference.

From websites to mobile apps, wearables to smart devices, social media to virtual reality and beyond. Activate will inspire you to get next-level with your career. Explore the possibilities of UI/UX design, web development, and the exciting future of an interactive world.

We're looking for self-starters who want to ignite their future beyond the classroom. We'll have speakers and panelists from the growing interactive community in Baton Rouge talking about their careers, answering your questions, and giving you advice on how to get an edge on the future of design and development. Plus, we'll give you the resources you need to prepare for a professional career in the interactive industry. Don't miss this opportunity to get a jump start on your future.

stay updated

				<form action="//activateconf.us12.list-manage.com/subscribe/post?u=1698009cda135b7f9480768e9&id=466d37a6e5" method="post" id="mc-embedded-subscribe-form" name="mc-embedded-subscribe-form" class="validate" target="_blank" novalidate class='form'>

						<input type="email" value="" name="EMAIL" class="email form-control" id="mce-EMAIL" placeholder="your email address" required>

<input type="text" name="b_1698009cda135b7f9480768e9_466d37a6e5" tabindex="-1" value="">

						<button class="btn btn-text-only" type="submit" id="mc-embedded-subscribe" >subscribe</button>

				</form>

date

Thursday, November 3rd, 2016
 6:00 – 9:30 PM

venue

Creative Bloc
 804 Main St.
Baton Rouge, LA 70802

more about venue

					<?php include('partials/fb.html'); ?>

					<?php include('partials/tw.html'); ?>

					<?php include('partials/ig.html'); ?>


text:
<?php

/**
 * IShowFunctionStatusWhereStatement interface file.
 *
 * @author Anastaszor
 */
interface IShowFunctionStatusWhereStatement extends IShowFunctionStatusStatement
{

	/**
	 *
	 * @return IWhereStatement
	 */
	public function getWhereStatement();

}


text:
package com.xtremeprog.sdk.ble;

import java.util.UUID;

import android.annotation.SuppressLint;

import com.xtremeprog.sdk.ble.BleService.BLESDK;

@SuppressLint("NewApi")
public class BleGattCharacteristic {

	public static final int PROPERTY_READ = 2;
	public static final int PROPERTY_WRITE = 8;
	public static final int PROPERTY_NOTIFY = 16;
	public static final int PROPERTY_INDICATE = 32;

	/**
	 * Characteristic value format type uint8
	 */
	public static final int FORMAT_UINT8 = 0x11;

	/**
	 * Characteristic value format type uint16
	 */
	public static final int FORMAT_UINT16 = 0x12;

	/**
	 * Characteristic value format type uint24 Note: this is not a standard data
	 * type!
	 */
	public static final int FORMAT_UINT24 = 0x13;

	/**
	 * Characteristic value format type uint32
	 */
	public static final int FORMAT_UINT32 = 0x14;

	/**
	 * Characteristic value format type sint8
	 */
	public static final int FORMAT_SINT8 = 0x21;

	/**
	 * Characteristic value format type sint16
	 */
	public static final int FORMAT_SINT16 = 0x22;

	/**
	 * Characteristic value format type sint32
	 */
	public static final int FORMAT_SINT32 = 0x24;

	/**
	 * Characteristic value format type sfloat (16-bit float)
	 */
	public static final int FORMAT_SFLOAT = 0x32;

	/**
	 * Characteristic value format type float (32-bit float)
	 */
	public static final int FORMAT_FLOAT = 0x34;

	private android.bluetooth.BluetoothGattCharacteristic mGattCharacteristicA;
	private com.broadcom.bt.gatt.BluetoothGattCharacteristic mGattCharacteristicB;
	private com.samsung.android.sdk.bt.gatt.BluetoothGattCharacteristic mGattCharacteristicS;
	private BLESDK mBleSDK;
	private String name;

	public BleGattCharacteristic(android.bluetooth.BluetoothGattCharacteristic c) {
		mBleSDK = BLESDK.ANDROID;
		setGattCharacteristicA(c);
		initInfo();
	}

	public BleGattCharacteristic(
			com.broadcom.bt.gatt.BluetoothGattCharacteristic c) {
		mBleSDK = BLESDK.BROADCOM;
		setGattCharacteristicB(c);
	}

	public BleGattCharacteristic(
			com.samsung.android.sdk.bt.gatt.BluetoothGattCharacteristic c) {
		mBleSDK = BLESDK.SAMSUNG;
		setGattCharacteristicS(c);
	}

	private void initInfo() {
		name = "Unknown characteristic";
	}

	public UUID getUuid() {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().getUuid();
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return getGattCharacteristicB().getUuid();
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return getGattCharacteristicS().getUuid();
		}

		return null;
	}

	protected android.bluetooth.BluetoothGattCharacteristic getGattCharacteristicA() {
		return mGattCharacteristicA;
	}

	public int getProperties() {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().getProperties();
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return getGattCharacteristicB().getProperties();
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return getGattCharacteristicS().getProperties();
		}

		return 0;
	}

	protected com.broadcom.bt.gatt.BluetoothGattCharacteristic getGattCharacteristicB() {
		return mGattCharacteristicB;
	}

	protected void setGattCharacteristicB(
			com.broadcom.bt.gatt.BluetoothGattCharacteristic mBCGattCharacteristic) {
		this.mGattCharacteristicB = mBCGattCharacteristic;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public boolean setValue(byte[] val) {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().setValue(val);
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return mGattCharacteristicS.setValue(val);
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return mGattCharacteristicB.setValue(val);
		}

		return false;
	}

	public byte[] getValue() {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().getValue();
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return mGattCharacteristicS.getValue();
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return mGattCharacteristicB.getValue();
		}

		return null;
	}

	public boolean setValue(int value, int formatType, int offset) {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().setValue(value, formatType, offset);
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return mGattCharacteristicS.setValue(value, formatType, offset);
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return mGattCharacteristicB.setValue(value, formatType, offset);
		}

		return false;
	}

	public boolean setValue(int mantissa, int exponent, int formatType,
			int offset) {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().setValue(mantissa, exponent,
					formatType, offset);
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return mGattCharacteristicS.setValue(mantissa, exponent,
					formatType, offset);
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return mGattCharacteristicB.setValue(mantissa, exponent,
					formatType, offset);
		}

		return false;
	}

	public boolean setValue(String value) {
		return setValue(value.getBytes());
	}

	public String getStringValue(int offset) {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().getStringValue(offset);
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return mGattCharacteristicS.getStringValue(offset);
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return mGattCharacteristicB.getStringValue(offset);
		}

		return null;
	}

	public Float getFloatValue(int formatType, int offset) {
		if (mBleSDK == BLESDK.ANDROID) {
			return getGattCharacteristicA().getFloatValue(formatType, offset);
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			return mGattCharacteristicS.getFloatValue(formatType, offset);
		} else if (mBleSDK == BLESDK.BROADCOM) {
			return mGattCharacteristicB.getFloatValue(formatType, offset);
		}

		return null;
	}

	public Integer getIntValue(int formatType, int offset) {
		if (mBleSDK == BLESDK.ANDROID) {
			if (formatType == FORMAT_UINT24) {
				byte[] value = getGattCharacteristicA().getValue();
				return byte2uint24(offset, value);
			} else {
				return getGattCharacteristicA().getIntValue(formatType, offset);
			}
		} else if (mBleSDK == BLESDK.SAMSUNG) {
			if (formatType == FORMAT_UINT24) {
				byte[] value = mGattCharacteristicS.getValue();
				return byte2uint24(offset, value);
			} else {
				return mGattCharacteristicS.getIntValue(formatType, offset);
			}
		} else if (mBleSDK == BLESDK.BROADCOM) {
			if (formatType == FORMAT_UINT24) {
				byte[] value = mGattCharacteristicB.getValue();
				return byte2uint24(offset, value);
			} else {
				return mGattCharacteristicB.getIntValue(formatType, offset);
			}
		}

		return null;
	}

	private Integer byte2uint24(int offset, byte[] value) {
		if ((offset + 3) > value.length)
			return null;
		return Integer.valueOf((value[offset] & 0xFF)
				| (value[offset + 1] & 0xFF) << 8
				| (value[offset + 2] & 0xFF) << 16);
	}

	protected com.samsung.android.sdk.bt.gatt.BluetoothGattCharacteristic getGattCharacteristicS() {
		return mGattCharacteristicS;
	}

	protected void setGattCharacteristicS(
			com.samsung.android.sdk.bt.gatt.BluetoothGattCharacteristic mSSGattCharacteristic) {
		this.mGattCharacteristicS = mSSGattCharacteristic;
	}

	protected void setGattCharacteristicA(
			android.bluetooth.BluetoothGattCharacteristic mGattCharacteristicA) {
		this.mGattCharacteristicA = mGattCharacteristicA;
	}
}