text:
describe('base.js', function() {
  describe('Helper', function() {
    describe('isDefined', function() {
      it('`var a` should be defined only after `a = 1`.', function() {
        var a;
        expect(Helper.isDefined(a)).to.be.false;
        a = 1;
        expect(Helper.isDefined(a)).to.be.true;
      });
      it('`a.b` should be defined only after `a = {}; a.b = 1`.', function() {
        var a = {};
        expect(Helper.isDefined(a, 'b')).to.be.false;
        a.b = 1;
        expect(Helper.isDefined(a, 'b')).to.be.true;
      });
    });
  });
  describe('Class', function() {
    it('makes subClass instanceof SubClass and Class', function() {
      var SubClass = Class.extend({});
      var subClass = new SubClass();
      expect(subClass instanceof SubClass).to.be.true;
      expect(subClass instanceof Class).to.be.true;
    });
  });
  describe('Model', function() {
    it('should give new instance an uniq id', function() {
      var SmapleModel = Model.extend({});
      var m1 = new SmapleModel();
      var m2 = new SmapleModel();
      var m3 = new SmapleModel();
      expect(m1.mId).to.equal(1);
      expect(m2.mId).to.equal(2);
      expect(m3.mId).to.equal(3);
    });
    describe('initView', function() {
      it('should render dom in body by default', function() {
        var SmapleModel = Model.extend({
          'template': '
Sample Model
'
        });
        var model = new SmapleModel();
        model.render();
        expect($('.sample-model').size()).equal(1);

        model.m$dom.remove();
      });
      it('should avoid duplicated rendering', function() {
        var SmapleModel = Model.extend({
          'template': '
Sample Model
'
        });
        var model = new SmapleModel();
        var spy = sinon.spy(model, 'initView');

        model.render();
        model.render();
        expect($('.sample-model').size()).equal(1);
        expect(spy.calledOnce).to.be.true;

        model.m$dom.remove();
      });
    });
    describe('initDataBindings', function() {
      describe('parseBindings', function() {
        it('should return a list of triplet', function() {
          var SmapleModel = Model.extend({
            'defaults': {
              'a': 'a',
              'b': 'b',
              'c': 'c'
            },
            'template': '\

 foo">\

 bar, c => baz"\

'
          });
          var model = new SmapleModel();
          var spy = sinon.spy(model, 'parseBindings');
          model.render();
          var bindings = spy.returnValues[0];
          expect(bindings.length).to.equal(3);
          expect(bindings[0].from).to.equal('a');
          expect(bindings[0].to).to.equal('foo');
          expect(bindings[2].from).to.equal('c');
          expect(bindings[2].to).to.equal('baz');
          model.m$dom.remove();
        });
      });
      it('should register state changes for updating dom', function() {
        var SmapleModel = Model.extend({
          'defaults': {
            's1': '',
            's2': '',
            's3': true,
            's4': false,
            's5': 'xxx',
          },
          'template': '\

\

html">
\

text">
\
            <input class="elem-3" data-bind="s5=>val">\

class--foo">
\

class--foo">
\

hidden">
\

hidden" hidden>
\

data-id">
\
            <input type="checkbox" class="elem-9" data-bind="s3=>checked">\
            <input type="checkbox" class="elem-10" data-bind="s4=>checked" checked>\

'
        });
        var model = new SmapleModel();
        model.render();
        expect($('.elem-1').html()).to.equal('');
        expect($('.elem-2').text()).to.equal('');
        expect($('.elem-3').val()).to.equal('xxx');
        expect($('.elem-4').is('.foo')).to.be.true;
        expect($('.elem-5').is('.foo')).to.be.false;
        expect($('.elem-6').is('[hidden]')).to.be.true;
        expect($('.elem-7').is('[hidden]')).to.be.false;
        expect($('.elem-8').is('[data-id="xxx"]')).to.be.true;
        expect($('.elem-9').is(':checked')).to.be.true;
        expect($('.elem-10').is(':checked')).to.be.false;

        model.m$dom.remove();
      });
      it('should bind dom change to states', function() {
        var SmapleModel = Model.extend({
          'defaults': {
            's1': '',
            's2': '',
            's3': true,
            's4': false,
            's5': 'xxx',
          },
          'template': '\

\
            <input class="elem-3" data-bind="s5=>val">\
            <input type="checkbox" class="elem-9" data-bind="s4=>checked">\

'
        });
        var model = new SmapleModel();
        model.render();
        $('.elem-3').val('yyy').trigger('change');
        expect(model.mStates.s5).to.equal('yyy');
        $('.elem-9').trigger('click');
        expect($('.elem-9').is(':checked')).to.be.true;
        $('.elem-9').trigger('click');
        expect($('.elem-9').is(':checked')).to.be.false;

        model.m$dom.remove();
      });
    });
    describe('initEventBindings', function() {
      it('should call handler with target model if control-UI event triggered',
      function() {
        var SmapleModel = Model.extend({
          'defaults': {
            'a': '1',
            'b': '2',
            'c': '3',
            'log': 'init'
          },
          'template': '\

 logA"\
            style="border: 1px solid black">\

 html" event-bind="click => logB">
\
            <input id="c" data-bind="c => val" event-bind="blur => logC">\

 text">
\

',
          handlers: {
            'logA': function(model) { this.change('log', 'A'); },
            'logB': function(model) { this.change('log', model.get('b')); },
            'logC': function(model) { this.change('log', 'C'); },
          }
        });
        var model = new SmapleModel();
        model.render();
        $('#a').trigger('mouseenter');
        expect($('#log').text()).to.equal('A');
        $('#b').trigger('click');
        expect($('#log').text()).to.equal('2');
        $('#c').trigger('blur');
        expect($('#log').text()).to.equal('C');
        model.m$dom.remove();
      });
    });
    describe('initEventBindings', function() {
      it('should toggle state if handler matches with a state name',
      function() {
        var SmapleModel = Model.extend({
          'defaults': {
            'a': true
          },
          'template': '\

\

 a">x
\

 text">
\

'
        });
        var model = new SmapleModel();
        model.render();
        $('#a').trigger('click');
        expect($('#log').text()).to.equal('false');
        model.m$dom.remove();
      });
    });
    describe('initStates', function() {
      it('should update the state by input. but ignore unrecognized ones', function() {
        var SmapleModel = Model.extend({
          'defaults': {
            'txt': 'default text'
          }
        });
        var model = new SmapleModel();
        model.render({'txt': 'hi there!', 'foo': 'unexpected state'});
        expect(model.mStates).to.not.have.ownProperty('foo');
        expect(model.mStates.txt).to.equal('hi there!');
        model.m$dom.remove();
      });
    });
    describe('statesDeps', function() {
      it('should reflect consumer state if provider state changed', function() {
        var SampleModel = Model.extend({
          'defaults': {
            'msg': '',
            'len': function() {
              return this.get('msg').length;
            }
          },
          'template': '\

\
              message: <input class="user-input" data-bind="msg=>val">\
              message length:text">\

\
          '
        });
        var model = new SampleModel();
        model.render();
        $('.user-input').val('123').trigger('change');
        expect(model.get('len')).to.equal(3);
        $('.user-input').val('1234').trigger('change');
        expect(model.get('len')).to.equal(4);
        model.m$dom.remove();
      });
      it('should avoid looping', function() {
        var SampleModel = Model.extend({
          'defaults': {
            'b': function() {
              return this.get('c');
            },
            'c': function() {
              return this.get('b');
            }
          },
          'template': '\

\
          '
        });
        var model = new SampleModel();
        var spy = sinon.spy(model, 'initStateDeps');
        model.render();
        expect(spy.returnValues[0]).to.be.false;
        model.m$dom.remove();
      });
    });
  });
  describe('Colleciton', function() {
    it('should render dom properly', function() {
      var SampleCollection = Collection.extend({
        'defaults': {
          'txt': ''
        },
        'template': '
 html">
'
      });
      var SampleModule = Model.extend({
        'defaults': {
          'title': function() {
            return 'got ' + this.get('listing').size() + ' listing items';
          },
          'listing': new SampleCollection()
        },
        'template': '\

\

 html">
\

 inner" style="border: 1px solid black">\

'
      });

      var model = new SampleModule();
      model.render();
      expect($('.sample-module').find('ul li').length).to.be.equal(0);
      model.change('listing', function(collection) {
        collection.add({txt: 'item1'});
      });
      expect($('.sample-module').find('ul li').length).to.be.equal(1);
      expect($('.sample-module').find('ul li').html()).to.be.equal('item1');
      model.change('listing', function(collection) {
        collection.change(0, 'txt', 'item x');
      });
      expect($('.sample-module').find('ul li').html()).to.be.equal('item x');

      model.m$dom.remove();
    });
    it('should bind event properly', function() {
      var SampleCollection = Collection.extend({
        'defaults': {
          'isChecked': false,
          'message': function() {
            return this.get('isChecked') ? 'yes' : 'no';
          },
          'log': ''
        },
        'template': '
\

 text"\
               event-bind="click => isChecked,\
               mouseenter => logMe"\
               ">
\
           html">\

',
        handlers: {
          'logMe': function(item, idx) {
            item.change('log', 'mouse enter model id: ' + item.mId);
          }
        }
      });
      var SampleModule2 = Model.extend({
        'defaults': {
          'listing': new SampleCollection()
        },
        'template': '\

\

 inner" style="border: 1px solid black">\

'
      });

      var model = new SampleModule2();
      model.render();
      model.change('listing', function(collection) {
        collection.add({isChecked: true});
        collection.add({isChecked: false});
      });
      $('.sample-module li:first-child>div').trigger('mouseenter');
      var log = $('.sample-module li:first-child').find('.log').text();
      expect(log).to.equal('mouse enter model id: 2');
      model.m$dom.remove();
    });
  });
});


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

   <stroke
       android:width="1dp"
       android:color="@color/_4d4d4d"/>
	<solid
	    android:color="@color/light_grey_color"/>
   <size
       android:width="55dp"
        android:height="55dp"/>
</shape>

redpajama_set_name: RedPajamaGithub


text:
import { required, RequiredParams } from '../required';
import { FieldValidationResult } from '../../entities';

describe('[required] validation rule tests =>', () => {
  describe('When validating a non string value', () => {
    it('should return false if value is null', () => {
      // Arrange
      const value = null;
      const vm = undefined;
      const customParams: RequiredParams = undefined;

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.false;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.equals('Please fill in this mandatory field.');
    });

    it('should return false if value is undefined', () => {
      // Arrange
      const value = undefined;
      const vm = undefined;
      const customParams: RequiredParams = undefined;

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.false;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.equals('Please fill in this mandatory field.');
    });

    it('should return false if value is false', () => {
      // Arrange
      const value = false;
      const vm = undefined;
      const customParams: RequiredParams = undefined;

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.false;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.equals('Please fill in this mandatory field.');
    });

    it('should return true if value is true', () => {
      // Arrange
      const value = true;
      const vm = undefined;
      const customParams: RequiredParams = undefined;

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.true;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.empty;
    });

  });

  describe('When validating a string value', () => {
    it('should return false if string is empty', () => {
      // Arrange
      const value = '';
      const vm = undefined;
      const customParams: RequiredParams = undefined;

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.false;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.equals('Please fill in this mandatory field.');
    });

    it('should return true if string has whitespace characters and trim option is false', () => {
      // Arrange
      const value = ' ';
      const vm = undefined;
      const customParams: RequiredParams = { trim: false };

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.true;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.empty;
    });

    it('should return true if string has whitespace characters and trim option is null', () => {
      // Arrange
      const value = ' ';
      const vm = undefined;
      const customParams: RequiredParams = { trim: null };

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.true;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.empty;
    });

    it('should return true if string has whitespace characters and trim option is undefined', () => {
      // Arrange
      const value = ' ';
      const vm = undefined;
      const customParams: RequiredParams = { trim: undefined };

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.true;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.empty;
    });

    it('should return false if string has whitespace characters and trim option is true', () => {
      // Arrange
      const value = ' ';
      const vm = undefined;
      const customParams: RequiredParams = { trim: true };

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.false;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.equals('Please fill in this mandatory field.');
    });

    it('should trim by default', () => {
      // Arrange
      const value = ' ';
      const vm = undefined;
      const customParams = undefined;

      // Act
      const validationResult = required(value, vm, customParams) as FieldValidationResult;

      // Assert
      expect(validationResult.succeeded).to.be.false;
      expect(validationResult.type).to.be.equals('REQUIRED');
      expect(validationResult.errorMessage).to.be.equals('Please fill in this mandatory field.');
    });
  });
});


text:
package com.amazonaws.services.sagemakerruntime;

import javax.annotation.Generated;

import com.amazonaws.services.sagemakerruntime.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;

import java.util.concurrent.ExecutorService;

/**
 * Client for accessing Amazon SageMaker Runtime asynchronously. Each asynchronous method will return a Java Future
 * object representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
 * notification when an asynchronous operation completes.
 *

 *

 * The Amazon SageMaker runtime API.
 *

 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonSageMakerRuntimeAsyncClient extends AmazonSageMakerRuntimeClient implements AmazonSageMakerRuntimeAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

    public static AmazonSageMakerRuntimeAsyncClientBuilder asyncBuilder() {
        return AmazonSageMakerRuntimeAsyncClientBuilder.standard();
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon SageMaker Runtime using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     */
    AmazonSageMakerRuntimeAsyncClient(AwsAsyncClientParams asyncClientParams) {
        this(asyncClientParams, false);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon SageMaker Runtime using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AmazonSageMakerRuntimeAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
        super(asyncClientParams, endpointDiscoveryEnabled);
        this.executorService = asyncClientParams.getExecutor();
    }

    /**
     * Returns the executor service used by this client to execute async requests.
     *
     * @return The executor service used by this client to execute async requests.
     */
    public ExecutorService getExecutorService() {
        return executorService;
    }

    @Override
    public java.util.concurrent.Future<InvokeEndpointResult> invokeEndpointAsync(InvokeEndpointRequest request) {

        return invokeEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<InvokeEndpointResult> invokeEndpointAsync(final InvokeEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler<InvokeEndpointRequest, InvokeEndpointResult> asyncHandler) {
        final InvokeEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable<InvokeEndpointResult>() {
            @Override
            public InvokeEndpointResult call() throws Exception {
                InvokeEndpointResult result = null;

                try {
                    result = executeInvokeEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future<InvokeEndpointAsyncResult> invokeEndpointAsyncAsync(InvokeEndpointAsyncRequest request) {

        return invokeEndpointAsyncAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future<InvokeEndpointAsyncResult> invokeEndpointAsyncAsync(final InvokeEndpointAsyncRequest request,
            final com.amazonaws.handlers.AsyncHandler<InvokeEndpointAsyncRequest, InvokeEndpointAsyncResult> asyncHandler) {
        final InvokeEndpointAsyncRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable<InvokeEndpointAsyncResult>() {
            @Override
            public InvokeEndpointAsyncResult call() throws Exception {
                InvokeEndpointAsyncResult result = null;

                try {
                    result = executeInvokeEndpointAsync(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
     * asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
     * call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
     * calling this method.
     */
    @Override
    public void shutdown() {
        super.shutdown();
        executorService.shutdownNow();
    }
}


text:
{-# LANGUAGE OverloadedStrings #-}

module Moz.Auth
  ( Auth(..)
  , expires
  , signature
  ) where

import qualified Data.ByteString as BS
import qualified Data.ByteString.Base64 as B64
import qualified Data.ByteString.Char8 as C8

import Crypto.Hash.SHA1 (hash)
import Crypto.MAC.HMAC (hmac)

import Data.Time.Clock (UTCTime, addUTCTime)
import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds)

data Auth = Auth { accessId :: BS.ByteString
                 , secretKey :: BS.ByteString
                 } deriving (Show)

toSeconds :: UTCTime -> Integer
toSeconds = round . utcTimeToPOSIXSeconds

expires :: UTCTime -> BS.ByteString
expires = C8.pack . show . toSeconds . addUTCTime 300

signature :: Auth -> UTCTime -> BS.ByteString
signature auth time = B64.encode . sign $ BS.intercalate "\n" [accessId auth, expires time]
  where sign = hmac hash 64 (secretKey auth)


text:
package scalarank.ranker

import scala.reflect.ClassTag
import scalarank.datapoint.{Datapoint, Query, Relevance}

/**
  * Ranks documents perfectly but requires relevance labels to be known during ranking
  *
  * @tparam T Type to train on and rank with which needs to be at least Datapoint with Relevance
  */
class OracleRanker[T <: Datapoint with Relevance : ClassTag] extends Ranker[T, T] {

  /**
    * Trains the ranker on a set of labeled data points
    *
    * @param data The set of labeled data points
    */
  override def train(data: Iterable[Query[T]]): Unit = {  }

  /**
    * Ranks given set of data points
    *
    * @param data The set of data points
    * @return An ordered list of data points
    */
  override def score(data: IndexedSeq[T]): IndexedSeq[Double] = {
    val maximum = data.map(d => d.relevance).max
    data.map(d => maximum - d.relevance)
  }

}


text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

//
// This source code was auto-generated by xsd, Version=4.6.1055.0.
//
//There is a bug with the xsd.exe tool where the notes field of the patchType class is generated with type textType[][] instead of textType[] and this must be changed manually.
namespace CWEBot.Models {
    using System.Xml.Serialization;

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://scap.nist.gov/schema/feed/vulnerability/2.0")]
    [System.Xml.Serialization.XmlRootAttribute(Namespace="http://scap.nist.gov/schema/feed/vulnerability/2.0", IsNullable=false)]
    public partial class nvd {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("entry", Order=0)]
        public vulnerabilityType[] entry;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public decimal nvd_xml_version;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public System.DateTime pub_date;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    [System.Xml.Serialization.XmlRootAttribute("entry", Namespace="http://scap.nist.gov/schema/feed/vulnerability/2.0", IsNullable=false)]
    public partial class vulnerabilityType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("osvdb-ext", Order=0)]
        public osvdbExtensionType osvdbext;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("vulnerable-configuration", Order=1)]
        public PlatformType[] vulnerableconfiguration;

        /// <remarks/>
        [System.Xml.Serialization.XmlArrayAttribute("vulnerable-software-list", Order=2)]
        [System.Xml.Serialization.XmlArrayItemAttribute("product", DataType="anyURI", IsNullable=false)]
        public string[] vulnerablesoftwarelist;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("cce-id", typeof(string), DataType="token", Order=3)]
        [System.Xml.Serialization.XmlElementAttribute("cve-id", typeof(string), DataType="token", Order=3)]
        [System.Xml.Serialization.XmlChoiceIdentifierAttribute("ItemElementName")]
        public string Item;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=4)]
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public ItemChoiceType ItemElementName;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("discovered-datetime", Order=5)]
        public System.DateTime discovereddatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool discovereddatetimeSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("disclosure-datetime", Order=6)]
        public System.DateTime disclosuredatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool disclosuredatetimeSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("exploit-publish-datetime", Order=7)]
        public System.DateTime exploitpublishdatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool exploitpublishdatetimeSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("published-datetime", Order=8)]
        public System.DateTime publisheddatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool publisheddatetimeSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("last-modified-datetime", Order=9)]
        public System.DateTime lastmodifieddatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool lastmodifieddatetimeSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=10)]
        public cvssImpactType cvss;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("security-protection", Order=11)]
        public securityProtectionType securityprotection;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool securityprotectionSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("assessment_check", Order=12)]
        public checkReferenceType[] assessment_check;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("cwe", Order=13)]
        public cweReferenceType[] cwe;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("references", Order=14)]
        public vulnerabilityReferenceType[] references;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("fix_action", Order=15)]
        public fixActionType[] fix_action;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("scanner", Order=16)]
        public toolConfigurationType[] scanner;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=17)]
        public string summary;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("technical_description", Order=18)]
        public referenceType[] technical_description;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("attack_scenario", Order=19)]
        public referenceType[] attack_scenario;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
        public string id;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public partial class osvdbExtensionType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("exploit-location", Order=0)]
        public associatedExploitLocationType exploitlocation;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public partial class associatedExploitLocationType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("physical-access", Order=0)]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool physicalaccess;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("voluntarily-interact", Order=1)]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool voluntarilyinteract;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=2)]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool dialup;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=3)]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool unknown;

        public associatedExploitLocationType() {
            this.physicalaccess = false;
            this.voluntarilyinteract = false;
            this.dialup = false;
            this.unknown = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public partial class toolConfigurationType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(DataType="anyURI", Order=0)]
        public string name;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("definition", Order=1)]
        public checkReferenceType[] definition;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/scap-core/0.1")]
    public partial class checkReferenceType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="anyURI")]
        public string system;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="anyURI")]
        public string href;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
        public string name;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/patch/0.1")]
    [System.Xml.Serialization.XmlRootAttribute("patch", Namespace="http://scap.nist.gov/schema/patch/0.1", IsNullable=false)]
    public partial class patchType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=0)]
        public textType title;

        /// <remarks/>
        [System.Xml.Serialization.XmlArrayAttribute(Order=1)]
        [System.Xml.Serialization.XmlArrayItemAttribute("reference", IsNullable=false)]
        public referenceType[] references;

        /// <remarks/>
        [System.Xml.Serialization.XmlArrayAttribute(Order=2)]
        [System.Xml.Serialization.XmlArrayItemAttribute("note", typeof(textType), Namespace="http://scap.nist.gov/schema/scap-core/0.1", IsNullable=false)]
        public textType[] notes;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("check", Order=3)]
        public checkReferenceType[] check;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("supersedes", Order=4)]
        public patchType[] supersedes;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("superseded-by", Order=5)]
        public patchType[] supersededby;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public double identifier;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public string name;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public bool superseded;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public bool deprecated;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool deprecatedSpecified;
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlIncludeAttribute(typeof(referenceType))]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/scap-core/0.1")]
    public partial class textType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/XML/1998/namespace")]
        public string lang;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public string Value;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/scap-core/0.1")]
    public partial class referenceType : textType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="anyURI")]
        public string href;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public partial class fixActionType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Namespace="http://scap.nist.gov/schema/patch/0.1", Order=0)]
        public patchType patch;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("configuration-remediation", Order=1)]
        public vulnerabilityReferenceType configurationremediation;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("software-update", DataType="anyURI", Order=2)]
        public string[] softwareupdate;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("notes", Order=3)]
        public string[] notes;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("deprecated-by", DataType="anyURI", Order=4)]
        public string[] deprecatedby;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("next-fix-action", Order=5)]
        public fixActionType[] nextfixaction;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("fix-action-tool-configuration", Order=6)]
        public toolConfigurationType[] fixactiontoolconfiguration;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("applicable-configuration", Order=7)]
        public PlatformType[] applicableconfiguration;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=8)]
        public fixEffectivenessEnumType effectiveness;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool effectivenessSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("applicable-check", Order=9)]
        public checkReferenceType[] applicablecheck;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public fixActionDescriptionEnumType fix_action_description;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public fixActionTypeEnumType fix_action_type;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
        public string id;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="anyURI")]
        public string source;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public partial class vulnerabilityReferenceType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=0)]
        public string source;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=1)]
        public referenceType reference;

        /// <remarks/>
        [System.Xml.Serialization.XmlArrayAttribute(Order=2)]
        [System.Xml.Serialization.XmlArrayItemAttribute("note", Namespace="http://scap.nist.gov/schema/scap-core/0.1", IsNullable=false)]
        public textType[] notes;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/XML/1998/namespace")]
        public string lang;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public vulnerabilityReferenceCategoryEnumType reference_type;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public bool deprecated;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool deprecatedSpecified;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public enum vulnerabilityReferenceCategoryEnumType {

        /// <remarks/>
        PATCH,

        /// <remarks/>
        VENDOR_ADVISORY,

        /// <remarks/>
        THIRD_PARTY_ADVISORY,

        /// <remarks/>
        SIGNATURE_SOURCE,

        /// <remarks/>
        MITIGATION_PROCEDURE,

        /// <remarks/>
        TOOL_CONFIGURATION_DESCRIPTION,

        /// <remarks/>
        UNKNOWN,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://cpe.mitre.org/language/2.0")]
    public partial class PlatformType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("title", Order=0)]
        public TextType[] title;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("remark", Order=1)]
        public TextType[] remark;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("logical-test", Order=2)]
        public LogicalTestType logicaltest;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="anyURI")]
        public string id;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://cpe.mitre.org/language/2.0")]
    public partial class TextType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(Form=System.Xml.Schema.XmlSchemaForm.Qualified, Namespace="http://www.w3.org/XML/1998/namespace")]
        public string lang;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public string Value;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://cpe.mitre.org/language/2.0")]
    [System.Xml.Serialization.XmlRootAttribute("logical-test", Namespace="http://cpe.mitre.org/language/2.0", IsNullable=false)]
    public partial class LogicalTestType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("logical-test", Order=0)]
        public LogicalTestType[] logicaltest;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("fact-ref", Order=1)]
        public FactRefType[] factref;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public operatorEnumeration @operator;

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public bool negate;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://cpe.mitre.org/language/2.0")]
    public partial class FactRefType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="anyURI")]
        public string name;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://cpe.mitre.org/language/2.0")]
    public enum operatorEnumeration {

        /// <remarks/>
        AND,

        /// <remarks/>
        OR,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public enum fixEffectivenessEnumType {

        /// <remarks/>
        PARTIAL,

        /// <remarks/>
        COMPLETE,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public enum fixActionDescriptionEnumType {

        /// <remarks/>
        PATCH,

        /// <remarks/>
        SOFTWARE_UPDATE,

        /// <remarks/>
        CONFIGURATION_CHANGE,

        /// <remarks/>
        POLICY_CHANGE,

        /// <remarks/>
        EXTERNAL_MITIGATION,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public enum fixActionTypeEnumType {

        /// <remarks/>
        MITIGATION,

        /// <remarks/>
        REMEDIATION,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public partial class cweReferenceType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute(DataType="token")]
        public string id;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class confidenceType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public confidenceEnumType Value;

        public confidenceType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum confidenceEnumType {

        /// <remarks/>
        UNCONFIRMED,

        /// <remarks/>
        UNCORROBORATED,

        /// <remarks/>
        CONFIRMED,

        /// <remarks/>
        NOT_DEFINED,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class remediationLevelType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public remediationLevelEnumType Value;

        public remediationLevelType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum remediationLevelEnumType {

        /// <remarks/>
        OFFICIAL_FIX,

        /// <remarks/>
        TEMPORARY_FIX,

        /// <remarks/>
        WORKAROUND,

        /// <remarks/>
        UNAVAILABLE,

        /// <remarks/>
        NOT_DEFINED,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class exploitabilityType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public exploitabilityEnumType Value;

        public exploitabilityType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum exploitabilityEnumType {

        /// <remarks/>
        UNPROVEN,

        /// <remarks/>
        PROOF_OF_CONCEPT,

        /// <remarks/>
        FUNCTIONAL,

        /// <remarks/>
        HIGH,

        /// <remarks/>
        NOT_DEFINED,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class ciaRequirementType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public ciaRequirementEnumType Value;

        public ciaRequirementType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum ciaRequirementEnumType {

        /// <remarks/>
        LOW,

        /// <remarks/>
        MEDIUM,

        /// <remarks/>
        HIGH,

        /// <remarks/>
        NOT_DEFINED,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class targetDistributionType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public targetDistributionEnumType Value;

        public targetDistributionType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum targetDistributionEnumType {

        /// <remarks/>
        NONE,

        /// <remarks/>
        LOW,

        /// <remarks/>
        MEDIUM,

        /// <remarks/>
        HIGH,

        /// <remarks/>
        NOT_DEFINED,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class collateralDamagePotentialType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public collateralDamagePotentialEnumType Value;

        public collateralDamagePotentialType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum collateralDamagePotentialEnumType {

        /// <remarks/>
        NONE,

        /// <remarks/>
        LOW,

        /// <remarks/>
        LOW_MEDIUM,

        /// <remarks/>
        MEDIUM_HIGH,

        /// <remarks/>
        HIGH,

        /// <remarks/>
        NOT_DEFINED,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class ciaType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public ciaEnumType Value;

        public ciaType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum ciaEnumType {

        /// <remarks/>
        NONE,

        /// <remarks/>
        PARTIAL,

        /// <remarks/>
        COMPLETE,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class authenticationType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public authenticationEnumType Value;

        public authenticationType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum authenticationEnumType {

        /// <remarks/>
        MULTIPLE_INSTANCES,

        /// <remarks/>
        SINGLE_INSTANCE,

        /// <remarks/>
        NONE,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class accessComplexityType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public accessComplexityEnumType Value;

        public accessComplexityType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum accessComplexityEnumType {

        /// <remarks/>
        HIGH,

        /// <remarks/>
        MEDIUM,

        /// <remarks/>
        LOW,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class accessVectorType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        [System.ComponentModel.DefaultValueAttribute(false)]
        public bool approximated;

        /// <remarks/>
        [System.Xml.Serialization.XmlTextAttribute()]
        public accessVectorEnumType Value;

        public accessVectorType() {
            this.approximated = false;
        }
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public enum accessVectorEnumType {

        /// <remarks/>
        LOCAL,

        /// <remarks/>
        ADJACENT_NETWORK,

        /// <remarks/>
        NETWORK,
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlIncludeAttribute(typeof(temporalMetricsType))]
    [System.Xml.Serialization.XmlIncludeAttribute(typeof(environmentalMetricsType))]
    [System.Xml.Serialization.XmlIncludeAttribute(typeof(baseMetricsType))]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public abstract partial class metricsType {

        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute("upgraded-from-version")]
        public decimal upgradedfromversion;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool upgradedfromversionSpecified;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class temporalMetricsType : metricsType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=0)]
        public decimal score;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool scoreSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("temporal-multiplier", Order=1)]
        public decimal temporalmultiplier;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool temporalmultiplierSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=2)]
        public exploitabilityType exploitability;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("remediation-level", Order=3)]
        public remediationLevelType remediationlevel;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("report-confidence", Order=4)]
        public confidenceType reportconfidence;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(DataType="anyURI", Order=5)]
        public string source;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("generated-on-datetime", Order=6)]
        public System.DateTime generatedondatetime;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class environmentalMetricsType : metricsType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=0)]
        public decimal score;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool scoreSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("collateral-damage-potential", Order=1)]
        public collateralDamagePotentialType collateraldamagepotential;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("target-distribution", Order=2)]
        public targetDistributionType targetdistribution;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("confidentiality-requirement", Order=3)]
        public ciaRequirementType confidentialityrequirement;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("integrity-requirement", Order=4)]
        public ciaRequirementType integrityrequirement;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("availability-requirement", Order=5)]
        public ciaRequirementType availabilityrequirement;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(DataType="anyURI", Order=6)]
        public string source;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("generated-on-datetime", Order=7)]
        public System.DateTime generatedondatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool generatedondatetimeSpecified;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class baseMetricsType : metricsType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=0)]
        public decimal score;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool scoreSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("exploit-subscore", Order=1)]
        public decimal exploitsubscore;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool exploitsubscoreSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("impact-subscore", Order=2)]
        public decimal impactsubscore;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool impactsubscoreSpecified;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("access-vector", Order=3)]
        public accessVectorType accessvector;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("access-complexity", Order=4)]
        public accessComplexityType accesscomplexity;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Order=5)]
        public authenticationType authentication;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("confidentiality-impact", Order=6)]
        public ciaType confidentialityimpact;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("integrity-impact", Order=7)]
        public ciaType integrityimpact;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("availability-impact", Order=8)]
        public ciaType availabilityimpact;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(DataType="anyURI", Order=9)]
        public string source;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("generated-on-datetime", Order=10)]
        public System.DateTime generatedondatetime;

        /// <remarks/>
        [System.Xml.Serialization.XmlIgnoreAttribute()]
        public bool generatedondatetimeSpecified;
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlIncludeAttribute(typeof(cvssImpactType))]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class cvssType {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("base_metrics", Order=0)]
        public baseMetricsType[] base_metrics;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("environmental_metrics", Order=1)]
        public environmentalMetricsType[] environmental_metrics;

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("temporal_metrics", Order=2)]
        public temporalMetricsType[] temporal_metrics;
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/cvss-v2/0.2")]
    public partial class cvssImpactType : cvssType {
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4", IncludeInSchema=false)]
    public enum ItemChoiceType {

        /// <remarks/>
        [System.Xml.Serialization.XmlEnumAttribute("cce-id")]
        cceid,

        /// <remarks/>
        [System.Xml.Serialization.XmlEnumAttribute("cve-id")]
        cveid,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://scap.nist.gov/schema/vulnerability/0.4")]
    public enum securityProtectionType {

        /// <remarks/>
        ALLOWS_ADMIN_ACCESS,

        /// <remarks/>
        ALLOWS_USER_ACCESS,

        /// <remarks/>
        ALLOWS_OTHER_ACCESS,
    }

    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "4.6.1055.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true, Namespace="http://cpe.mitre.org/language/2.0")]
    [System.Xml.Serialization.XmlRootAttribute("platform-specification", Namespace="http://cpe.mitre.org/language/2.0", IsNullable=false)]
    public partial class platformspecification {

        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("platform", Order=0)]
        public PlatformType[] platform;
    }
}


text:
sap.ui.jsview("espm-ui-reviews-web.main", {

	getControllerName : function() {
		return "espm-ui-reviews-web.main";
	},

	createContent : function(oController) {

		var oView = sap.app.viewCache.get("reviews");

		if (sap.app.config.displayShell) {
			var oShell = new sap.ui.ux3.Shell({
				id : oController.createId("shell-id"),
				appTitle : "{i18n>SHELL_HEADER_TITLE}",
				showLogoutButton : true,
				showSearchTool : false,
				showFeederTool : false,
				showTools : true,
				showPane : true,
				paneWidth : 500,
				worksetItems : [ new sap.ui.ux3.NavigationItem({
					id : "nav-customer-reviews-id",
					text : "{i18n>SHELL_WORKSET_ITEM_CUSTOMER_REVIEWS}"
				}) ]
			});

			var oSettingsButton = new sap.ui.commons.Button({
				id : oController.createId("settings-button-id"),
				text : "{i18n>SHELL_HEADER_ITEM_SETTINGS_TEXT}",
				tooltip : "{i18n>SHELL_HEADER_ITEM_SETTINGS_TOOLTIP}",
				press : function(oEvent) {
					oController.openSettingsDialog();
				}
			});
			oShell.addHeaderItem(oSettingsButton);
			oShell.addContent(oView);
			return oShell;
		} else {
			// only display view (w/o shell)
			return oView;
		}
	},
});


text:
#pragma once

#include "cppan_string.h"
#include "filesystem.h"

#include <primitives/hash_combine.h>

#define LOCAL_VERSION_NAME "local"

using ProjectId = uint64_t;
using ProjectVersionId = uint64_t;
using ProjectVersionNumber = int32_t;

enum class VersionType
{
    Any,
    Equal,
    Version,
    Branch,
};

struct Version
{
    // undef gcc symbols
#ifdef major
#undef major
#endif
#ifdef minor
#undef minor
#endif
#ifdef patch
#undef patch
#endif

    ProjectVersionNumber major = -1;
    ProjectVersionNumber minor = -1;
    ProjectVersionNumber patch = -1;
    String branch;
    VersionType type{ VersionType::Any };

    Version(ProjectVersionNumber ma = -1, ProjectVersionNumber mi = -1, ProjectVersionNumber pa = -1);
    Version(const String &s);

    String toAnyVersion() const;
    String toString() const;
    path toPath() const;

    bool isValid() const;
    bool isBranch() const;
    bool isVersion() const;

    // checks if this version can be rhs using upgrade rules
    // does not check branches!
    // rhs should be exact version
    bool canBe(const Version &rhs) const;

    bool operator<(const Version &rhs) const;
    bool operator==(const Version &rhs) const;
    bool operator!=(const Version &rhs) const;

    static bool check_branch_name(const String &n, String *error = nullptr);
};

namespace std
{

template<> struct hash<Version>
{
    size_t operator()(const Version& v) const
    {
        if (!v.branch.empty())
            return std::hash<String>()(v.branch);
        size_t h = 0;
        hash_combine(h, v.major);
        hash_combine(h, v.minor);
        hash_combine(h, v.patch);
        return h;
    }
};

}


text:
package fi.jarimatti.demo.paxexam.service.itest;

import fi.jarimatti.demo.paxexam.service.api.HelloWorld;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.ops4j.pax.exam.Configuration;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
import org.ops4j.pax.exam.options.MavenArtifactUrlReference;
import org.ops4j.pax.exam.options.MavenUrlReference;

import javax.inject.Inject;

import java.io.File;

import static org.junit.Assert.assertEquals;
import static org.ops4j.pax.exam.CoreOptions.*;
import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.features;
import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.karafDistributionConfiguration;
import static org.ops4j.pax.exam.karaf.options.KarafDistributionOption.keepRuntimeFolder;

/**
 *Test HelloWorld service in Karaf.
 */
@RunWith(PaxExam.class)
public class HelloWorldIntegrationTest {

    @Inject
    private HelloWorld helloWorld;

    @Configuration
    public Option[] config() {
        MavenArtifactUrlReference karafUrl = maven()
                .groupId("org.apache.karaf")
                .artifactId("apache-karaf")
                .version("4.0.3")
                .type("tar.gz");
        MavenUrlReference karafStandardRepo = maven()
                .groupId("org.apache.karaf.features")
                .artifactId("standard")
                .classifier("features")
                .type("xml")
                .version("4.0.3");
        return new Option[]{
                karafDistributionConfiguration()
                        .frameworkUrl(karafUrl)
                        .unpackDirectory(new File("build/exam"))
                        .useDeployFolder(false),
                // keepRuntimeFolder(),
                features(karafStandardRepo, "scr"),
                bundle(new File("../service/build/libs/service-0.0.1-SNAPSHOT.jar").toURI().toString()),
                junitBundles()
        };
    }

    @Test
    public void testGreet() {
        assertEquals("Hello, World!", helloWorld.greet());
    }

    @Test
    public void testGreetWithName() {
        assertEquals("Hello, Paavo!", helloWorld.greet("Paavo"));
    }
}


text:
jQuery(document).ready(function($){
	$('.dropcapText').each(function(index,element) {

		var dropcapped_letter = $(element).text().charAt(0).slice(0);
		var custom_css = $(element).attr('style');
		$(element).text($(element).text().substring(1));
		$(element).prepend(''+dropcapped_letter+'');
	});
	$('.dropcapLight').each(function(index,element) {
		var dropcapped_letter = $(element).text().charAt(0).slice(0);
		$(element).text($(element).text().substring(1));
		$(element).prepend(''+dropcapped_letter+'');
	});
});


text:
"use strict";

import { expect } from "chai";

import containment from "../src/containment";
import { registry } from "./fixtures";

describe("containment", function () {
  let child, parent;

  beforeEach(function () {
    child = { foo: "bar" };
    parent = { baz: "qxu" };
  });

  describe("#setOwner", function () {
    it("sets an object as owner of another", function () {
      containment.setOwner(child, parent);

      expect(containment.getOwner(child)).to.eql(parent);
    });
  });

  describe("#getOwner", function () {
    it("returns the owner of the object", function () {
      containment.setOwner(child, parent);

      expect(containment.getOwner(child)).to.eql(parent);
    });
  });
});


text:
<?php

declare(strict_types = 1);

namespace Dot\Mapper\Event;

use Zend\EventManager\ListenerAggregateInterface;

/**
 * Interface MapperEventListenerInterface
 * @package Dot\Mapper\Event
 */
interface MapperEventListenerInterface extends ListenerAggregateInterface
{
    public function onBeforeFind(MapperEvent $e);

    public function onAfterFind(MapperEvent $e);

    public function onBeforeLoad(MapperEvent $e);

    public function onAfterLoad(MapperEvent $e);

    public function onBeforeSave(MapperEvent $e);

    public function onAfterSave(MapperEvent $e);

    public function onAfterSaveCommit(MapperEvent $e);

    public function onBeforeDelete(MapperEvent $e);

    public function onAfterDelete(MapperEvent $e);

    public function onAfterDeleteCommit(MapperEvent $e);
}


text:
import React from 'react'
import './Skill.css'

const Skill = (props) => {

  return (

              { props.title }

              { props.description }

  )

}

export default Skill


text:
package org.apache.calcite.rel.core;

import org.apache.calcite.plan.RelOptCluster;
import org.apache.calcite.plan.RelTraitSet;
import org.apache.calcite.rel.RelCollation;
import org.apache.calcite.rel.RelCollationTraitDef;
import org.apache.calcite.rel.RelDistribution;
import org.apache.calcite.rel.RelDistributionTraitDef;
import org.apache.calcite.rel.RelInput;
import org.apache.calcite.rel.RelNode;
import org.apache.calcite.rel.RelWriter;

import java.util.Objects;

/**
 * Relational expression that performs {@link Exchange} and {@link Sort}
 * simultaneously.
 *
 *
Whereas a Sort produces output with a particular
 * {@link org.apache.calcite.rel.RelCollation} and an Exchange produces output
 * with a particular {@link org.apache.calcite.rel.RelDistribution}, the output
 * of a SortExchange has both the required collation and distribution.
 *
 *
Several implementations of SortExchange are possible; the purpose of this
 * base class allows rules to be written that apply to all of those
 * implementations.
 */
public abstract class SortExchange extends Exchange {
  protected final RelCollation collation;

  //~ Constructors -----------------------------------------------------------

  /**
   * Creates a SortExchange.
   *
   * @param cluster   Cluster this relational expression belongs to
   * @param traitSet  Trait set
   * @param input     Input relational expression
   * @param distribution Distribution specification
   */
  protected SortExchange(RelOptCluster cluster, RelTraitSet traitSet,
      RelNode input, RelDistribution distribution, RelCollation collation) {
    super(cluster, traitSet, input, distribution);
    this.collation = Objects.requireNonNull(collation, "collation");

    assert traitSet.containsIfApplicable(collation)
        : "traits=" + traitSet + ", collation=" + collation;
  }

  /**
   * Creates a SortExchange by parsing serialized output.
   */
  protected SortExchange(RelInput input) {
    this(input.getCluster(),
        input.getTraitSet().plus(input.getCollation())
            .plus(input.getDistribution()),
        input.getInput(),
        RelDistributionTraitDef.INSTANCE.canonize(input.getDistribution()),
        RelCollationTraitDef.INSTANCE.canonize(input.getCollation()));
  }

  //~ Methods ----------------------------------------------------------------

  @Override public final SortExchange copy(RelTraitSet traitSet,
      RelNode newInput, RelDistribution newDistribution) {
    return copy(traitSet, newInput, newDistribution, collation);
  }

  public abstract SortExchange copy(RelTraitSet traitSet, RelNode newInput,
      RelDistribution newDistribution, RelCollation newCollation);

  /**
   * Returns the array of {@link org.apache.calcite.rel.RelFieldCollation}s
   * asked for by the sort specification, from most significant to least
   * significant.
   *
   *
See also
   * {@link org.apache.calcite.rel.metadata.RelMetadataQuery#collations(RelNode)},
   * which lists all known collations. For example,
   * ORDER BY time_id might also be sorted by
   * the_year, the_month because of a known monotonicity
   * constraint among the columns. {@code getCollation} would return
   * [time_id] and {@code collations} would return
   * [ [time_id], [the_year, the_month] ].

   */
  public RelCollation getCollation() {
    return collation;
  }

  @Override public RelWriter explainTerms(RelWriter pw) {
    return super.explainTerms(pw)
        .item("collation", collation);
  }
}


text:
<!DOCTYPE html>

We are unable to show the select partner organisation page

                        The error message

        <form method="POST" th:action="@{${#ifsUtil.formPostUri(#httpServletRequest)}}" novalidate="novalidate"
              th:object="${form}">
            <fieldset class="govuk-fieldset">

                    <legend class="govuk-fieldset__legend govuk-fieldset__legend--s">

Choose partner

We only show partners that
                            have completed all their organisation details.

                    </legend>

                            <input type="radio"
                                   class="govuk-radios__input"
                                   th:field="*{organisationId}"
                                   th:value="${partnerOrganisation.organisation}"
                                   th:id="|organisation-radio-${partnerOrganisation.organisation}|"
                                   required="required"
                            />

            </fieldset>

            <button class="govuk-button" type="submit">View partner details</button>

                Cancel and return to project details

        </form>


text:
package com.wildbeeslabs.rest.model.dto.ext;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

import java.io.Serializable;
import java.util.List;
import java.util.Objects;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

/**
 *
 * MetricWrapperDTO REST Application Model
 *
 * @author Alex
 * @version 1.0.0
 * @since 2017-08-08
 * @param <E>
 */
@JsonInclude(JsonInclude.Include.NON_EMPTY)
@JacksonXmlRootElement(localName = "metrics")
public class MetricWrapperDTO<E extends MetricDTO> implements Serializable {

//    @JsonProperty("metrics")
//    @JacksonXmlElementWrapper(useWrapping = false)
//    @JacksonXmlProperty(localName = "metric")
//    private final ConcurrentMap<String, ConcurrentMap<String, Integer>> metricsMap = new ConcurrentHashMap<>();
    @JsonProperty("metrics")
    @JacksonXmlElementWrapper(useWrapping = false)
    @JacksonXmlProperty(localName = "metric")
    private final Queue<E> metrics = new ConcurrentLinkedQueue<>();

    public Queue<? extends E> getMetrics() {
        return metrics;
    }

    public void setMetrics(final List<? extends E> items) {
        this.metrics.clear();
        if (Objects.nonNull(metrics)) {
            this.metrics.addAll(metrics);
        }
    }

    public void addMetric(final E metricDto) {
        if (Objects.nonNull(metricDto)) {
            this.metrics.add(metricDto);
        }
    }

//    public ConcurrentMap<String, ConcurrentMap<String, Integer>> getMetricsMap() {
//        return metricsMap;
//    }
//
//    public void setMetricsMap(final ConcurrentMap<String, ConcurrentMap<String, Integer>> metricsMap) {
//        this.metricsMap.clear();
//        if (Objects.nonNull(metricsMap)) {
//            this.metricsMap.putAll(metricsMap);
//        }
//    }
//
//    public void addMetrics(final String key, final ConcurrentMap<String, Integer> value) {
//        this.metricsMap.put(key, value);
//    }
}


text:
describe('unique', function () {
  var uniqueFilter;

  beforeEach(module('ui.unique'));
  beforeEach(inject(function ($filter) {
    uniqueFilter = $filter('unique');
  }));

  it('should return unique entries based on object equality', function () {
    var arrayToFilter = [
      {key: 'value'},
      {key: 'value2'},
      {key: 'value'}
    ];
    expect(uniqueFilter(arrayToFilter)).toEqual([
      {key: 'value'},
      {key: 'value2'}
    ]);
  });

  it('should return unique entries based on object equality for complex objects', function () {
    var arrayToFilter = [
      {key: 'value', other: 'other1'},
      {key: 'value2', other: 'other2'},
      {other: 'other1', key: 'value'}
    ];
    expect(uniqueFilter(arrayToFilter)).toEqual([
      {key: 'value', other: 'other1'},
      {key: 'value2', other: 'other2'}
    ]);
  });

  it('should return unique entries based on the key provided', function () {
    var arrayToFilter = [
      {key: 'value'},
      {key: 'value2'},
      {key: 'value'}
    ];
    expect(uniqueFilter(arrayToFilter, 'key')).toEqual([
      {key: 'value'},
      {key: 'value2'}
    ]);
  });

  it('should return unique entries based on the key provided for complex objects', function () {
    var arrayToFilter = [
      {key: 'value', other: 'other1'},
      {key: 'value2', other: 'other2'},
      {key: 'value', other: 'other3'}
    ];
    expect(uniqueFilter(arrayToFilter, 'key')).toEqual([
      { key: 'value', other: 'other1' },
      { key: 'value2', other: 'other2' }
    ]);
  });

  it('should return unique primitives in arrays', function () {
    expect(uniqueFilter([1, 2, 1, 3])).toEqual([1, 2, 3]);
  });

  it('should work correctly for arrays of mixed elements and object equality', function () {
    expect(uniqueFilter([1, {key: 'value'}, 1, {key: 'value'}, 2, "string", 3])).toEqual([1, {key: 'value'}, 2, "string", 3]);
  });

  it('should work correctly for arrays of mixed elements and a key specified', function () {
    expect(uniqueFilter([1, {key: 'value'}, 1, {key: 'value'}, 2, "string", 3], 'key')).toEqual([1, {key: 'value'}, 2, "string", 3]);
  });

  it('should return unmodified object if not array', function () {
    expect(uniqueFilter('string', 'someKey')).toEqual('string');
  });

  it('should return unmodified array if provided key === false', function () {
    var arrayToFilter = [
      {key: 'value1'},
      {key: 'value2'}
    ];
    expect(uniqueFilter(arrayToFilter, false)).toEqual(arrayToFilter);
  });

});


text:
package com.github.TKnudsen.ComplexDataObject.data.probability;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;

import com.github.TKnudsen.ComplexDataObject.model.tools.MathFunctions;

public class ProbabilityDistribution<I> {

	public static double EPSILON = 1e-8;

	private final Map<I, Double> probabilityDistribution;

	private I mostLikelyItem;

	public ProbabilityDistribution(Map<I, Double> probabilityDistribution) {
		this.probabilityDistribution = Objects.requireNonNull(probabilityDistribution,
				"The probabilityDistribution may not be null");

		calculateRepresentant();
	}

	private void calculateRepresentant() {

		if (probabilityDistribution.isEmpty()) {
			return;
		}
		Double winning = 0.0;
		double sum = 0.0;
		for (I value : probabilityDistribution.keySet()) {
			if (probabilityDistribution.get(value) > winning) {
				mostLikelyItem = value;
				winning = probabilityDistribution.get(value);
			}

			sum += probabilityDistribution.get(value);
		}

		if (Math.abs(sum - 1.0) > EPSILON)
			throw new IllegalArgumentException(
					"ProbabilityDistribution: sum of given set of probabilites was != 100% (" + sum + ")");
	}

	public static boolean checkProbabilitySumMatchesHundredPercent(Collection<Double> probabilities, double epsilon,
			boolean print) {
		double sum = MathFunctions.getSum(probabilities, false);

		if (Math.abs(sum - 1.0) > EPSILON) {
//			System.err.println("ProbabilityDistribution: sum of given set of probabilities was != 100% (" + sum + ")");
			return false;
		}

		return true;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();

		Iterator<Entry<I, Double>> iterator = probabilityDistribution.entrySet().iterator();
		while (iterator.hasNext()) {
			Entry<I, Double> probability = iterator.next();
			sb.append(probability.getKey());
			sb.append('=').append('"');
			sb.append(probability.getValue());
			sb.append('"');
			if (iterator.hasNext())
				sb.append(',').append(' ');
		}

		return sb.toString();
	}

	/**
	 * provides values in the intrinsic order of a given set. Meaningful if several
	 * distributions are to be compared.
	 *
	 * Throws a NullPointerException if no probabilty is available for a given item.
	 *
	 * @param items
	 * @return
	 */
	public List<Double> values(Set<I> items) {
		List<Double> list = new ArrayList<>();

		for (I i : items) {
			Double probability = getProbability(i);

			if (probability == null)
				throw new NullPointerException("ProbabilityDistribution: probability for item " + i + " was null.");

			list.add(getProbability(i));
		}

		return list;
	}

	/**
	 * little helper to normalize a map with doubles to 1.0.
	 *
	 * @param valuesMap
	 * @return
	 */
	public static <I> Map<I, Double> normalize(Map<I, Double> valuesMap) {
		double sum = 0.0;

		for (double d : valuesMap.values())
			sum += d;

		Map<I, Double> output = new LinkedHashMap<>();

		for (I i : valuesMap.keySet())
			output.put(i, valuesMap.get(i) / sum);

		return output;
	}

	public Double getProbability(I item) {
		return probabilityDistribution.get(item);
	}

	public Map<I, Double> getProbabilityDistribution() {
		return probabilityDistribution;
	}

	public Set<I> keySet() {
		return probabilityDistribution.keySet();
	}

	public I getMostLikelyItem() {
		return mostLikelyItem;
	}
}


text:
<?php

use yii\helpers\Html;
use yii\widgets\ActiveForm;

/* @var $this yii\web\View */
/* @var $model app\models\WirelessDeviceInfo */
/* @var $form yii\widgets\ActiveForm */
?>

    <?php $form = ActiveForm::begin(); ?>

    <?= $form->field($model, 'id')->textInput() ?>

    <?= $form->field($model, 'label')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'ip')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'mask')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'status')->textInput() ?>

    <?= $form->field($model, 'sysName')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'location')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'sysOid')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'runtime')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'lastPoll')->textInput() ?>

    <?= $form->field($model, 'categoryId')->textInput() ?>

    <?= $form->field($model, 'supportPing')->textInput() ?>

    <?= $form->field($model, 'webMgrPort')->textInput() ?>

    <?= $form->field($model, 'configPollTime')->textInput() ?>

    <?= $form->field($model, 'statePollTime')->textInput() ?>

    <?= $form->field($model, 'typeName')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'positionX')->textInput() ?>

    <?= $form->field($model, 'positionY')->textInput() ?>

    <?= $form->field($model, 'symbolType')->textInput() ?>

    <?= $form->field($model, 'symbolDesc')->textarea(['rows' => 6]) ?>

    <?= $form->field($model, 'mac')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'phyName')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'phyCreateTime')->textInput() ?>

    <?= $form->field($model, 'series_id')->textInput() ?>

    <?= $form->field($model, 'model_id')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'interfaces')->textarea(['rows' => 6]) ?>

    <?= $form->field($model, 'category')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'update_time')->textInput() ?>

    <?= $form->field($model, 'series_name')->textInput(['maxlength' => true]) ?>

    <?= $form->field($model, 'model_name')->textInput(['maxlength' => true]) ?>

        <?= Html::submitButton($model->isNewRecord ? 'Create' : 'Update', ['class' => $model->isNewRecord ? 'btn btn-success' : 'btn btn-primary']) ?>

    <?php ActiveForm::end(); ?>


text:
from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_ORStoolsDialogConfigBase(object):
    def setupUi(self, ORStoolsDialogConfigBase):
        ORStoolsDialogConfigBase.setObjectName("ORStoolsDialogConfigBase")
        ORStoolsDialogConfigBase.resize(414, 67)
        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(ORStoolsDialogConfigBase.sizePolicy().hasHeightForWidth())
        ORStoolsDialogConfigBase.setSizePolicy(sizePolicy)
        self.gridLayout = QtWidgets.QGridLayout(ORStoolsDialogConfigBase)
        self.gridLayout.setSizeConstraint(QtWidgets.QLayout.SetMinAndMaxSize)
        self.gridLayout.setObjectName("gridLayout")
        self.providers = QtWidgets.QWidget(ORStoolsDialogConfigBase)
        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.providers.sizePolicy().hasHeightForWidth())
        self.providers.setSizePolicy(sizePolicy)
        self.providers.setObjectName("providers")
        self.verticalLayout = QtWidgets.QVBoxLayout(self.providers)
        self.verticalLayout.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint)
        self.verticalLayout.setObjectName("verticalLayout")
        self.gridLayout.addWidget(self.providers, 0, 0, 1, 3)
        self.buttonBox = QtWidgets.QDialogButtonBox(ORStoolsDialogConfigBase)
        self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.Ok)
        self.buttonBox.setObjectName("buttonBox")
        self.gridLayout.addWidget(self.buttonBox, 1, 2, 1, 1)
        self.provider_add = QtWidgets.QPushButton(ORStoolsDialogConfigBase)
        self.provider_add.setObjectName("provider_add")
        self.gridLayout.addWidget(self.provider_add, 1, 0, 1, 1)
        self.provider_remove = QtWidgets.QPushButton(ORStoolsDialogConfigBase)
        self.provider_remove.setObjectName("provider_remove")
        self.gridLayout.addWidget(self.provider_remove, 1, 1, 1, 1)

        self.retranslateUi(ORStoolsDialogConfigBase)
        QtCore.QMetaObject.connectSlotsByName(ORStoolsDialogConfigBase)

    def retranslateUi(self, ORStoolsDialogConfigBase):
        _translate = QtCore.QCoreApplication.translate
        ORStoolsDialogConfigBase.setWindowTitle(_translate("ORStoolsDialogConfigBase", "Provider Settings"))
        self.provider_add.setText(_translate("ORStoolsDialogConfigBase", "Add"))
        self.provider_remove.setText(_translate("ORStoolsDialogConfigBase", "Remove"))


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.13"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Prop Unlimiter: Harmony.ILCopying.ILInstruction Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

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

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

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

Prop Unlimiter

Public Member Functions |
Public Attributes |
List of all members

Harmony.ILCopying.ILInstruction Class Reference

Public Member Functions

 	ILInstruction (OpCode opcode, object operand=null)

CodeInstruction 	GetCodeInstruction ()

int 	GetSize ()

override string 	ToString ()

Public Attributes

int 	offset

OpCode 	opcode

object 	operand

object 	argument

List< Label > 	labels = new List<Label>()

The documentation for this class was generated from the following file:

C:/Users/applecobbler/Documents/Visual Studio 2017/Projects/PropUnlimiter/PropUnlimiter/Harmony/ILCopying/ILInstruction.cs

Harmony

ILCopying

ILInstruction

Generated by

     1.8.13


text:
<!--- Please specify the issue type to help us categorize the issue, mention any one of the below types -->

- Bug Report
- Feature proposal
- Feature enhancement
- Documentation Report

##### Summary

<!--- Provide a brief summary of the issue -->

##### Environment

<!---
Describe the environment in which you encountered this issue.
Details of the environment GoCD is running in can be fetched from the GoCD support api - http://<go-server-host>/go/api/support.
If you are pasting plain text, please surround it with 3 backticks on each side

```plain
paste any text output
to prevent formatting
```
-->

###### Basic environment details

<!--- We recommend providing the for us to reproduce the issue quicker -->

* Go Version: `Available in the footer`
* JAVA Version: `Available from http://<go-server-host>/go/about`
* OS: `Available from http://<go-server-host>/go/about`
* Browser vendor and version (if relevant): `Hopefully not Internet Explorer 7 :)`

###### Additional Environment Details

<!-- More environment details captured from the support API or other sources can be shared here -->

##### Steps to Reproduce

<!--- Provide a link to a live example, or an unambiguous set of steps to -->
<!--- reproduce this bug include code to reproduce, if relevant -->
1.
2.
3.
4.

##### Expected Results
<!--- Tell us what should happen -->

##### Actual Results
<!--- Tell us what happens instead -->

##### Possible Fix
<!--- Not obligatory, but suggest a fix or reason for the bug -->

##### Log snippets
<!---
If you could find any information/exceptions from the logs do provide it here.
Do mask any confidential information which you don't want to be shared.
Remember to surround them in 3 backticks like this —

```
long log lines go here
```
-->

##### Code snippets/Screenshots
<!---
If you would like to share any code/screenshots please add it here.
Do mask any confidential information which you don't want to be shared.
Remember to surround them in 3 backticks like this —

```
long log lines go here
```
-->

##### Any other info
<!--- Provide any other information you would like to share to explain this issue more better -->


text:
set -e

VERSION=$(cat version/version)

pushd prometheus-custom-git
./extract.sh ../prometheus-release-git

git config --global user.email "releasebot@c0.pivotal.io"
git config --global user.name "Releasebot"

cat > config/private.yml << EOF
---
blobstore:
  s3:
    access_key_id: ${AWS_ACCESS_KEY}
    secret_access_key: ${AWS_SECRET_KEY}
EOF

bosh -n create release --final --with-tarball --version "${VERSION}"

git add . && git commit -m "New release"

mkdir -p artifacts
echo "v${VERSION}"                           > tag
echo "Prometheus Customizations v${VERSION}" > name
cp releases/*/*-${VERSION}.tgz artifacts
popd

cp -r prometheus-custom-git/. pushme