text:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;

namespace Skybrud.Social.Http {

    /// <summary>
    /// Collection of HTTP headers.
    /// </summary>
    public class SocialHttpHeaderCollection : IEnumerable<KeyValuePair<string, string>> {

        #region Properties

        /// <summary>
        /// Gets a reference to the internal instance of <see cref="WebHeaderCollection"/>.
        /// </summary>
        public WebHeaderCollection Headers { get; private set; }

        /// <summary>
        /// Gets or sets the character sets that are acceptable - eg. <c>utf8</c>. This property corresponds to
        /// the <c>Accept-Charset</c> HTTP header.
        /// </summary>
        public string AcceptCharset {
            get => Headers["Accept-Charset"];
            set => Headers["Accept-Charset"] = value;
        }

        /// <summary>
        /// Gets or sets the a list of acceptable encodings - eg. <c>gzip</c> or <c>gzip, deflate</c>. This
        /// property corresponds to the <c>Accept-Encoding</c> HTTP header.
        /// </summary>
        /// <see>
        ///     <cref>https://en.wikipedia.org/wiki/HTTP_compression</cref>
        /// </see>
        public string AcceptEncoding {
            get => Headers["Accept-Encoding"];
            set => Headers["Accept-Encoding"] = value;
        }

        /// <summary>
        /// Gets or sets the accept language header of the request - eg. <c>en-US</c>, <c>en</c> or
        /// <c>da</c>. This property corresponds to the <c>Accept-Language</c> HTTP header.
        /// </summary>
        /// <see>
        ///     <cref>https://en.wikipedia.org/wiki/Content_negotiation</cref>
        /// </see>
        public string AcceptLanguage {
            get => Headers["Accept-Language"];
            set => Headers["Accept-Language"] = value;
        }

        /// <summary>
        /// Gets or sets the authentication credentials for HTTP authentication. This property corresponds to the
        /// <c>Authorization</c> HTTP header.
        /// </summary>
        public string Authorization {
            get => Headers["Authorization"];
            set => Headers["Authorization"] = value;
        }

        /// <summary>
        /// Gets amount of headers added to the collection.
        /// </summary>
        public int Count => Headers.Count;

        /// <summary>
        /// Gets a <see cref="System.String"/> array representing the keys of the header collection.
        /// </summary>
        public string[] Keys => Headers.AllKeys.ToArray();

        /// <summary>
        /// Gets or set the header with the specified <paramref name="key"/>.
        /// </summary>
        /// <param name="key">The key of the header.</param>
        /// <returns>The value of the header.</returns>
        public string this[string key] {
            get => Headers[key];
            set => Headers[key] = value;
        }

        #endregion

        #region Constructor

        /// <summary>
        /// Creates an empty collection of headers.
        /// </summary>
        public SocialHttpHeaderCollection() {
            Headers = new WebHeaderCollection();
        }

        /// <summary>
        /// Creates a new instance based on the specified <paramref name="headers"/>.
        /// </summary>
        public SocialHttpHeaderCollection(WebHeaderCollection headers) {
            Headers = headers ?? new WebHeaderCollection();
        }

        #endregion

        #region Member methods

        /// <summary>
        /// Adds a new header with the specified <paramref name="name"/> and <paramref name="value"/>.
        /// </summary>
        /// <param name="name">The name of the header.</param>
        /// <param name="value">The value of the header.</param>
        public void Add(string name, string value) {
            Headers[name] = value;
        }

        /// <summary>
        /// Adds a new header with the specified <paramref name="name"/> and <paramref name="value"/>.
        /// </summary>
        /// <param name="name">The name of the header.</param>
        /// <param name="value">The value of the header.</param>
        public void Add(string name, object value) {
            Headers[name] = String.Format(CultureInfo.InvariantCulture, "{0}", value);
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the collection.</returns>
        public IEnumerator<KeyValuePair<string, string>> GetEnumerator() {
            return Headers.AllKeys.Select(x => new KeyValuePair<string, string>(x, Headers[x])).GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the collection.</returns>
        IEnumerator IEnumerable.GetEnumerator() {
            return GetEnumerator();
        }

        #endregion

        #region Operator overloading

        /// <summary>
        /// Creates a new instance from the specified <paramref name="headers"/>.
        /// </summary>
        /// <param name="headers">The <see cref="WebHeaderCollection"/> representing the headers.</param>
        public static implicit operator SocialHttpHeaderCollection(WebHeaderCollection headers) {

            // Initialize a new instance of SocialHttpHeaderCollection
            SocialHttpHeaderCollection collection = new SocialHttpHeaderCollection {
                Headers = headers ?? new WebHeaderCollection()
            };

            return collection;

        }

        #endregion

    }

}


text:
#ifndef __GST_DSHOWAUDIODEC_H__
#define __GST_DSHOWAUDIODEC_H__

#include <gst/gst.h>
#include "gstdshowutil.h"
#include "gstdshowfakesrc.h"

G_BEGIN_DECLS

typedef struct {
  gchar *element_name;      /* The gst element factory name */
  gchar *element_longname;  /* Description string for element */
  gint32 format;            /* WAVEFORMATEX format */
  gchar *sinkcaps;          /* GStreamer caps of input format */
  PreferredFilter *preferred_filters; /* NULL-terminated list of preferred filters */
} AudioCodecEntry;

#define GST_TYPE_DSHOWAUDIODEC               (gst_dshowaudiodec_get_type())
#define GST_DSHOWAUDIODEC(obj)              (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DSHOWAUDIODEC,GstDshowAudioDec))
#define GST_DSHOWAUDIODEC_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DSHOWAUDIODEC,GstDshowAudioDecClass))
#define GST_IS_DSHOWAUDIODEC(obj)           (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DSHOWAUDIODEC))
#define GST_IS_DSHOWAUDIODEC_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DSHOWAUDIODEC))

typedef struct _GstDshowAudioDec GstDshowAudioDec;
typedef struct _GstDshowAudioDecClass GstDshowAudioDecClass;

class AudioFakeSink;

struct _GstDshowAudioDec
{
  GstElement element;

  /* element pads */
  GstPad *sinkpad;
  GstPad *srcpad;

  GstFlowReturn last_ret;

  /* filters interfaces*/
  FakeSrc *fakesrc;
  AudioFakeSink *fakesink;

  IBaseFilterPtr decfilter;

  /* graph manager interfaces */
  IMediaFilterPtr mediafilter;
  IFilterGraphPtr filtergraph;

  /* true when dshow graph is setup */
  gboolean setup;

  /* audio settings */
  gint bitrate;
  gint block_align;
  gint depth;
  gint channels;
  gint rate;
  gint layer;
  GstBuffer *codec_data;

  /* current segment */
  GstSegment * segment;

  /* timestamp of the next buffer */
  GstClockTime timestamp;

  gboolean comInitialized;
  GMutex   com_init_lock;
  GMutex   com_deinit_lock;
  GCond    com_initialized;
  GCond    com_uninitialize;
  GCond    com_uninitialized;
};

struct _GstDshowAudioDecClass
{
  GstElementClass parent_class;
  const AudioCodecEntry *entry;
};

gboolean dshow_adec_register (GstPlugin * plugin);

const GUID CLSID_AudioFakeSink =
{ 0x3867f537, 0x3e3d, 0x44da,
  { 0xbb, 0xf2, 0x02, 0x48, 0x7b, 0xb0, 0xbc, 0xc4} };

class AudioFakeSink :  public CBaseRenderer
{
public:
  AudioFakeSink(GstDshowAudioDec *dec) :
      m_hres(S_OK),
      CBaseRenderer(CLSID_AudioFakeSink, _T("AudioFakeSink"), NULL, &m_hres),
      mDec(dec)
  {};
  virtual ~AudioFakeSink() {};

  HRESULT DoRenderSample(IMediaSample *pMediaSample);
  HRESULT CheckMediaType(const CMediaType *pmt);
  HRESULT SetMediaType (AM_MEDIA_TYPE *pmt)
  {
    m_MediaType.Set (*pmt);
    return S_OK;
  }
  int GetBufferSize();

protected:
  HRESULT m_hres;
  CMediaType m_MediaType;
  GstDshowAudioDec *mDec;
};

G_END_DECLS

#endif /* __GST_DSHOWAUDIODEC_H__ */

redpajama_set_name: RedPajamaGithub


text:
package com.netflix.hystrix.contrib.servopublisher;

import com.netflix.hystrix.HystrixEventType;
import com.netflix.hystrix.HystrixThreadPoolKey;
import com.netflix.hystrix.HystrixThreadPoolMetrics;
import com.netflix.hystrix.HystrixThreadPoolProperties;
import com.netflix.hystrix.metric.consumer.CumulativeThreadPoolEventCounterStream;
import com.netflix.hystrix.metric.consumer.RollingThreadPoolMaxConcurrencyStream;
import com.netflix.hystrix.metric.consumer.RollingThreadPoolEventCounterStream;
import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisherThreadPool;
import com.netflix.servo.DefaultMonitorRegistry;
import com.netflix.servo.annotations.DataSourceLevel;
import com.netflix.servo.monitor.BasicCompositeMonitor;
import com.netflix.servo.monitor.Monitor;
import com.netflix.servo.monitor.MonitorConfig;
import com.netflix.servo.tag.Tag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.functions.Func0;

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

/**
 * Implementation of {@link HystrixMetricsPublisherThreadPool} using Servo (https://github.com/Netflix/servo)
 */
public class HystrixServoMetricsPublisherThreadPool extends HystrixServoMetricsPublisherAbstract implements HystrixMetricsPublisherThreadPool {

    private static final Logger logger = LoggerFactory.getLogger(HystrixServoMetricsPublisherThreadPool.class);

    private final HystrixThreadPoolKey key;
    private final HystrixThreadPoolMetrics metrics;
    private final HystrixThreadPoolProperties properties;
    private final Tag servoInstanceTag;
    private final Tag servoTypeTag;

    public HystrixServoMetricsPublisherThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixThreadPoolMetrics metrics, HystrixThreadPoolProperties properties) {
        this.key = threadPoolKey;
        this.metrics = metrics;
        this.properties = properties;

        this.servoInstanceTag = new Tag() {

            @Override
            public String getKey() {
                return "instance";
            }

            @Override
            public String getValue() {
                return key.name();
            }

            @Override
            public String tagString() {
                return key.name();
            }

        };
        this.servoTypeTag = new Tag() {

            @Override
            public String getKey() {
                return "type";
            }

            @Override
            public String getValue() {
                return "HystrixThreadPool";
            }

            @Override
            public String tagString() {
                return "HystrixThreadPool";
            }

        };
    }

    @Override
    public void initialize() {
        /* list of monitors */
        List<Monitor<?>> monitors = getServoMonitors();

        // publish metrics together under a single composite (it seems this name is ignored)
        MonitorConfig commandMetricsConfig = MonitorConfig.builder("HystrixThreadPool_" + key.name()).build();
        BasicCompositeMonitor commandMetricsMonitor = new BasicCompositeMonitor(commandMetricsConfig, monitors);

        DefaultMonitorRegistry.getInstance().register(commandMetricsMonitor);
        RollingThreadPoolEventCounterStream.getInstance(key, properties).startCachingStreamValuesIfUnstarted();
        CumulativeThreadPoolEventCounterStream.getInstance(key, properties).startCachingStreamValuesIfUnstarted();
        RollingThreadPoolMaxConcurrencyStream.getInstance(key, properties).startCachingStreamValuesIfUnstarted();
    }

    @Override
    protected Tag getServoTypeTag() {
        return servoTypeTag;
    }

    @Override
    protected Tag getServoInstanceTag() {
        return servoInstanceTag;
    }

    protected Monitor<Number> safelyGetCumulativeMonitor(final String name, final Func0<HystrixEventType.ThreadPool> eventThunk) {
        return new CounterMetric(MonitorConfig.builder(name).withTag(getServoTypeTag()).withTag(getServoInstanceTag()).build()) {
            @Override
            public Long getValue() {
                try {
                    return metrics.getCumulativeCount(eventThunk.call());
                } catch (NoSuchFieldError error) {
                    logger.error("While publishing Servo metrics, error looking up eventType for : {}.  Please check that all Hystrix versions are the same!", name);
                    return 0L;
                }
            }
        };
    }

    protected Monitor<Number> safelyGetRollingMonitor(final String name, final Func0<HystrixEventType.ThreadPool> eventThunk) {
        return new GaugeMetric(MonitorConfig.builder(name).withTag(DataSourceLevel.DEBUG).withTag(getServoTypeTag()).withTag(getServoInstanceTag()).build()) {
            @Override
            public Long getValue() {
                try {
                    return metrics.getRollingCount(eventThunk.call());
                } catch (NoSuchFieldError error) {
                    logger.error("While publishing Servo metrics, error looking up eventType for : {}.  Please check that all Hystrix versions are the same!", name);
                    return 0L;
                }
            }
        };
    }

    /**
     * Servo will flatten metric names as: getServoTypeTag()_getServoInstanceTag()_monitorName
     *
     * An implementation note.  If there's a version mismatch between hystrix-core and hystrix-servo-metric-publisher,
     * the code below may reference a HystrixEventType.ThreadPool that does not exist in hystrix-core.  If this happens,
     * a j.l.NoSuchFieldError occurs.  Since this data is not being generated by hystrix-core, it's safe to count it as 0
     * and we should log an error to get users to update their dependency set.
     */
    private List<Monitor<?>> getServoMonitors() {

        List<Monitor<?>> monitors = new ArrayList<Monitor<?>>();

        monitors.add(new InformationalMetric<String>(MonitorConfig.builder("name").build()) {
            @Override
            public String getValue() {
                return key.name();
            }
        });

        // allow Servo and monitor to know exactly at what point in time these stats are for so they can be plotted accurately
        monitors.add(new GaugeMetric(MonitorConfig.builder("currentTime").withTag(DataSourceLevel.DEBUG).build()) {
            @Override
            public Number getValue() {
                return System.currentTimeMillis();
            }
        });

        monitors.add(new GaugeMetric(MonitorConfig.builder("threadActiveCount").build()) {
            @Override
            public Number getValue() {
                return metrics.getCurrentActiveCount();
            }
        });

        monitors.add(new GaugeMetric(MonitorConfig.builder("completedTaskCount").build()) {
            @Override
            public Number getValue() {
                return metrics.getCurrentCompletedTaskCount();
            }
        });

        monitors.add(new GaugeMetric(MonitorConfig.builder("largestPoolSize").build()) {
            @Override
            public Number getValue() {
                return metrics.getCurrentLargestPoolSize();
            }
        });

        monitors.add(new GaugeMetric(MonitorConfig.builder("totalTaskCount").build()) {
            @Override
            public Number getValue() {
                return metrics.getCurrentTaskCount();
            }
        });

        monitors.add(new GaugeMetric(MonitorConfig.builder("queueSize").build()) {
            @Override
            public Number getValue() {
                return metrics.getCurrentQueueSize();
            }
        });

        monitors.add(new GaugeMetric(MonitorConfig.builder("rollingMaxActiveThreads").withTag(DataSourceLevel.DEBUG).build()) {
            @Override
            public Number getValue() {
                return metrics.getRollingMaxActiveThreads();
            }
        });

        //thread pool event monitors
        monitors.add(safelyGetCumulativeMonitor("countThreadsExecuted", new Func0<HystrixEventType.ThreadPool>() {
            @Override
            public HystrixEventType.ThreadPool call() {
                return HystrixEventType.ThreadPool.EXECUTED;
            }
        }));
        monitors.add(safelyGetCumulativeMonitor("countThreadsRejected", new Func0<HystrixEventType.ThreadPool>() {
            @Override
            public HystrixEventType.ThreadPool call() {
                return HystrixEventType.ThreadPool.REJECTED;
            }
        }));
        monitors.add(safelyGetRollingMonitor("rollingCountThreadsExecuted", new Func0<HystrixEventType.ThreadPool>() {
            @Override
            public HystrixEventType.ThreadPool call() {
                return HystrixEventType.ThreadPool.EXECUTED;
            }
        }));
        monitors.add(safelyGetRollingMonitor("rollingCountCommandsRejected", new Func0<HystrixEventType.ThreadPool>() {
            @Override
            public HystrixEventType.ThreadPool call() {
                return HystrixEventType.ThreadPool.REJECTED;
            }
        }));

        // properties
        monitors.add(new InformationalMetric<Number>(MonitorConfig.builder("propertyValue_corePoolSize").build()) {
            @Override
            public Number getValue() {
                return properties.coreSize().get();
            }
        });

        monitors.add(new InformationalMetric<Number>(MonitorConfig.builder("propertyValue_maximumSize").build()) {
            @Override
            public Number getValue() {
                return properties.maximumSize().get();
            }
        });

        monitors.add(new InformationalMetric<Number>(MonitorConfig.builder("propertyValue_actualMaximumSize").build()) {
            @Override
            public Number getValue() {
                return properties.actualMaximumSize();
            }
        });

        monitors.add(new InformationalMetric<Number>(MonitorConfig.builder("propertyValue_keepAliveTimeInMinutes").build()) {
            @Override
            public Number getValue() {
                return properties.keepAliveTimeMinutes().get();
            }
        });

        monitors.add(new InformationalMetric<Number>(MonitorConfig.builder("propertyValue_queueSizeRejectionThreshold").build()) {
            @Override
            public Number getValue() {
                return properties.queueSizeRejectionThreshold().get();
            }
        });

        monitors.add(new InformationalMetric<Number>(MonitorConfig.builder("propertyValue_maxQueueSize").build()) {
            @Override
            public Number getValue() {
                return properties.maxQueueSize().get();
            }
        });

        return monitors;
    }

}


text:
using System;
using System.ComponentModel.DataAnnotations;
using EPiServer;
using EPiServer.Core;
using EPiServer.DataAbstraction;
using EPiServer.DataAnnotations;
using ImageProcessor.Web.Episerver.UI.Blocks.Business;

namespace ImageProcessor.Web.Episerver.UI.Blocks.Models.Blocks
{
    [ContentType(DisplayName = "Method Collection",
        GUID = "12fed908-e7b4-4dca-aee6-fcb65dcaf969",
        Description = "Re-useable grouping of image processing methods",
        GroupName = Global.GroupName,
        Order = 33)]
    [Icon]
    public class MethodCollectionBlock : ImageProcessorMethodBaseBlock
    {
        [Display(Name = "Methods",
                Description = "Select the methods to process the image with",
                Order = 1)]
        [AllowedTypes(typeof(ImageProcessorMethodBaseBlock))]
        public virtual ContentArea Methods { get; set; }

        public override UrlBuilder GetMethod(UrlBuilder url)
        {
            if (Methods == null)
            {
                return url;
            }
            foreach (var item in Methods.FilteredItems)
            {
                if (item.GetContent() is ImageProcessorMethodBaseBlock method)
                {
                    method.GetMethod(url);
                }
            }
            return url;
        }
    }
}


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

-->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="300dip"
              android:layout_height="wrap_content"
              android:padding="16dip">

    <com.albedinsky.android.ui.widget.EditTextWidget
            android:id="@+id/dialog_file_new_edit_text_file_name"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="@string/storage_files_dialog_file_new_hint"/>

    <com.albedinsky.android.ui.widget.CheckBoxWidget
            android:id="@+id/dialog_file_new_check_box_as_directory"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/storage_files_dialog_file_new_check_as_directory"/>
</LinearLayout>


text:
package procstat

import (
	"fmt"
	"testing"

	"os/user"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestGather_RealPattern(t *testing.T) {
	pg, err := NewNativeFinder()
	require.NoError(t, err)
	pids, err := pg.Pattern(`procstat`)
	require.NoError(t, err)
	fmt.Println(pids)
	assert.Equal(t, len(pids) > 0, true)
}

func TestGather_RealFullPattern(t *testing.T) {
	pg, err := NewNativeFinder()
	require.NoError(t, err)
	pids, err := pg.FullPattern(`%procstat%`)
	require.NoError(t, err)
	fmt.Println(pids)
	assert.Equal(t, len(pids) > 0, true)
}

func TestGather_RealUser(t *testing.T) {
	user, err := user.Current()
	require.NoError(t, err)
	pg, err := NewNativeFinder()
	require.NoError(t, err)
	pids, err := pg.Uid(user.Username)
	require.NoError(t, err)
	fmt.Println(pids)
	assert.Equal(t, len(pids) > 0, true)
}


text:
package org.codegist.crest.annotate;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 *
Binds a method parameter to be used as a request form parameter.

 *
Values will be URL encoded unless this is disabled using the {@link org.codegist.crest.annotate.Encoded} annotation.

 *
The type of the parameter must either:

 *

 *
Be a primitive

 *
Have a toString() method that returns the value to be used

 *
Any type being handled by CRest, see available {@link org.codegist.crest.serializer.Serializer} implementations for a list of supported types.

 *
Any user specific type given that a {@link org.codegist.crest.serializer.Serializer} has been provided for it.

 *
Be a Collection<T>, or an array T[] where T satisfies 2, 3 or 4 above.

 *

 *
Note that for array/Collection, the default behavior will be to create as many pair/value parameters as values in the array/collection. Values can be merged in one single parameter using the {@link org.codegist.crest.annotate.ListSeparator} annotation

 *
Can contain placeholders, see {@link org.codegist.crest.CRestBuilder#placeholder(String, String)}.

 *
When set at interface or method levels, it will add a form parameter with the given value for all method's to which it applies

 * @see org.codegist.crest.annotate.Serializer
 * @see org.codegist.crest.annotate.ListSeparator
 * @author laurent.gilles@codegist.org
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD, ElementType.PARAMETER})
public @interface FormParam {

    /**
     * Defines the name of the request form parameter that will hold the given value
     */
    String value();

    /**
     * Defines the default value of the form parameter if the value being passed is null
     */
    String defaultValue() default "";
}


text:
<?php

class communityComponents extends opCommunityComponents {
    public function executeJoinListBox($request) {
        if (!opToolkit::isSecurePage()) {
            return sfView::NONE;
        }
        $context = sfContext::getInstance();
        $module = $context->getActionStack()->getLastEntry()->getModuleName();
        $action = $context->getActionStack()->getLastEntry()->getActionName();

        $this->type = sfConfig::get('sf_nav_type', sfConfig::get('mod_' . $module . '_default_nav', 'default'));

        if ('default' != $this->type) {
            $this->navId = sfConfig::get('sf_nav_id', $request->getParameter('id'));
            $this->member = Doctrine::getTable('Member')->find($this->navId);
        }else {
            $this->navId = $this->getUser()->getMemberId();
            $this->member = $this->getUser()->getMember();
        }
        $this->row = $this->gadget->getConfig('row');
        $this->col = $this->gadget->getConfig('col');
        $this->crownIds = Doctrine::getTable('CommunityMember')->getCommunityIdsOfAdminByMemberId($this->member->getId());
        $this->communities = Doctrine::getTable('Community')->retrievesByMemberId($this->member->getId(), $this->row * $this->col, true);
    }

    public function executeCommunityNewTopic($request) {

    }
}


text:
<?php

class Oauth2 implaments ApiInterface {

	private $ConnectionData;

	__construct($ConnectionData){
		if($ConnectionData instanceof ConnectionData){
			$this->ConnectionData = $ConnectionData;
		}
	}

	public function getYearSteps(array $token = []);
	public function getRangeSteps(array $token = [], DateTme $start, DateTme $end);

	public function getYearDistance(array $token = []);
	public function getRangeDistance(array $token = [], DateTme $start, DateTme $end);

	public function migrateTokenFromOauth1aToOauth2(array $oauth1aToken = []){
		return NULL; //not yet necessary unless there is an oAuth3 released one day
	}

	public function getUserToken($input);
	public function setUserToken($input, $clear_cache = TRUE);
}


text:
var async = require('async'),
  fs = require('fs'),
  path = require('path'),
  spawn = require('child_process').spawn,
  file = require('./file'),
  commitMessage = require('./util').commitMessage;

module.exports = function(args, callback){
  var baseDir = args.deploy_dir || hexo.base_dir,
    //deployDir = path.join(baseDir, '.deploy'),
    deployDir = baseDir,
    gitDir = path.join(baseDir, '.git'),
    themesDir = path.join(baseDir, 'themes'),
    publicDir = hexo.public_dir;

  if (!args.repo && !args.repository){
    var help = '';

    help += 'You should configure deployment settings in _config.yml first!\n\n';
    help += 'Example:\n';
    help += '  deploy:\n';
    help += '    type: git\n';
    help += '    message: [message]\n';
    help += '    repo:\n';
    help += '      github: <repository url>,<branch>\n';
    help += '      gitcafe: <repository url>,<branch>\n\n';
    help += 'For more help, you can check the docs: ' + 'http://hexo.io/docs/deployment.html'.underline;

    console.log(help);
    return callback();
  }

  var repo = args.repo || args.repository;
  for (var t in repo){
    var s = repo[t].split(',');
    repo[t] = {};
    repo[t].url = s[0];
    repo[t].branch = s.length > 1 ? s[1] : 'master';
  }

  var run = function(command, args, callback){
    var cp = spawn(command, args, {cwd: deployDir});

    cp.stdout.on('data', function(data){
      process.stdout.write(data);
    });

    cp.stderr.on('data', function(data){
      process.stderr.write(data);
    });

    cp.on('close', callback);
  };

  async.series([
    // Set up
    function(next){
      fs.exists(gitDir, function(exist){
        if (exist && !args.setup) return next();
        hexo.log.i('Setting up Git-Backup deployment...');

        var commands = [['init']];
        if(args.theme){
             var themeGitDir = path.join(baseDir,'themes/' + args.theme + '/.git');
             var themeDir = path.join(baseDir,'themes/' + args.theme);
             fs.exists(themeGitDir,function(exist){
                 if(exist){
                        var child = spawn('rm', ['-rf', '.git'],{cwd: themeDir});
                        hexo.log.i(themeGitDir);
                        child.stdout.setEncoding('utf8');
                        child.stdout.on('data', function(data) {
                                hexo.log.i(data);
                            });
                        child.stderr.on('data', function (data) {
                              hexo.log.i('stderr: ' + data);
                        });

                        child.on('close', function (code) {
                              hexo.log.i('child process exited with code ' + code);
                        });
                        }
                })
            }
        if (args.master && repo[args.master]){
          var master = repo[args.master];
          hexo.log.i('fetch from ['+ args.master.green + ']:', master.url.cyan);
          commands.push(['remote', 'add', 'origin', '-t', master.branch, master.url]);
          commands.push(['pull']);
        } else {
          commands.push(['add', '-A', '.']);
          commands.push(['commit', '-m', 'First commit']);
          hexo.log.i('First');
        }

        for (var t in repo){
          commands.push(['remote', 'add', t, '-t', repo[t].branch, repo[t].url]);
        }
        //file.writeFile(deployDir, 'placeHolder', function(err){
         // if (err) callback(err);
          async.eachSeries(commands, function(item, next){
            run('git', item, function(code){
              if (code === 0) next();
            });
          }, function(){
            if (!args.setup) next();
          });
       // });
      });
    },

    function(next){
      //file.emptyDir(deployDir, next);
      next();
    },
    function(next){
      var commands = [
        ['add', '-A'],
        ['commit', '-m', commitMessage(args)],
      ];

      for (var t in repo){
        commands.push(['push', '-u', t, 'master:' + repo[t].branch, '--force']);
      }

      async.eachSeries(commands, function(item, next){
        run('git', item, function(){
          next();
        });
      }, next);
    }
  ], callback);
};


text:
var Page = require('./page');

module.exports = Page({
  feed: 'http://blogs.fidm.com/my_weblog/costume_design/rss.xml',
  title: 'Theatre Costume Design'
});


text:
from collections.abc import MutableSet

class OrderedSet(MutableSet):
    """
    Ordered set.

    See: https://code.activestate.com/recipes/576694/.
    """
    def __init__(self, iterable=None):
        self.end = end = []
        end += [None, end, end]         # sentinel node for doubly linked list
        self.map = {}                   # key --> [key, prev, next]
        if iterable is not None:
            self |= iterable

    def __len__(self):
        return len(self.map)

    def __contains__(self, key):
        return key in self.map

    def add(self, key):
        if key not in self.map:
            end = self.end
            curr = end[1]
            curr[2] = end[1] = self.map[key] = [key, curr, end]

    def discard(self, key):
        if key in self.map:
            key, prev, next = self.map.pop(key)
            prev[2] = next
            next[1] = prev

    def __iter__(self):
        end = self.end
        curr = end[2]
        while curr is not end:
            yield curr[0]
            curr = curr[2]

    def __reversed__(self):
        end = self.end
        curr = end[1]
        while curr is not end:
            yield curr[0]
            curr = curr[1]

    def pop(self, last=True):
        if not self:
            raise KeyError('set is empty')
        key = self.end[1][0] if last else self.end[2][0]
        self.discard(key)
        return key

    def __repr__(self):
        if not self:
            return '%s()' % (self.__class__.__name__,)
        return '%s(%r)' % (self.__class__.__name__, list(self))

    def __eq__(self, other):
        if isinstance(other, OrderedSet):
            return len(self) == len(other) and list(self) == list(other)
        return set(self) == set(other)


text:
package releasebundlecreate

var Usage = []string{"ds rbc [command options] <release bundle name> <release bundle version> <pattern>",
	"ds rbc --spec=<File Spec path> [command options] <release bundle name> <release bundle version>"}

func GetDescription() string {
	return "Create a release bundle."
}

func GetArguments() string {
	return `	release bundle name
		The name of the release bundle.

	release bundle version
		The release bundle version.

	pattern
		Specifies the source path in Artifactory, from which the artifacts should be bundled,
		in the following format: <repository name>/<repository path>. You can use wildcards to specify multiple artifacts.`
}


text:
#pragma once
#include <aws/rekognition/Rekognition_EXPORTS.h>
#include <aws/rekognition/model/S3Object.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Rekognition
{
namespace Model
{

  /**
   *
The S3 bucket that contains an Amazon Sagemaker Ground Truth format manifest
   * file.

See Also:
   AWS
   * API Reference

   */
  class AWS_REKOGNITION_API GroundTruthManifest
  {
  public:
    GroundTruthManifest();
    GroundTruthManifest(Aws::Utils::Json::JsonView jsonValue);
    GroundTruthManifest& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    inline const S3Object& GetS3Object() const{ return m_s3Object; }

    inline bool S3ObjectHasBeenSet() const { return m_s3ObjectHasBeenSet; }

    inline void SetS3Object(const S3Object& value) { m_s3ObjectHasBeenSet = true; m_s3Object = value; }

    inline void SetS3Object(S3Object&& value) { m_s3ObjectHasBeenSet = true; m_s3Object = std::move(value); }

    inline GroundTruthManifest& WithS3Object(const S3Object& value) { SetS3Object(value); return *this;}

    inline GroundTruthManifest& WithS3Object(S3Object&& value) { SetS3Object(std::move(value)); return *this;}

  private:

    S3Object m_s3Object;
    bool m_s3ObjectHasBeenSet = false;
  };

} // namespace Model
} // namespace Rekognition
} // namespace Aws


text:
using System.Windows.Forms;
using System.Runtime.InteropServices;

public class AddByUserSelection
{

    private void Button1_Click(object sender, System.EventArgs e)
    {
        SolidEdgeFramework.Application objApplication = null;
        SolidEdgeDraft.DraftDocument objDraftDoc = null;
        SolidEdgeDraft.DrawingView DrawingView = null;
        SolidEdgeDraft.DrawingViews DrawingViews = null;
        SolidEdgeDraft.BlockTables BlockTables = null;
        SolidEdgeDraft.BlockTable BlockTable = null;
        SolidEdgeFrameworkSupport.Balloons Balloons = null;
        Type objType = null;

        try
        {
            // Create/get the application with specific settings
            objApplication = (SolidEdgeFramework.Application)Marshal.GetActiveObject("SolidEdge.Application");

            if (objApplication == null)
            {
                // Get the type from the Solid Edge ProgID
                objType = Type.GetTypeFromProgID("SolidEdge.Application");
                // Start Solid Edge
                objApplication = Activator.CreateInstance(objType);
                // Make Solid Edge visible
                objApplication.Visible = true;
            }
            //Get reference to active document
            objDraftDoc = objApplication.ActiveDocument;
            DrawingViews = objDraftDoc.ActiveSheet.DrawingViews;
            BlockTables = objDraftDoc.BlockTables;
            Balloons = objDraftDoc.ActiveSheet.Balloons;

            //Add Method- By User Selection
            BlockTable = BlockTables.AddByUserSelection("ISO", 1);

            //Update Method
            foreach (SolidEdgeDraft.BlockTable BlockTableWithinLoop in BlockTables)
            {
                BlockTable = BlockTableWithinLoop;
                BlockTableWithinLoop.Update();
            }

            //Delete method
            foreach (SolidEdgeDraft.BlockTable BlockTableWithinLoop in BlockTables)
            {
                BlockTable = BlockTableWithinLoop;
                BlockTableWithinLoop.Delete();
            }

            //Add Method (only table )
            BlockTable = BlockTables.AddByUserSelection("ISO", 0);

        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.ToString());
        }
    }

    public AddByUserSelection()
    {
    	SubscribeToEvents();
    }

	private bool EventsSubscribed = false;
	private void SubscribeToEvents()
	{
		if (EventsSubscribed)
			return;
		else
			EventsSubscribed = true;

		Button1.Click += Button1_Click;
	}

}


text:
(function () {
    'use strict';

    angular.module('TeaMeeting')
            .factory('post', ['$http', postService]);

    function postService($http) {
        function defaultFailure(response) {
            console.error(response.data);
        }

        function post(url, callback, data, failure) {
            failure = failure || defaultFailure;
            $http({
                method: 'POST',
                url: url,
                data: data,
                headers: {'Content-Type': 'application/x-www-form-urlencoded'}
            }).then(callback, failure);
        }

        return post;
    }
})();


text:
<ns0:eml xmlns:ns0="eml://ecoinformatics.org/eml-2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" packageId="newsgs.3.7" scope="system" system="knb" xsi:schemaLocation="eml://ecoinformatics.org/eml-2.0.0 eml.xsd">
  <dataset scope="document">
    <title>Long-term net above ground primary production of the
      shortgrass steppe community</title>
    <creator id="1083869653214" scope="document">
      <individualName>
        <salutation>Dr.</salutation>
        <givenName>William</givenName>
        <surName>Lauenroth</surName>
      </individualName>
      <organizationName>SGS-LTER</organizationName>
      <positionName>Principal Investigator</positionName>
      <address scope="document">
        <deliveryPoint>Department of Forest, Rangeland, and Watershed Stewardship</deliveryPoint>
        <deliveryPoint>Campus Delivery 1472</deliveryPoint>
        <city>Fort Collins</city>
        <administrativeArea>Colorado</administrativeArea>
        <postalCode>80523-1472</postalCode>
        <country>USA</country>
      </address>
      <electronicMailAddress>billl@cnr.colostate.edu</electronicMailAddress>
    </creator>
    <creator id="1083869439376" scope="document">
      <individualName>
        <salutation>Dr.</salutation>
        <givenName>Daniel</givenName>
        <surName>Milchunas</surName>
      </individualName>
      <organizationName>SGS-LTER</organizationName>
      <positionName>Principal investigator</positionName>
      <address scope="document">
        <deliveryPoint>Department of Forest, Rangeland, and Watershed Stewardship</deliveryPoint>
        <deliveryPoint>Campus Delivery 1472</deliveryPoint>
        <city>Fort Collins</city>
        <administrativeArea>Colorado</administrativeArea>
        <postalCode>80523-1472</postalCode>
        <country>USA</country>
      </address>
      <phone phonetype="voice">970-491-6691</phone>
      <electronicMailAddress>daniel.milchunas@colostate.edu</electronicMailAddress>
    </creator>
    <abstract>
      <para>The ojectives of this study are: a) Long-term monitoring of
        ANPP and peak-crop nitrogen yield in moderately grazed and
        ungrazed sites. (In conjuction with neutron probe soil water
        monitoring.) b) monitor temporal dynamics of life-form nitrogen
        concentration.  Additional Objective: monitor annual nitrogen
        concentrations, yields, ANPP.  Additional Objective: to capture
        a digital photograph that allows researchers to interpret
        biomass in g/m2 or other characteristics of the vegetation.</para>
    </abstract>
    <keywordSet>
      <keyword>Milchunas, productivity, biomass, populations, processes,
        plants, vegetation</keyword>
    </keywordSet>
    <intellectualRights>
      <para>Shortgrass Steppe (SGS) LTER data sets represent years of
        hard work by dedicated scientists and technicians. Please
        respect the effort that went into the creation of these data
        sets. If you plan to use the SGS LTER data sets, please follow
        the SGS LTER data acquisition policy outlined below. Thank you
        for your cooperation.   1. Before downloading data: Please send
        or email the SGS Data manager a short notice stating your
        reasons for acquiring data and a description of your publication
        intent.  2. Prior to Submission: Please send a copy of the
        report or manuscript to the principal investigator of the data.
        The SGS LTER should be adequately cited in any resulting
        publications.  3. Please Include Tag Line in Report or
        Manuscript: Data sets were provided by the Shortgrass Steppe
        Long Term Ecological Research group, a partnership between
        Colorado State University, United States Department of
        Agriculture, Agricultural Research Service, and the U.S. Forest
        Service Pawnee National Grassland. Significant funding for these
        data was provided by the National Science Foundation Long Term
        Ecological Research program (NSF Grant Number DEB-0217631).  If
        you have any questions, please contact the Information Manager, Nicole.Kaplan@colostate.edu.</para>
    </intellectualRights>
    <coverage scope="document">
      <geographicCoverage scope="document">
        <geographicDescription>Shortgrass Steppe LTER (SGS)</geographicDescription>
        <boundingCoordinates>
          <westBoundingCoordinate>-104.8</westBoundingCoordinate>
          <eastBoundingCoordinate>-104.6952</eastBoundingCoordinate>
          <northBoundingCoordinate>40.8</northBoundingCoordinate>
          <southBoundingCoordinate>40.8</southBoundingCoordinate>
        </boundingCoordinates>
      </geographicCoverage>
      <temporalCoverage scope="document">
        <singleDateTime>
          <calendarDate>2000-01-01</calendarDate>
        </singleDateTime>
      </temporalCoverage>
      <taxonomicCoverage scope="document">
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Agropyron</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Allium</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Aristida</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Aristida</taxonRankValue>
          <taxonomicClassification>
            <taxonRankName>Species</taxonRankName>
            <taxonRankValue>longiseta</taxonRankValue>
            <commonName>Redthree Awn</commonName>
          </taxonomicClassification>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Artemisia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Astragalus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Astragulas</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Atriplex</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Bouteloua</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Buchloe</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Carex</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Chenopodium</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Chrysothamnus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Coryphantha</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Dalea</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Eriogonum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Euphorbia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Gaura</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Grindelia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Gutierrezia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Haplopappus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Helianthus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Hordeum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Ipomopsis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Lappula</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Lepidium</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Lithosperma</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Lupinus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Lygodesmia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Machaeranthera</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Mirabilis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Muhlenbergia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Oenothera</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Opuntia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Orobanche</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Oryzopsis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Penstemon</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Picradeniopsis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Plantago</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Portulaca</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Psoralea</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Salsola</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Schedonnardis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Senecio</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Sitanion</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Sphaeralcea</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Sporobolus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Stipa</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Talinum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Thelesperma</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Townsendia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Tradescantia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Tragopogon</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Unknown</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>Vulpia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Genus</taxonRankName>
          <taxonRankValue>unknown</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>Oxytropis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>albidus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>album</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>angustifolius</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>annuus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>candida</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>canescens</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>coccinea</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>comata</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>coronopifolia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>cryptandrus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>dactyloides</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>densiflorum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>dubius</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>effusum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>eleocharis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>exotic</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>fasciculata</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>filifolia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>flifolium</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>forb</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>frigida</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>glyptosperma</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>gracilis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>grandiflora</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>grass</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>hymenoides</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>hystrix</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>iberica</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>incanum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>incisum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>jubatum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>juncea</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>laxiflora</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>leptophyllum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>linearis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>longiseta</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>megapotamicum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>nauseosus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>occidenalis</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>octoflora</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>oleracea</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>oppositifolia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>paniculatus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>parviflorum</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>patagonica</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>petiolaris</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>polycantha</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>pusillus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>redowskii</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>sarothrae</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>secundiflorus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>shrub</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>smithii</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>species</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>spinulosus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>squarrosa</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>tanacetifolia</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>tenuiflora</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>textile</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>torreyi</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>tridenticulatus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>viscidiflorus</taxonRankValue>
        </taxonomicClassification>
        <taxonomicClassification>
          <taxonRankName>Species</taxonRankName>
          <taxonRankValue>vivipara</taxonRankValue>
        </taxonomicClassification>
      </taxonomicCoverage>
    </coverage>
    <contact scope="document">
      <references>1083869653214</references>
    </contact>
    <contact scope="document">
      <references>1083869439376</references>
    </contact>
    <contact id="1083869910464" scope="document">
      <individualName>
        <salutation>Ms.</salutation>
        <givenName>Nicole</givenName>
        <surName>Kaplan</surName>
      </individualName>
      <organizationName>SGS-LTER</organizationName>
      <positionName>Information Manager</positionName>
      <address scope="document">
        <deliveryPoint>Department of Soil and Crop Sciences</deliveryPoint>
        <deliveryPoint>Campus Delivery 1170</deliveryPoint>
        <city>Fort Collins</city>
        <administrativeArea>Colorado</administrativeArea>
        <postalCode>80523-1170</postalCode>
        <country>USA</country>
      </address>
      <phone phonetype="voice">(970)-491-1147</phone>
      <electronicMailAddress>Nicole.Kaplan@colostate.edu</electronicMailAddress>
    </contact>
    <methods>
      <methodStep>
        <description>
          <section>
            <title>Long-term NPP Field Sampling Protocol</title>
            <para>Study Sites and Methods:</para>
            <para>There are six locations: ridgetop (ridge), midslope
              (M-slope), swale, ESA (replicate 1, control block),
              Section 25 (SEC 25), and Owl Creek (OC).  Make sure all
              are done.  Each location has 15 plots.  There are 3
              transects with 5 plots in each transect.  Plots in the
              grazed locations are protected by cages.  Chose a random
              direction and distance to move the cages for the LTNPP
              harvest next year and re-stake the cages.  Plots in the
              ungrazed locations are chosen randomly each year.   The 3
              transects are marked by rebar.  Measure to the random
              location of the five plots along each transect.</para>
          </section>
        </description>
        <instrumentation>Equipment needed:</instrumentation>
        <instrumentation>Different size bags (sizes #2-shopping bags)
          and coin envelopes contained in a 5 gallon bucket</instrumentation>
        <instrumentation>Clippers</instrumentation>
        <instrumentation>Sharpie</instrumentation>
        <instrumentation>Knee pads</instrumentation>
        <instrumentation>m2 circular metal clipping frame</instrumentation>
        <instrumentation>Hammers</instrumentation>
        <instrumentation>Replacement tent stakes to restake cages</instrumentation>
        <instrumentation>Digital camera and digital camera field
          notebook (see protocol for taking digital pictures)</instrumentation>
      </methodStep>
      <methodStep>
        <description>
          <section>
            <title>Grinding and Combining Guidelines for LTER LTNPP</title>
            <para>1. Check bag with sample for ID information, so that
              the corresponding plot may be found on the Biomass List
              for the LTNPP.</para>
            <para>2. Once you have located the correct plot on the
              Biomass List, check to see if the</para>
            <para>plant species in the bag match up with those on the
              list.  Keep in mind that the OPPO (cactus) has been
              removed from the main bag, so you will not find any OPPO
              in the sample bag.  (If you do find any OPPO in the bag,
              please let Judy know.)</para>
            <para>3. If you find any problems with the list not matching
              with the sampling bag, note the problem on the list and
              put the bag aside for Judy to deal with later.  If
              everything matches up between the list and the bag, go
              ahead to step #4.</para>
            <para>4. Separate the species for grinding according to this plan:</para>
            <para>a. OPPO (should already be separate)</para>
            <para>b. SPCO</para>
            <para>c. BOGR and BUDA</para>
            <para>d. All Others  (All samples other than a, b, and c
              will be combined for grinding, and labeled OTHER.)</para>
            <para>All species will not be found on every plot, but
              separate the ones you do find according to this plan.
              Total weight of the sample to be ground needs to be at
              least 2 grams to be put through the Wiley Mill.  Samples
              with a total weight of less than 2 grams will be ground in
              the ball mill-grinding step.</para>
            <para>5. When preparing to grind a sample, first dump the
              sample out onto a tray or</para>
            <para>pan so that you can remove any foreign matter from the
              sample.  Foreign matter may include rocks, insects, animal
              scat, other plant species, etc.  Hopefully, most or all of
              the foreign matter will have been removed when the sample
              was weighed.</para>
            <para>6. When you have finished checking the sample, go
              ahead and put it into the top of the grinder.
              It’s OK to bend or break the sample in order to
              make it fit.  Always use the wooden dowel to push the
              sample into the grinder.  Never use your hands to push the
              sample into the grinder!  It’s a good idea to
              let the wooden dowel rest in the top of the grinding
              funnel, so that sample doesn’t “spit
              out” the top of the grinder after you turn the
              grinder on.</para>
            <para>7. Before turning the grinder switch on, make sure
              that the grinder door is tightly closed and the glass
              “catching jar” is screwed securely
              onto the bottom of the grinder.  Then you can secure the
              safety lock and turn the grinder on.</para>
            <para>8. Quite often you will need to tamp down on the
              sample with the wooden dowel to force the sample to enter
              the grinding chamber.  When the sample enters the grinding
              chamber the grinder will noisily chop it up.  If the
              sample is too large or bulky, the blades may not rotate
              and you will not hear a grinding noise.  This does not
              happen very often, but when it does occur it’s
              important to turn the grinder off right away so the motor
              doesn’t burn out.  Then you can open up the door
              to the grinding chamber to free up the sample that is
              “stuck” with a sturdy pair of tweezers.</para>
            <para>9. You can see the ground material coming out of the
              grinder into the catch jar at the bottom.  When the flow
              of sample is down to a minimum, you can consider your
              sample ground and turn the grinder off.</para>
            <para>10. Make sure to disengage the safety lock first
              thing, so that the grinder can not be accidentally restarted.</para>
            <para>11. Now the grinding door may be opened and the small
              bits of remaining sample may be swept into the catch jar
              with a toothbrush.  (Once again, please don’t
              use your hands!)</para>
            <para>12. The ground sample may be placed in a labeled coin
              envelope and put aside for ball grinding in the future.
              If the sample is too large to fit in one coin envelope use
              as many coin envelopes as necessary.  Label all of the
              envelopes as usual and then add 1 of 2, 2 of 2, etc.</para>
            <para>13. The grinder and catching jar must be vacuumed out
              thoroughly between samples to prevent cross-contamination.
              Use a brush to turn the grinding blades and remove stuck
              sample if need be, not your hands.</para>
            <para>14. Once the grinder is clean, you’re ready
              to start another bag of plant samples.</para>
            <para>A digital picture must be taken of every plot before
              it is clipped.  Use the ¼ m2 black wood frame to
              show the perimeter of the plot.  Label the white board
              with the same information used on the sample bags (shown
              below) and place to the side of the frame.  Follow the
              protocol for taking digital pictures (U:field season\field
              studies\digital pictures).</para>
            <para>Clip at crown-level, except for shrubs.  Only current
              year growth of shrubs are clipped that is green and has
              leaves, and which grows from an older, woodier branch.
              All live and recent dead material needs to be harvested
              from the plot – check your plot before moving to
              the next one.  Old-dead is not included in the sample (the
              gray colored material). You can brush the old-dead
              material away from the clipped material with your fingers.</para>
            <para>Plots are clipped by species.  It is usually easier to
              first clip species other than BOGR and BUDA.  There are
              three cactus species on the site.  Only current year
              growth of OPPO is clipped – these are the small
              pads.  The two “barrel” cactus are not
              clipped (ECVI and COVI).  There are only some times when
              combining of species may be done.  You must follow these
              rules when combining species.</para>
            <para>1) The only time combining is allowed is when two
              species are each less than a gram (this may be a seedling,
              a few leaves, or one very small stem or leaf of an individual).</para>
            <para>2) Some species are never combined even if there is
              only a very small quantity – these are BOGR,
              BUDA, SPCO, and CAHE.</para>
            <para>3) When combining never combine forbs with shrubs,
              grasses with forbs, etc.  Only combine grasses with
              grasses, forbs with forbs, and shrubs with shrubs.
              Envelopes that contain combined species should have codes
              for all species in the envelope.</para>
            <para>Place all envelopes or small bags from each plot into
              the largest sample bag from that plot.  Note all small
              mammal, ant and any other disturbances on the largest
              sample bag from that plot.  This is usually, but not
              always, the BOGR bag.  If there happens to be one or more
              large bags from one plot, keep track of them by labeling
              the bags “1 of 3, 2 of 3, 3 of 3”.
              Make sure that your writing is clear and legible and that
              the bags are labeled using a sharpie permanent marker.</para>
          </section>
        </description>
        <instrumentation>Wiley Mill, balance, and ball grinder</instrumentation>
      </methodStep>
      <methodStep>
        <description>
          <section>
            <title>Protocol for Capturing Digital Images for Aboveground Biomass</title>
            <para>Use the ladder to gain a bird?s eye view of the plot.
              Be sure that the wood or metal frame is delimiting the
              plot as accurately as possible.  Run your finger along the
              edge of the frame and pull vegetation in that is rooted
              within the frame and out that is rooted outside of the
              frame.  A photo may need to be taken of the vegetation
              underneath a cage.  In this case, remove the stakes around
              the cage and place the middle frame under the cage in the
              center of the plot.  Lift and rotate the cage one meter to
              the east and south and re-stake the cage.  Situate
              yourself on the ladder in a stable position and as
              parallel to the plot as possible. Create a complete label
              for that project and plot on the white board.  The label
              should be consistent and include the project name, date,
              transect, and plot or treatment description.  Place the
              labeled white board to the right or left of the plot.
              Pictures should be captured at a 640 x 480 resolution.
              Review the picture on the screen to be sure that the image
              was captured.  Keep track of the image # and plot label in
              the digital camera field book or on a data sheet that is
              provided.  Place a pin flag with the plot and transect
              number or coordinates in the middle of the metal frame
              after you capture the image.  This marks the center of the
              plot that was beneath a cage.  It is very important to
              keep this record in case we need to go back and verify a
              digital image.</para>
          </section>
        </description>
        <instrumentation>Kodak Digital Camera</instrumentation>
        <instrumentation>Orange Field Book for Digital Camera</instrumentation>
        <instrumentation>White board</instrumentation>
        <instrumentation>Dry erase markers and eraser</instrumentation>
        <instrumentation>Cleaner and paper towels</instrumentation>
        <instrumentation>Black ¼ m2 wood frame (used for LTNPP, GZTX,
          and Cross Site plots) OR</instrumentation>
        <instrumentation>Square meter white metal frame (used for Chart,
          oppo, and Bogr Removal studies)</instrumentation>
        <instrumentation>Sturdy ladder</instrumentation>
      </methodStep>
      <sampling>
        <studyExtent>
          <description>
            <para>There are six locations: ridgetop (ridge), midslope
              (M-slope), swale, ESA (replicate 1, control block),
              Section 25 (SEC 25), and Owl Creek (OC) on the Central
              Plains Experimental Range in Nunn, Colorado.</para>
          </description>
        </studyExtent>
        <samplingDescription>
          <para>There are six locations: ridgetop (ridge), midslope
            (M-slope), swale, ESA (replicate 1, control block), Section
            25 (SEC 25), and Owl Creek (OC).  Make sure all are done.
            Each location has 15 plots.  There are 3 transects with 5
            plots in each transect.  Plots in the grazed locations are
            protected by cages.  Chose a random direction and distance
            to move the cages for the LTNPP harvest next year and
            re-stake the cages.  Plots in the ungrazed locations are
            chosen randomly each year.   The 3 transects are marked by
            rebar.  Measure to the random location of the five plots
            along each transect.</para>
        </samplingDescription>
      </sampling>
    </methods>
    <project scope="document">
      <title>Shortgrass Steppe Long Term Ecological Research</title>
      <personnel id="1083870115619" scope="document">
        <individualName>
          <salutation>Dr.</salutation>
          <givenName>Eugene</givenName>
          <surName>Kelly</surName>
        </individualName>
        <organizationName>SGS-LTER</organizationName>
        <positionName>Lead Principal Investigator</positionName>
        <address scope="document">
          <deliveryPoint>Department of Soil and Crop Sciences</deliveryPoint>
          <deliveryPoint>Campus Delivery 1170</deliveryPoint>
          <city>Fort Collins</city>
          <administrativeArea>Colorado</administrativeArea>
          <postalCode>80523-1170</postalCode>
          <country>USA</country>
        </address>
        <phone phonetype="voice">(970)-491-4996</phone>
        <electronicMailAddress>Eugene.kelly@colostate.edu</electronicMailAddress>
        <role>Principal Investigator</role>
      </personnel>
      <funding>
        <para>NSF DB0217631</para>
      </funding>
    </project>
    <access authSystem="knb" order="denyFirst" scope="document">
      <allow>
        <principal>public</principal>
        <permission>read</permission>
      </allow>
      <allow>
        <principal>uid=bflynn,o=LTER,dc=ecoinformatics,dc=org</principal>
        <permission>all</permission>
      </allow>
      <allow>
        <principal>uid=nkaplan,o=LTER,dc=ecoinformatics,dc=org</principal>
        <permission>all</permission>
      </allow>
    </access>
    <dataTable id="1083881983324" scope="document">
      <entityName>2000_before_code_changes_sgs-npp.txt</entityName>
      <entityDescription />
      <physical id="1083881966650" scope="document">
        <objectName>2000_before_code_changes_sgs-npp.txt</objectName>
        <size unit="byte">11654</size>
        <dataFormat>
          <textFormat>
            <numHeaderLines>1</numHeaderLines>
            <recordDelimiter>#x0A</recordDelimiter>
            <attributeOrientation>column</attributeOrientation>
            <simpleDelimited>
              <fieldDelimiter>#x09</fieldDelimiter>
            </simpleDelimited>
          </textFormat>
        </dataFormat>
        <distribution scope="document">
          <online>
            <url function="download">ecogrid://knb/newsgs.5.1</url>
          </online>
        </distribution>
      </physical>
      <attributeList>
        <attribute id="1083881983334" scope="document">
          <attributeName>year</attributeName>
          <attributeDefinition>why am I providing this information again</attributeDefinition>
          <measurementScale>
            <datetime>
              <formatString>YYYY</formatString>
              <dateTimePrecision>y year</dateTimePrecision>
              <dateTimeDomain />
            </datetime>
          </measurementScale>
        </attribute>
        <attribute id="1083881983344" scope="document">
          <attributeName>SITE</attributeName>
          <attributeDefinition>why am I providing this information again</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <enumeratedDomain enforced="yes">
                  <codeDefinition>
                    <code>SEC25</code>
                    <definition>Section 25</definition>
                  </codeDefinition>
                  <codeDefinition>
                    <code>ESA</code>
                    <definition>ESA</definition>
                  </codeDefinition>
                  <codeDefinition>
                    <code>MIDSLOPE</code>
                    <definition>midslope</definition>
                  </codeDefinition>
                  <codeDefinition>
                    <code>OWL CREEK</code>
                    <definition>riparian area</definition>
                  </codeDefinition>
                  <codeDefinition>
                    <code>RIDGE</code>
                    <definition>ridge top</definition>
                  </codeDefinition>
                  <codeDefinition>
                    <code>SWALE</code>
                    <definition>swale, lowland</definition>
                  </codeDefinition>
                </enumeratedDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083881983354" scope="document">
          <attributeName>transect</attributeName>
          <attributeDefinition>why am I providing this information again</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <textDomain>
                  <definition>Transect</definition>
                </textDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083881983364" scope="document">
          <attributeName>plot</attributeName>
          <attributeDefinition>why am I providing this information again</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <textDomain>
                  <definition>Plot number</definition>
                </textDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083881983374" scope="document">
          <attributeName>species</attributeName>
          <attributeDefinition>codes relate to species-table-morpho data table</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <enumeratedDomain enforced="yes">
                  <entityCodeList>
                    <entityReference>1083884196206</entityReference>
                    <valueAttributeReference>1083884196266</valueAttributeReference>
                    <definitionAttributeReference>1083884196216</definitionAttributeReference>
                  </entityCodeList>
                </enumeratedDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083881983384" scope="document">
          <attributeName>weight</attributeName>
          <attributeDefinition>weight of each</attributeDefinition>
          <measurementScale>
            <ratio>
              <unit>
                <standardUnit>gram</standardUnit>
              </unit>
              <precision>.01</precision>
              <numericDomain>
                <numberType>real</numberType>
              </numericDomain>
            </ratio>
          </measurementScale>
        </attribute>
      </attributeList>
      <numberOfRecords>435</numberOfRecords>
    </dataTable>
    <dataTable id="1083884196206" scope="document">
      <entityName>species-table-morpho.txt</entityName>
      <entityDescription>genus amd species code for aboveground biomass
        data for 2000 at the SGS-LTER</entityDescription>
      <physical id="1083884194994" scope="document">
        <objectName>species-table-morpho.txt</objectName>
        <size unit="byte">3175</size>
        <dataFormat>
          <textFormat>
            <numHeaderLines>1</numHeaderLines>
            <recordDelimiter>#x0A</recordDelimiter>
            <attributeOrientation>column</attributeOrientation>
            <simpleDelimited>
              <fieldDelimiter>#x09</fieldDelimiter>
            </simpleDelimited>
          </textFormat>
        </dataFormat>
        <distribution scope="document">
          <online>
            <url function="download">ecogrid://knb/newsgs.9.1</url>
          </online>
        </distribution>
      </physical>
      <attributeList>
        <attribute id="1083884196216" scope="document">
          <attributeName>Genus species</attributeName>
          <attributeDefinition>Genus species</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <textDomain>
                  <definition>Genus species</definition>
                </textDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083884196226" scope="document">
          <attributeName>Genus</attributeName>
          <attributeDefinition>Genus</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <textDomain>
                  <definition>Genus</definition>
                </textDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083884196236" scope="document">
          <attributeName>species</attributeName>
          <attributeDefinition>species</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <textDomain>
                  <definition>species</definition>
                </textDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
        <attribute id="1083884196266" scope="document">
          <attributeName>code_name</attributeName>
          <attributeDefinition>first two letters of genus and first two
            letters of species</attributeDefinition>
          <measurementScale>
            <nominal>
              <nonNumericDomain>
                <textDomain>
                  <definition>first two letters of genus and first two
                    letters of species</definition>
                </textDomain>
              </nonNumericDomain>
            </nominal>
          </measurementScale>
        </attribute>
      </attributeList>
      <numberOfRecords>69</numberOfRecords>
    </dataTable>
  </dataset>
</ns0:eml>