text:
package hrpc

import (
	"context"
	"errors"
	"math"
	"reflect"
	"testing"
	"time"

	"github.com/tsuna/gohbase/filter"
	"github.com/tsuna/gohbase/test"
)

func TestFamilesOption(t *testing.T) {
	f := map[string][]string{"yolo": []string{"swag", "meow"}}

	g, err := NewGet(context.Background(), nil, nil, Families(f))
	if err != nil {
		t.Error(err)
	}

	if !reflect.DeepEqual(f, g.families) {
		t.Errorf("expected %v, got %v", f, g.families)
	}

	_, err = NewPutStr(context.Background(), "", "", nil, Families(f))
	if err == nil || err.Error() != "'Families' option can only be used with Get or Scan request" {
		t.Error(err)
	}
}

func TestFiltersOption(t *testing.T) {
	f := filter.NewColumnCountGetFilter(1)
	g, err := NewGet(context.Background(), nil, nil, Filters(f))
	if err != nil {
		t.Error(err)
	}

	if g.filter == nil {
		t.Error("expected filter to be set")
	}

	_, err = NewPutStr(context.Background(), "", "", nil, Filters(f))
	if err == nil || err.Error() != "'Filters' option can only be used with Get or Scan request" {
		t.Error(err)
	}
}

func TestTimeRangeOption(t *testing.T) {
	now := time.Now()
	tests := []struct {
		from time.Time
		to   time.Time
		err  error
	}{
		{from: now, to: now.Add(time.Minute)},
		{from: now.Add(time.Minute), to: now, err: errors.New(
			"'from' timestamp is greater or equal to 'to' timestamp")},
		{from: now, to: now, err: errors.New(
			"'from' timestamp is greater or equal to 'to' timestamp")},
	}

	for _, tcase := range tests {
		g, err := NewGet(context.Background(), nil, nil, TimeRange(tcase.from, tcase.to))
		if !test.ErrEqual(tcase.err, err) {
			t.Fatalf("expected %v, got %v", tcase.err, err)
		}
		if tcase.err != nil {
			continue
		}

		from, to := g.fromTimestamp, g.toTimestamp
		if fromExp := uint64(tcase.from.UnixNano() / 1e6); from != fromExp {
			t.Errorf("expected from time %d, got from time %d", fromExp, from)
		}
		if toExp := uint64(tcase.to.UnixNano() / 1e6); to != toExp {
			t.Errorf("expected to time %d, got to time %d", toExp, to)
		}

		_, err = NewPutStr(context.Background(), "", "", nil, TimeRange(tcase.to, tcase.from))
		if err == nil || err.Error() !=
			"'TimeRange' option can only be used with Get or Scan request" {
			t.Error(err)
		}
	}
}

func TestMaxVersions(t *testing.T) {
	v := uint32(123456)
	g, err := NewGet(context.Background(), nil, nil, MaxVersions(v))
	if err != nil {
		t.Error(err)
	}

	if vExp, vGot := v, g.maxVersions; vExp != vGot {
		t.Errorf("expected %d, got %d", vExp, vGot)
	}

	_, err = NewGet(context.Background(), nil, nil, MaxVersions(uint32(math.MaxUint32)))
	if err == nil || err.Error() != "'MaxVersions' exceeds supported number of versions" {
		t.Error(err)
	}

	_, err = NewPutStr(context.Background(), "", "", nil, MaxVersions(v))
	if err == nil || err.Error() !=
		"'MaxVersions' option can only be used with Get or Scan request" {
		t.Error(err)
	}
}

func TestMaxResultsPerColumnFamily(t *testing.T) {
	r := uint32(123456)
	g, err := NewGet(context.Background(), nil, nil, MaxResultsPerColumnFamily(r))
	if err != nil {
		t.Error(err)
	}

	if rExp, rGot := r, g.storeLimit; rExp != rGot {
		t.Errorf("expected %d, got %d", rExp, rGot)
	}

	_, err = NewGet(context.Background(), nil, nil,
		MaxResultsPerColumnFamily(uint32(math.MaxUint32)))
	if err == nil || err.Error() !=
		"'MaxResultsPerColumnFamily' exceeds supported number of value results" {
		t.Error(err)
	}

	_, err = NewPutStr(context.Background(), "", "", nil, MaxResultsPerColumnFamily(r))
	if err == nil || err.Error() !=
		"'MaxResultsPerColumnFamily' option can only be used with Get or Scan request" {
		t.Error(err)
	}
}

func TestResultOffset(t *testing.T) {
	r := uint32(123456)
	g, err := NewGet(context.Background(), nil, nil, ResultOffset(r))
	if err != nil {
		t.Error(err)
	}

	if rExp, rGot := r, g.storeOffset; rExp != rGot {
		t.Errorf("expected %d, got %d", rExp, rGot)
	}

	_, err = NewGet(context.Background(), nil, nil, ResultOffset(uint32(math.MaxUint32)))
	if err == nil || err.Error() != "'ResultOffset' exceeds supported offset value" {
		t.Error(err)
	}

	_, err = NewPutStr(context.Background(), "", "", nil, ResultOffset(r))
	if err == nil || err.Error() !=
		"'ResultOffset' option can only be used with Get or Scan request" {
		t.Error(err)
	}
}

func TestCacheBlocks(t *testing.T) {
	// set CacheBlocks to false for Get
	g, err := NewGet(context.Background(), nil, nil, CacheBlocks(false))
	if err != nil {
		t.Error(err)
	}

	if cbExp, cbGot := false, g.cacheBlocks; cbExp != cbGot {
		t.Errorf("expected %v, got %v", cbExp, cbGot)
	}

	// check that default CacheBlocks for Get is true
	g2, err := NewGet(context.Background(), nil, nil)
	if err != nil {
		t.Error(err)
	}
	if cbExp, cbGot := true, g2.cacheBlocks; cbExp != cbGot {
		t.Errorf("expected %v, got %v", cbExp, cbGot)
	}

	// explicitly set CacheBlocks to true for Get
	s, err := NewScan(context.Background(), nil, CacheBlocks(true))
	if err != nil {
		t.Error(err)
	}

	if cbExp, cbGot := true, s.cacheBlocks; cbExp != cbGot {
		t.Errorf("expected %v, got %v", cbExp, cbGot)
	}

	// check that default CacheBlocks for Scan is true
	s2, err := NewScan(context.Background(), nil)
	if err != nil {
		t.Error(err)
	}

	if cbExp, cbGot := true, s2.cacheBlocks; cbExp != cbGot {
		t.Errorf("expected %v, got %v", cbExp, cbGot)
	}

	_, err = NewPutStr(context.Background(), "", "", nil, CacheBlocks(true))
	if err == nil || err.Error() !=
		"'CacheBlocks' option can only be used with Get or Scan request" {
		t.Error(err)
	}
}


text:
=begin
    Copyright 2010-2012 Tasos Laskos <tasos.laskos@gmail.com>

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
=end

require 'socket'

require Arachni::Options.instance.dir['lib'] + 'rpc/client/dispatcher'

module Arachni
module UI
module Web

#
# Provides methods for dispatcher management.
#
# @author Tasos "Zapotek" Laskos
#                                      <tasos.laskos@gmail.com>
#
# @version 0.1.1
#
class DispatcherManager

    class Dispatcher
        include DataMapper::Resource

        property :id,           Serial
        property :url,          String
    end

    def initialize( opts, settings )
        @opts     = opts
        @settings = settings

        DataMapper::setup( :default, "sqlite3://#{@settings.db}/default.db" )
        DataMapper.finalize

        Dispatcher.auto_upgrade!
    end

    #
    # Puts a new dispatcher (and it's neighbours) in the DB.
    #
    # @param    [String]    url          URL of the dispatcher
    # @param    [Bool]      neighbours   add its neighbouring dispatchers too?
    #
    def new( url, neighbours = true )
        Dispatcher.first_or_create( :url => url )

        return if !neighbours
        connect( url ).node.neighbours {
            |neighbours|
            neighbours.each {
                |node|
                Dispatcher.first_or_create( :url => node )
            }
        }
    end

    #
    # Provides an easy way to connect to a dispatcher.
    #
    # @param    [String]   url
    #
    # @return   [Arachni::RPC::Client::Dispatcher]
    #
    def connect( url )
        Arachni::RPC::Client::Dispatcher.new( @opts, url )
    end

    #
    # Checks wether the dispatcher is alive.
    #
    # @param    [String]    url     URL of the dispatcher
    #
    def alive?( url, &block )
        raise( "This method requires a block!" ) if !block_given?

        connect( url ).alive? {
            |ret|
            block.call( ret.rpc_connection_error? ? false : true )
        }
    end

    def first_alive( &block )
        raise( "This method requires a block!" ) if !block_given?

        if !all.empty?
            EM.synchrony do
                dispatchers = EM::Synchrony::Iterator.new( all ).map {
                    |dispatcher, iter|
                    alive?( dispatcher.url ){
                        |bool|
                        if bool
                            iter.return( dispatcher )
                        else
                            iter.return( nil )
                        end
                    }
                }.compact

                if dispatchers.empty?
                    block.call( false )
                else
                    block.call( dispatchers.pop )
                end
            end
        else
            block.call( false )
        end
    end

    def jobs( &block )
        ::EM::Iterator.new( all, 20 ).map( proc {
            |dispatcher, iter|

            connect( dispatcher.url ).stats {
                |stats|
                iter.return( stats['running_jobs'] ) if !stats.rpc_connection_error?
            }

        }, proc {
            |running|
            block.call( running.flatten )
        })
    end

    #
    # Provides statistics about running jobs etc using the dispatcher
    #
    # @return   [Hash]
    #
    def stats( &block )
        raise( "This method requires a block!" ) if !block_given?

        EM.synchrony do

            stats = EM::Synchrony::Iterator.new( all ).map {
                |dispatcher, iter|

                if !dispatcher.rpc_connection_error?
                    connect( dispatcher.url ).stats {
                        |stats|
                        if !stats.rpc_exception?

                            # automatically grab and save neighbours
                            stats['neighbours'].each { |n| new( n ) }

                            iter.return( { dispatcher.url => stats } )
                        else
                            iter.return( nil )
                        end
                    }
                end
            }.compact

            sorted_stats = {}
            stats.sort{ |a, b| a.keys[0] <=> b.keys[0] }.each {
                |stat|
                sorted_stats.merge!( stat )
            }

            sorted_stats.each_pair {
                |k, stats|

                sorted_stats[k]['running_jobs'] =
                    EM::Synchrony::Iterator.new( stats['running_jobs'] ).map {
                    |instance, iter|

                    if instance['helpers']['rank'] != 'slave'
                        @settings.instances.connect( instance['url'] ).framework.progress_data(
                            :slaves   => false,
                            :messages => false,
                            :issues   => false
                        ) {
                            |prog_data|
                            if prog_data.rpc_exception?
                                iter.return( nil )
                            else
                                instance.merge!( prog_data['stats'] )
                                instance['status']  = prog_data['status'].capitalize!
                                iter.return( instance )
                            end
                        }
                    else
                        @settings.instances.connect( instance['helpers']['master'] ).framework.progress_data(
                            :messages => false,
                            :issues   => false
                        ) {
                            |prog_data|
                            if prog_data.rpc_exception?
                                iter.return( nil )
                            else
                                prog_data['instances'].each {
                                    |insdat|
                                     if insdat['url'] == instance['url']
                                         instance.merge!( insdat )
                                         instance['status'].capitalize!
                                         iter.return( instance )
                                    end
                                }
                            end
                        }
                    end
                }.compact
            }

            block.call( sorted_stats )
        end
    end

    #
    # Returns all dispatchers stored in the DB.
    #
    # @return    [Array]
    #
    def all( *args )
        Dispatcher.all( *args )
    end

    def all_with_liveness( &block )
        raise( "This method requires a block!" ) if !block_given?

        EM::Iterator.new( all ).map( proc{
            |dispatcher, iter|

            alive?( dispatcher.url ) {
                |liveness|

                m_dispatcher = {}
                dispatcher.attributes.each_pair {
                    |k, v|
                    m_dispatcher[k.to_s] = v
                }
                m_dispatcher['alive'] = liveness
                iter.return( m_dispatcher )
            }
        }, proc{
            |dispatchers|
            block.call( dispatchers )
        })
    end

    #
    # Removed all dispatchers from the DB.
    #
    def delete_all
        all.each {
            |report|
            delete( report.id )
        }
        all.destroy
    end

    #
    # Removed a dispatcher from the DB.
    #
    # @param    [Integer]   id
    #
    def delete( id )
        Dispatcher.get( id ).destroy
    end

end
end
end
end

redpajama_set_name: RedPajamaGithub


text:
package io.opensemantics.semiotics.model.assessment.impl;

import io.opensemantics.semiotics.model.assessment.Account;
import io.opensemantics.semiotics.model.assessment.Accounts;
import io.opensemantics.semiotics.model.assessment.Application;
import io.opensemantics.semiotics.model.assessment.Applications;
import io.opensemantics.semiotics.model.assessment.Assessment;
import io.opensemantics.semiotics.model.assessment.AssessmentFactory;
import io.opensemantics.semiotics.model.assessment.AssessmentPackage;
import io.opensemantics.semiotics.model.assessment.Contents;
import io.opensemantics.semiotics.model.assessment.Control;
import io.opensemantics.semiotics.model.assessment.Controller;
import io.opensemantics.semiotics.model.assessment.Controllers;
import io.opensemantics.semiotics.model.assessment.Entitlement;
import io.opensemantics.semiotics.model.assessment.Entitlements;
import io.opensemantics.semiotics.model.assessment.Finding;
import io.opensemantics.semiotics.model.assessment.Findings;
import io.opensemantics.semiotics.model.assessment.Generic;
import io.opensemantics.semiotics.model.assessment.Graph;
import io.opensemantics.semiotics.model.assessment.GraphNode;
import io.opensemantics.semiotics.model.assessment.Http;
import io.opensemantics.semiotics.model.assessment.HttpMethod;
import io.opensemantics.semiotics.model.assessment.Label;
import io.opensemantics.semiotics.model.assessment.Language;
import io.opensemantics.semiotics.model.assessment.Model;
import io.opensemantics.semiotics.model.assessment.Models;
import io.opensemantics.semiotics.model.assessment.Node;
import io.opensemantics.semiotics.model.assessment.Notes;
import io.opensemantics.semiotics.model.assessment.Resource;
import io.opensemantics.semiotics.model.assessment.Resources;
import io.opensemantics.semiotics.model.assessment.Scm;
import io.opensemantics.semiotics.model.assessment.Sink;
import io.opensemantics.semiotics.model.assessment.Sinks;
import io.opensemantics.semiotics.model.assessment.Snippet;
import io.opensemantics.semiotics.model.assessment.Task;
import io.opensemantics.semiotics.model.assessment.TaskStatus;
import io.opensemantics.semiotics.model.assessment.Tasks;
import io.opensemantics.semiotics.model.assessment.Url;
import io.opensemantics.semiotics.model.assessment.UrlPattern;
import io.opensemantics.semiotics.model.assessment.View;

import io.opensemantics.semiotics.model.assessment.Views;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EEnum;
import org.eclipse.emf.ecore.EGenericType;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.ETypeParameter;

import org.eclipse.emf.ecore.impl.EPackageImpl;

/**
 *
 * An implementation of the model Package.
 *
 * @generated
 */
public class AssessmentPackageImpl extends EPackageImpl implements AssessmentPackage {
	/**
   *
	 *
   * @generated
   */
	private EClass httpEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass nodeEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass assessmentEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass applicationEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass sinkEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass controllerEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass viewEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass modelEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass findingEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass accountEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass entitlementEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass taskEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass scmEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass snippetEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass urlEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass graphEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass genericEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass graphNodeEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass controlEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass resourceEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass labelEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass contentsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass notesEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass applicationsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass findingsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass accountsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass controllersEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass entitlementsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass modelsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass viewsEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass sinksEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass resourcesEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EClass tasksEClass = null;

	/**
   *
	 *
   * @generated
   */
	private EEnum httpMethodEEnum = null;

	/**
   *
	 *
   * @generated
   */
	private EEnum urlPatternEEnum = null;

	/**
   *
	 *
   * @generated
   */
	private EEnum languageEEnum = null;

	/**
   *
	 *
   * @generated
   */
	private EEnum taskStatusEEnum = null;

	/**
   * Creates an instance of the model Package, registered with
   * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
   * package URI value.
   *
Note: the correct way to create the package is via the static
   * factory method {@link #init init()}, which also performs
   * initialization of the package, or returns the registered package,
   * if one already exists.
   *
	 *
   * @see org.eclipse.emf.ecore.EPackage.Registry
   * @see io.opensemantics.semiotics.model.assessment.AssessmentPackage#eNS_URI
   * @see #init()
   * @generated
   */
	private AssessmentPackageImpl() {
    super(eNS_URI, AssessmentFactory.eINSTANCE);
  }

	/**
   *
	 *
   * @generated
   */
	private static boolean isInited = false;

	/**
   * Creates, registers, and initializes the Package for this model, and for any others upon which it depends.
   *
   *
This method is used to initialize {@link AssessmentPackage#eINSTANCE} when that field is accessed.
   * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
   *
	 *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
	public static AssessmentPackage init() {
    if (isInited) return (AssessmentPackage)EPackage.Registry.INSTANCE.getEPackage(AssessmentPackage.eNS_URI);

    // Obtain or create and register package
    AssessmentPackageImpl theAssessmentPackage = (AssessmentPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof AssessmentPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new AssessmentPackageImpl());

    isInited = true;

    // Create package meta-data objects
    theAssessmentPackage.createPackageContents();

    // Initialize created meta-data
    theAssessmentPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theAssessmentPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(AssessmentPackage.eNS_URI, theAssessmentPackage);
    return theAssessmentPackage;
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getHttp() {
    return httpEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getHttp_Request() {
    return (EAttribute)httpEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getHttp_Response() {
    return (EAttribute)httpEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getNode() {
    return nodeEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getNode_Children() {
    return (EReference)nodeEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getNode_Parent() {
    return (EReference)nodeEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getNode_RefersTo() {
    return (EReference)nodeEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getNode_ReferredBy() {
    return (EReference)nodeEClass.getEStructuralFeatures().get(3);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getNode_Tasks() {
    return (EReference)nodeEClass.getEStructuralFeatures().get(4);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getNode_Findings() {
    return (EReference)nodeEClass.getEStructuralFeatures().get(5);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getAssessment() {
    return assessmentEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAssessment_Applications() {
    return (EReference)assessmentEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAssessment_Findings() {
    return (EReference)assessmentEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAssessment_Tasks() {
    return (EReference)assessmentEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getApplication() {
    return applicationEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Accounts() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Entitlements() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Controllers() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Models() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(3);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Scm() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(4);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Views() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(5);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Sinks() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(6);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Resources() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(7);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplication_Applications() {
    return (EReference)applicationEClass.getEStructuralFeatures().get(8);
  }

	/**
   *
   *
   * @generated
   */
  public EAttribute getApplication_InternalURL() {
    return (EAttribute)applicationEClass.getEStructuralFeatures().get(9);
  }

  /**
   *
   *
   * @generated
   */
  public EAttribute getApplication_ExternalURL() {
    return (EAttribute)applicationEClass.getEStructuralFeatures().get(10);
  }

  /**
   *
	 *
   * @generated
   */
	public EClass getSink() {
    return sinkEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getSink_Cwes() {
    return (EAttribute)sinkEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getSink_Sinks() {
    return (EReference)sinkEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getController() {
    return controllerEClass;
  }

	/**
   *
   *
   * @generated
   */
  public EReference getController_Controllers() {
    return (EReference)controllerEClass.getEStructuralFeatures().get(0);
  }

  /**
   *
	 *
   * @generated
   */
	public EClass getView() {
    return viewEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getView_Views() {
    return (EReference)viewEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getModel() {
    return modelEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getModel_Models() {
    return (EReference)modelEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getFinding() {
    return findingEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getFinding_Findings() {
    return (EReference)findingEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getFinding_Reproducer() {
    return (EAttribute)findingEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getFinding_Remediation() {
    return (EAttribute)findingEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getFinding_References() {
    return (EAttribute)findingEClass.getEStructuralFeatures().get(3);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getFinding_Affects() {
    return (EReference)findingEClass.getEStructuralFeatures().get(4);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getAccount() {
    return accountEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAccount_Accounts() {
    return (EReference)accountEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAccount_Entitlements() {
    return (EReference)accountEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getAccount_Email() {
    return (EAttribute)accountEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getAccount_Password() {
    return (EAttribute)accountEClass.getEStructuralFeatures().get(3);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getEntitlement() {
    return entitlementEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getEntitlement_Accounts() {
    return (EReference)entitlementEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getEntitlement_Entitlements() {
    return (EReference)entitlementEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getTask() {
    return taskEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getTask_Tasks() {
    return (EReference)taskEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getTask_Affects() {
    return (EReference)taskEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getTask_Status() {
    return (EAttribute)taskEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getScm() {
    return scmEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getScm_Repository() {
    return (EAttribute)scmEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getScm_BranchTag() {
    return (EAttribute)scmEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getScm_Application() {
    return (EReference)scmEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getSnippet() {
    return snippetEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getSnippet_LineEnd() {
    return (EAttribute)snippetEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getSnippet_ColumnStart() {
    return (EAttribute)snippetEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getSnippet_ColumnEnd() {
    return (EAttribute)snippetEClass.getEStructuralFeatures().get(2);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getSnippet_LineStart() {
    return (EAttribute)snippetEClass.getEStructuralFeatures().get(3);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getSnippet_Resource() {
    return (EReference)snippetEClass.getEStructuralFeatures().get(4);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getUrl() {
    return urlEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getUrl_Pattern() {
    return (EAttribute)urlEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getUrl_PatternType() {
    return (EAttribute)urlEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getGraph() {
    return graphEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getGraph_Root() {
    return (EReference)graphEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getGeneric() {
    return genericEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getGraphNode() {
    return graphNodeEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getControl() {
    return controlEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getResource() {
    return resourceEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getResource_Resources() {
    return (EReference)resourceEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getResource_Snippets() {
    return (EReference)resourceEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getLabel() {
    return labelEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getLabel_Label() {
    return (EAttribute)labelEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getContents() {
    return contentsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getContents_Contents() {
    return (EAttribute)contentsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getNotes() {
    return notesEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EAttribute getNotes_Notes() {
    return (EAttribute)notesEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getApplications() {
    return applicationsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplications_Applications() {
    return (EReference)applicationsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getApplications_Assessment() {
    return (EReference)applicationsEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getFindings() {
    return findingsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getFindings_Findings() {
    return (EReference)findingsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getFindings_Assessment() {
    return (EReference)findingsEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getAccounts() {
    return accountsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAccounts_Application() {
    return (EReference)accountsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getAccounts_Accounts() {
    return (EReference)accountsEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getControllers() {
    return controllersEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getControllers_Application() {
    return (EReference)controllersEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getControllers_Controllers() {
    return (EReference)controllersEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getEntitlements() {
    return entitlementsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getEntitlements_Application() {
    return (EReference)entitlementsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getEntitlements_Entitlements() {
    return (EReference)entitlementsEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getModels() {
    return modelsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getModels_Application() {
    return (EReference)modelsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getModels_Models() {
    return (EReference)modelsEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getViews() {
    return viewsEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getViews_Application() {
    return (EReference)viewsEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getViews_Views() {
    return (EReference)viewsEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getSinks() {
    return sinksEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getSinks_Application() {
    return (EReference)sinksEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getSinks_Sinks() {
    return (EReference)sinksEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getResources() {
    return resourcesEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getResources_Application() {
    return (EReference)resourcesEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getResources_Resources() {
    return (EReference)resourcesEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EClass getTasks() {
    return tasksEClass;
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getTasks_Assessment() {
    return (EReference)tasksEClass.getEStructuralFeatures().get(0);
  }

	/**
   *
	 *
   * @generated
   */
	public EReference getTasks_Tasks() {
    return (EReference)tasksEClass.getEStructuralFeatures().get(1);
  }

	/**
   *
	 *
   * @generated
   */
	public EEnum getHttpMethod() {
    return httpMethodEEnum;
  }

	/**
   *
	 *
   * @generated
   */
	public EEnum getUrlPattern() {
    return urlPatternEEnum;
  }

	/**
   *
	 *
   * @generated
   */
	public EEnum getLanguage() {
    return languageEEnum;
  }

	/**
   *
	 *
   * @generated
   */
	public EEnum getTaskStatus() {
    return taskStatusEEnum;
  }

	/**
   *
	 *
   * @generated
   */
	public AssessmentFactory getAssessmentFactory() {
    return (AssessmentFactory)getEFactoryInstance();
  }

	/**
   *
	 *
   * @generated
   */
	private boolean isCreated = false;

	/**
   * Creates the meta-model objects for the package.  This method is
   * guarded to have no affect on any invocation but its first.
   *
	 *
   * @generated
   */
	public void createPackageContents() {
    if (isCreated) return;
    isCreated = true;

    // Create classes and their features
    httpEClass = createEClass(HTTP);
    createEAttribute(httpEClass, HTTP__REQUEST);
    createEAttribute(httpEClass, HTTP__RESPONSE);

    nodeEClass = createEClass(NODE);
    createEReference(nodeEClass, NODE__CHILDREN);
    createEReference(nodeEClass, NODE__PARENT);
    createEReference(nodeEClass, NODE__REFERS_TO);
    createEReference(nodeEClass, NODE__REFERRED_BY);
    createEReference(nodeEClass, NODE__TASKS);
    createEReference(nodeEClass, NODE__FINDINGS);

    assessmentEClass = createEClass(ASSESSMENT);
    createEReference(assessmentEClass, ASSESSMENT__APPLICATIONS);
    createEReference(assessmentEClass, ASSESSMENT__FINDINGS);
    createEReference(assessmentEClass, ASSESSMENT__TASKS);

    applicationEClass = createEClass(APPLICATION);
    createEReference(applicationEClass, APPLICATION__ACCOUNTS);
    createEReference(applicationEClass, APPLICATION__ENTITLEMENTS);
    createEReference(applicationEClass, APPLICATION__CONTROLLERS);
    createEReference(applicationEClass, APPLICATION__MODELS);
    createEReference(applicationEClass, APPLICATION__SCM);
    createEReference(applicationEClass, APPLICATION__VIEWS);
    createEReference(applicationEClass, APPLICATION__SINKS);
    createEReference(applicationEClass, APPLICATION__RESOURCES);
    createEReference(applicationEClass, APPLICATION__APPLICATIONS);
    createEAttribute(applicationEClass, APPLICATION__INTERNAL_URL);
    createEAttribute(applicationEClass, APPLICATION__EXTERNAL_URL);

    sinkEClass = createEClass(SINK);
    createEAttribute(sinkEClass, SINK__CWES);
    createEReference(sinkEClass, SINK__SINKS);

    controllerEClass = createEClass(CONTROLLER);
    createEReference(controllerEClass, CONTROLLER__CONTROLLERS);

    viewEClass = createEClass(VIEW);
    createEReference(viewEClass, VIEW__VIEWS);

    modelEClass = createEClass(MODEL);
    createEReference(modelEClass, MODEL__MODELS);

    findingEClass = createEClass(FINDING);
    createEReference(findingEClass, FINDING__FINDINGS);
    createEAttribute(findingEClass, FINDING__REPRODUCER);
    createEAttribute(findingEClass, FINDING__REMEDIATION);
    createEAttribute(findingEClass, FINDING__REFERENCES);
    createEReference(findingEClass, FINDING__AFFECTS);

    accountEClass = createEClass(ACCOUNT);
    createEReference(accountEClass, ACCOUNT__ACCOUNTS);
    createEReference(accountEClass, ACCOUNT__ENTITLEMENTS);
    createEAttribute(accountEClass, ACCOUNT__EMAIL);
    createEAttribute(accountEClass, ACCOUNT__PASSWORD);

    entitlementEClass = createEClass(ENTITLEMENT);
    createEReference(entitlementEClass, ENTITLEMENT__ACCOUNTS);
    createEReference(entitlementEClass, ENTITLEMENT__ENTITLEMENTS);

    taskEClass = createEClass(TASK);
    createEReference(taskEClass, TASK__TASKS);
    createEReference(taskEClass, TASK__AFFECTS);
    createEAttribute(taskEClass, TASK__STATUS);

    scmEClass = createEClass(SCM);
    createEAttribute(scmEClass, SCM__REPOSITORY);
    createEAttribute(scmEClass, SCM__BRANCH_TAG);
    createEReference(scmEClass, SCM__APPLICATION);

    snippetEClass = createEClass(SNIPPET);
    createEAttribute(snippetEClass, SNIPPET__LINE_END);
    createEAttribute(snippetEClass, SNIPPET__COLUMN_START);
    createEAttribute(snippetEClass, SNIPPET__COLUMN_END);
    createEAttribute(snippetEClass, SNIPPET__LINE_START);
    createEReference(snippetEClass, SNIPPET__RESOURCE);

    urlEClass = createEClass(URL);
    createEAttribute(urlEClass, URL__PATTERN);
    createEAttribute(urlEClass, URL__PATTERN_TYPE);

    graphEClass = createEClass(GRAPH);
    createEReference(graphEClass, GRAPH__ROOT);

    genericEClass = createEClass(GENERIC);

    graphNodeEClass = createEClass(GRAPH_NODE);

    controlEClass = createEClass(CONTROL);

    resourceEClass = createEClass(RESOURCE);
    createEReference(resourceEClass, RESOURCE__RESOURCES);
    createEReference(resourceEClass, RESOURCE__SNIPPETS);

    labelEClass = createEClass(LABEL);
    createEAttribute(labelEClass, LABEL__LABEL);

    contentsEClass = createEClass(CONTENTS);
    createEAttribute(contentsEClass, CONTENTS__CONTENTS);

    notesEClass = createEClass(NOTES);
    createEAttribute(notesEClass, NOTES__NOTES);

    applicationsEClass = createEClass(APPLICATIONS);
    createEReference(applicationsEClass, APPLICATIONS__APPLICATIONS);
    createEReference(applicationsEClass, APPLICATIONS__ASSESSMENT);

    findingsEClass = createEClass(FINDINGS);
    createEReference(findingsEClass, FINDINGS__FINDINGS);
    createEReference(findingsEClass, FINDINGS__ASSESSMENT);

    accountsEClass = createEClass(ACCOUNTS);
    createEReference(accountsEClass, ACCOUNTS__APPLICATION);
    createEReference(accountsEClass, ACCOUNTS__ACCOUNTS);

    controllersEClass = createEClass(CONTROLLERS);
    createEReference(controllersEClass, CONTROLLERS__APPLICATION);
    createEReference(controllersEClass, CONTROLLERS__CONTROLLERS);

    entitlementsEClass = createEClass(ENTITLEMENTS);
    createEReference(entitlementsEClass, ENTITLEMENTS__APPLICATION);
    createEReference(entitlementsEClass, ENTITLEMENTS__ENTITLEMENTS);

    modelsEClass = createEClass(MODELS);
    createEReference(modelsEClass, MODELS__APPLICATION);
    createEReference(modelsEClass, MODELS__MODELS);

    viewsEClass = createEClass(VIEWS);
    createEReference(viewsEClass, VIEWS__APPLICATION);
    createEReference(viewsEClass, VIEWS__VIEWS);

    sinksEClass = createEClass(SINKS);
    createEReference(sinksEClass, SINKS__APPLICATION);
    createEReference(sinksEClass, SINKS__SINKS);

    resourcesEClass = createEClass(RESOURCES);
    createEReference(resourcesEClass, RESOURCES__APPLICATION);
    createEReference(resourcesEClass, RESOURCES__RESOURCES);

    tasksEClass = createEClass(TASKS);
    createEReference(tasksEClass, TASKS__ASSESSMENT);
    createEReference(tasksEClass, TASKS__TASKS);

    // Create enums
    httpMethodEEnum = createEEnum(HTTP_METHOD);
    urlPatternEEnum = createEEnum(URL_PATTERN);
    languageEEnum = createEEnum(LANGUAGE);
    taskStatusEEnum = createEEnum(TASK_STATUS);
  }

	/**
   *
	 *
   * @generated
   */
	private boolean isInitialized = false;

	/**
   * Complete the initialization of the package and its meta-model.  This
   * method is guarded to have no affect on any invocation but its first.
   *
	 *
   * @generated
   */
	public void initializePackageContents() {
    if (isInitialized) return;
    isInitialized = true;

    // Initialize package
    setName(eNAME);
    setNsPrefix(eNS_PREFIX);
    setNsURI(eNS_URI);

    // Create type parameters
    ETypeParameter graphEClass_T = addETypeParameter(graphEClass, "T");

    // Set bounds for type parameters
    EGenericType g1 = createEGenericType(this.getNode());
    graphEClass_T.getEBounds().add(g1);

    // Add supertypes to classes
    httpEClass.getESuperTypes().add(this.getGraphNode());
    nodeEClass.getESuperTypes().add(this.getLabel());
    nodeEClass.getESuperTypes().add(this.getNotes());
    assessmentEClass.getESuperTypes().add(this.getLabel());
    assessmentEClass.getESuperTypes().add(this.getNotes());
    applicationEClass.getESuperTypes().add(this.getLabel());
    applicationEClass.getESuperTypes().add(this.getNotes());
    sinkEClass.getESuperTypes().add(this.getNode());
    controllerEClass.getESuperTypes().add(this.getNode());
    viewEClass.getESuperTypes().add(this.getNode());
    modelEClass.getESuperTypes().add(this.getNode());
    findingEClass.getESuperTypes().add(this.getLabel());
    findingEClass.getESuperTypes().add(this.getNotes());
    accountEClass.getESuperTypes().add(this.getNode());
    entitlementEClass.getESuperTypes().add(this.getNode());
    taskEClass.getESuperTypes().add(this.getLabel());
    taskEClass.getESuperTypes().add(this.getNotes());
    snippetEClass.getESuperTypes().add(this.getGraphNode());
    snippetEClass.getESuperTypes().add(this.getContents());
    genericEClass.getESuperTypes().add(this.getGraphNode());
    graphNodeEClass.getESuperTypes().add(this.getNode());
    controlEClass.getESuperTypes().add(this.getGraphNode());
    resourceEClass.getESuperTypes().add(this.getLabel());
    resourceEClass.getESuperTypes().add(this.getNotes());
    resourceEClass.getESuperTypes().add(this.getContents());

    // Initialize classes, features, and operations; add parameters
    initEClass(httpEClass, Http.class, "Http", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getHttp_Request(), ecorePackage.getEString(), "request", null, 0, 1, Http.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getHttp_Response(), ecorePackage.getEString(), "response", null, 0, 1, Http.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(nodeEClass, Node.class, "Node", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getNode_Children(), this.getGraphNode(), null, "children", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getNode_Parent(), this.getNode(), null, "parent", null, 0, 1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getNode_RefersTo(), this.getNode(), this.getNode_ReferredBy(), "refersTo", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getNode_ReferredBy(), this.getNode(), this.getNode_RefersTo(), "referredBy", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getNode_Tasks(), this.getTask(), this.getTask_Affects(), "tasks", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getNode_Findings(), this.getFinding(), this.getFinding_Affects(), "findings", null, 0, -1, Node.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(assessmentEClass, Assessment.class, "Assessment", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getAssessment_Applications(), this.getApplications(), this.getApplications_Assessment(), "applications", null, 0, 1, Assessment.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getAssessment_Findings(), this.getFindings(), this.getFindings_Assessment(), "findings", null, 0, 1, Assessment.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getAssessment_Tasks(), this.getTasks(), this.getTasks_Assessment(), "tasks", null, 0, 1, Assessment.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(applicationEClass, Application.class, "Application", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getApplication_Accounts(), this.getAccounts(), null, "accounts", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Entitlements(), this.getEntitlements(), null, "entitlements", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Controllers(), this.getControllers(), this.getControllers_Application(), "controllers", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Models(), this.getModels(), this.getModels_Application(), "models", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Scm(), this.getScm(), this.getScm_Application(), "scm", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Views(), this.getViews(), this.getViews_Application(), "views", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Sinks(), this.getSinks(), null, "sinks", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Resources(), this.getResources(), this.getResources_Application(), "resources", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplication_Applications(), this.getApplications(), this.getApplications_Applications(), "applications", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getApplication_InternalURL(), ecorePackage.getEString(), "internalURL", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getApplication_ExternalURL(), ecorePackage.getEString(), "externalURL", null, 0, 1, Application.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(sinkEClass, Sink.class, "Sink", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getSink_Cwes(), ecorePackage.getEInt(), "cwes", null, 0, -1, Sink.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getSink_Sinks(), this.getSinks(), this.getSinks_Sinks(), "sinks", null, 0, 1, Sink.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(controllerEClass, Controller.class, "Controller", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getController_Controllers(), this.getControllers(), this.getControllers_Controllers(), "controllers", null, 0, 1, Controller.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(viewEClass, View.class, "View", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getView_Views(), this.getViews(), this.getViews_Views(), "views", null, 0, 1, View.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(modelEClass, Model.class, "Model", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getModel_Models(), this.getModels(), this.getModels_Models(), "models", null, 0, 1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(findingEClass, Finding.class, "Finding", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getFinding_Findings(), this.getFindings(), this.getFindings_Findings(), "findings", null, 0, 1, Finding.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getFinding_Reproducer(), ecorePackage.getEString(), "reproducer", null, 0, 1, Finding.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getFinding_Remediation(), ecorePackage.getEString(), "remediation", null, 0, 1, Finding.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getFinding_References(), ecorePackage.getEString(), "references", null, 0, 1, Finding.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getFinding_Affects(), this.getNode(), this.getNode_Findings(), "affects", null, 0, -1, Finding.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(accountEClass, Account.class, "Account", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getAccount_Accounts(), this.getAccounts(), this.getAccounts_Accounts(), "accounts", null, 0, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getAccount_Entitlements(), this.getEntitlement(), this.getEntitlement_Accounts(), "entitlements", null, 0, -1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getAccount_Email(), ecorePackage.getEString(), "email", null, 0, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getAccount_Password(), ecorePackage.getEString(), "password", null, 0, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(entitlementEClass, Entitlement.class, "Entitlement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getEntitlement_Accounts(), this.getAccount(), this.getAccount_Entitlements(), "accounts", null, 0, -1, Entitlement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getEntitlement_Entitlements(), this.getEntitlements(), this.getEntitlements_Entitlements(), "entitlements", null, 0, 1, Entitlement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(taskEClass, Task.class, "Task", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getTask_Tasks(), this.getTasks(), this.getTasks_Tasks(), "tasks", null, 0, 1, Task.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getTask_Affects(), this.getNode(), this.getNode_Tasks(), "affects", null, 0, -1, Task.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getTask_Status(), this.getTaskStatus(), "status", null, 0, 1, Task.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(scmEClass, Scm.class, "Scm", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getScm_Repository(), ecorePackage.getEString(), "repository", null, 0, 1, Scm.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getScm_BranchTag(), ecorePackage.getEString(), "branchTag", null, 0, 1, Scm.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getScm_Application(), this.getApplication(), this.getApplication_Scm(), "application", null, 0, 1, Scm.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(snippetEClass, Snippet.class, "Snippet", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getSnippet_LineEnd(), ecorePackage.getEInt(), "lineEnd", null, 0, 1, Snippet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getSnippet_ColumnStart(), ecorePackage.getEInt(), "columnStart", null, 0, 1, Snippet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getSnippet_ColumnEnd(), ecorePackage.getEInt(), "columnEnd", null, 0, 1, Snippet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getSnippet_LineStart(), ecorePackage.getEInt(), "lineStart", null, 0, 1, Snippet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getSnippet_Resource(), this.getResource(), this.getResource_Snippets(), "resource", null, 0, 1, Snippet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(urlEClass, Url.class, "Url", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getUrl_Pattern(), ecorePackage.getEString(), "pattern", null, 0, 1, Url.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEAttribute(getUrl_PatternType(), this.getUrlPattern(), "patternType", null, 0, 1, Url.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(graphEClass, Graph.class, "Graph", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    g1 = createEGenericType(graphEClass_T);
    initEReference(getGraph_Root(), g1, null, "root", null, 0, 1, Graph.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(genericEClass, Generic.class, "Generic", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);

    initEClass(graphNodeEClass, GraphNode.class, "GraphNode", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);

    initEClass(controlEClass, Control.class, "Control", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);

    initEClass(resourceEClass, Resource.class, "Resource", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getResource_Resources(), this.getResources(), this.getResources_Resources(), "resources", null, 0, 1, Resource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getResource_Snippets(), this.getSnippet(), this.getSnippet_Resource(), "snippets", null, 0, -1, Resource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(labelEClass, Label.class, "Label", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getLabel_Label(), ecorePackage.getEString(), "label", null, 0, 1, Label.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(contentsEClass, Contents.class, "Contents", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getContents_Contents(), ecorePackage.getEString(), "contents", null, 0, 1, Contents.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(notesEClass, Notes.class, "Notes", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEAttribute(getNotes_Notes(), ecorePackage.getEString(), "notes", null, 0, 1, Notes.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(applicationsEClass, Applications.class, "Applications", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getApplications_Applications(), this.getApplication(), this.getApplication_Applications(), "applications", null, 0, -1, Applications.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getApplications_Assessment(), this.getAssessment(), this.getAssessment_Applications(), "assessment", null, 0, 1, Applications.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(findingsEClass, Findings.class, "Findings", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getFindings_Findings(), this.getFinding(), this.getFinding_Findings(), "findings", null, 0, -1, Findings.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getFindings_Assessment(), this.getAssessment(), this.getAssessment_Findings(), "assessment", null, 0, 1, Findings.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(accountsEClass, Accounts.class, "Accounts", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getAccounts_Application(), this.getApplication(), null, "application", null, 0, 1, Accounts.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getAccounts_Accounts(), this.getAccount(), this.getAccount_Accounts(), "accounts", null, 0, -1, Accounts.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(controllersEClass, Controllers.class, "Controllers", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getControllers_Application(), this.getApplication(), this.getApplication_Controllers(), "application", null, 0, 1, Controllers.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getControllers_Controllers(), this.getController(), this.getController_Controllers(), "controllers", null, 0, -1, Controllers.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(entitlementsEClass, Entitlements.class, "Entitlements", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getEntitlements_Application(), this.getApplication(), null, "application", null, 0, 1, Entitlements.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getEntitlements_Entitlements(), this.getEntitlement(), this.getEntitlement_Entitlements(), "entitlements", null, 0, -1, Entitlements.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(modelsEClass, Models.class, "Models", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getModels_Application(), this.getApplication(), this.getApplication_Models(), "application", null, 0, 1, Models.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getModels_Models(), this.getModel(), this.getModel_Models(), "models", null, 0, -1, Models.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(viewsEClass, Views.class, "Views", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getViews_Application(), this.getApplication(), this.getApplication_Views(), "application", null, 0, 1, Views.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getViews_Views(), this.getView(), this.getView_Views(), "views", null, 0, -1, Views.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(sinksEClass, Sinks.class, "Sinks", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getSinks_Application(), this.getApplication(), null, "application", null, 0, 1, Sinks.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getSinks_Sinks(), this.getSink(), this.getSink_Sinks(), "sinks", null, 0, -1, Sinks.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(resourcesEClass, Resources.class, "Resources", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getResources_Application(), this.getApplication(), this.getApplication_Resources(), "application", null, 0, 1, Resources.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getResources_Resources(), this.getResource(), this.getResource_Resources(), "resources", null, 0, -1, Resources.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    initEClass(tasksEClass, Tasks.class, "Tasks", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
    initEReference(getTasks_Assessment(), this.getAssessment(), this.getAssessment_Tasks(), "assessment", null, 0, 1, Tasks.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
    initEReference(getTasks_Tasks(), this.getTask(), this.getTask_Tasks(), "tasks", null, 0, -1, Tasks.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);

    // Initialize enums and add enum literals
    initEEnum(httpMethodEEnum, HttpMethod.class, "HttpMethod");
    addEEnumLiteral(httpMethodEEnum, HttpMethod.GET);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.HEAD);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.POST);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.PUT);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.DELETE);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.OPTIONS);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.TRACE);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.CONNECT);
    addEEnumLiteral(httpMethodEEnum, HttpMethod.PATCH);

    initEEnum(urlPatternEEnum, UrlPattern.class, "UrlPattern");
    addEEnumLiteral(urlPatternEEnum, UrlPattern.ANT);

    initEEnum(languageEEnum, Language.class, "Language");
    addEEnumLiteral(languageEEnum, Language.JAVA);
    addEEnumLiteral(languageEEnum, Language.PYTHON);
    addEEnumLiteral(languageEEnum, Language.CSHARP);
    addEEnumLiteral(languageEEnum, Language.SCALA);
    addEEnumLiteral(languageEEnum, Language.PHP);
    addEEnumLiteral(languageEEnum, Language.CCPP);
    addEEnumLiteral(languageEEnum, Language.RUBY);
    addEEnumLiteral(languageEEnum, Language.OTHER);

    initEEnum(taskStatusEEnum, TaskStatus.class, "TaskStatus");
    addEEnumLiteral(taskStatusEEnum, TaskStatus.TODO);
    addEEnumLiteral(taskStatusEEnum, TaskStatus.IN_PROGRESS);
    addEEnumLiteral(taskStatusEEnum, TaskStatus.SKIPPED);
    addEEnumLiteral(taskStatusEEnum, TaskStatus.DONE);

    // Create resource
    createResource(eNS_URI);
  }

} //AssessmentPackageImpl


text:
/*
 * Hibernate Validator, declare and validate application constraints
 *
 * License: Apache License, Version 2.0
 * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
 */
package org.hibernate.validator.test.internal.engine.groups.redefiningdefaultgroup;

import javax.validation.constraints.AssertTrue;
import javax.validation.constraints.Min;

/**
 * @author Hardy Ferentschik
 */
public class Driver extends Person {
	@Min(value = 18, message = "You have to be 18 to drive a car", groups = DriverChecks.class)
	private int age;

	@AssertTrue(message = "You first have to pass the driving test", groups = DriverChecks.class)
	private boolean hasDrivingLicense;

	public Driver(String name) {
		super( name );
	}

	public void passedDrivingTest(boolean b) {
		hasDrivingLicense = b;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}


text:
Design notes
============

.. Version: 0.0.3

This is not really readable at the moment, mostly some personal notes about
current internal design.

Bento is currently split into two parts: a core API to parse the
package description into a simple object API, and a commands library
which gives a command line interface to bento.

The main design philosophy of bento is to clearly separate the
different stages of packaging deployment, as we believe it is the only
way to make a build tool extensible.

Commands "protocol"
-------------------

The command line interface of bento currently supports 3 stages:

        - configuration: is concerned with configuring user options
          (build/install customization).
        - build: compile C extensions
        - install: deploy the software into the system as configured
          at the first stage. Installers are considered installation
          as well for reasons explained later.

Although those stages are very similar to distutils/setuptools
mechanism, the implementation is fundamentally different, because each
stage is mostly independent from each other. No python object is
directly shared between commands - the current bentomaker
implementation implements each stage as a separate run. Once
configured, every command has access to all options.

Build manifest and building installers
--------------------------------------

Bento uses a slightly unusal process to install the bits of your package.
Instead of copying directly the files to the desired location, the install
process is driven by a build manifest. This build manifest is produced by the
build command. It contains a description of files per category as well as a few
metadata. The syntax is based of JSON so that it can easily be parsed from any
language and in most environments (local machine, browser, etc...).

Format internals
~~~~~~~~~~~~~~~~

The main sections is a list of json 'dicts', e.g.::

    "files": [
        ["bentomaker", "bentomaker-2.6"],
        ["bentomaker", "bentomaker"],
    ],
    "name": "bentomaker",
    "category": "executables",
    "source_dir": "build/scripts-2.6",
    "target_dir": "$bindir"

The files variable is a list of tuples (source, target). This is interpreted as
installing the file build/scripts-2.6/bentomaker into $bindir/bentomaker-2.6
and into $bindir/bentomaker. The category variable may be used to customize
installation/packaging behavior (and later to extend the build manifest for
installation hook).

A key point of the format is to specify source_dir and target_dir outside the
source/destination, so that they may be modified when the build manifest is
read depending on the usages. In particular, since eggs and windows installers
produced by bento include the build manifest, this may be used to losslessly
convert between installer formats.

Advantages
~~~~~~~~~~

The built bits and the build manifest are enough to install the
software to arbitrary location, so that the install process does not
need to know anything about the build process.  Conversely, as long as
you can produce a build manifest, you can use the installation
commands as is.

Besides installation, the manifest is also used to produce installers.
Currently, only windows installers and eggs are supported, but adding
new types of installers should be easier than with distutils. If you
look at the build_wininst and build_egg commands source code, they are
simple, and most of the "magic" happens in the build manifest. In
particular, the build manifest still refers to installed bits
relatively to abstract paths, and those paths are resolved when
building the installers.

WARNING: the build manifest will most likely need to be changed in
backward incompatible ways, including the API to access it.

Installers conversion
~~~~~~~~~~~~~~~~~~~~~

The build manifest is intended to be included in each produced
installer, for convertion between various formats. The goal is to have
idempotent conversions (e.g.  converting an egg to wininst and then
converting it back to an egg produces the exact same egg).

We also intend to use build manifest for the upcoming ''nest''
service, which will contain a database of installed software.


text:
brew update
brew upgrade

brew install mas
brew install git
brew install vim
brew install z
brew install zsh-syntax-highlighting
brew install ripgrep
brew install asdf

brew tap homebrew/cask-fonts
brew tap homebrew/cask-drivers

brew cask install google-chrome
brew cask install firefox
brew cask install microsoft-edge
brew cask install iterm2
brew cask install sublime-text
brew cask install visual-studio-code
brew cask install sublime-merge
brew cask install docker
brew cask install paw
brew cask install gpg-suite
brew cask install mongodb-compass
brew cask install imageoptim
brew cask install zeplin
brew cask install logitech-options
brew cask install rectangle
brew cask install handbrake
brew cask install font-fira-code font-open-sans font-roboto font-lato
brew cask install alfred
brew cask install istat-menus
brew cask install authy
brew cask install hyperswitch
brew cask install java
brew cask install iina
brew cask install spotify
brew cask install kap
brew cask install postico
brew cask install notion
brew cask install 1password
brew cask install qbittorrent

brew cleanup


text:
import { UserId, UserBalanceTransfer } from './entities'

export type WithdrawFunds = (user : UserId) => Promise<UserBalanceTransfer>

export type BuildParams = {
    api: Api
    balanceTransfer: Model
}

export type Api = {
    loaderWithToken(params : UserIdParams) : {
        load(): Promise<UserBalanceTransfer>
    }
}

export type Model = {
    postOptions(params : UserIdParams) : UserIdParams
}

type UserIdParams = {
    user_id : number | string
}

export function createWithdrawRequest(params : BuildParams) : WithdrawFunds {
    const {
        api,
        balanceTransfer
    } = params

    return async (user : UserId) : Promise<UserBalanceTransfer> => {
        const loaderOptions = balanceTransfer.postOptions({ user_id: user.id })
        const requestLoader = api.loaderWithToken(loaderOptions)
        return await requestLoader.load()
    }
}


text:
package de.tum.in.www1.artemis.domain;

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

import javax.persistence.*;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;

import de.tum.in.www1.artemis.domain.enumeration.SubmissionType;

/**
 * A ProgrammingSubmission.
 */
@Entity
@DiscriminatorValue(value = "P")
@JsonInclude(JsonInclude.Include.NON_EMPTY)
public class ProgrammingSubmission extends Submission {

    @Column(name = "commit_hash")
    private String commitHash;

    @Column(name = "build_failed")
    private boolean buildFailed;

    @Column(name = "build_artifact")
    private boolean buildArtifact;

    // Only present if buildFailed == true
    @OneToMany(mappedBy = "programmingSubmission", cascade = CascadeType.ALL, orphanRemoval = true)
    @OrderColumn
    @JsonIgnoreProperties(value = "programmingSubmission", allowSetters = true)
    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
    private List<BuildLogEntry> buildLogEntries = new ArrayList<>();

    public String getCommitHash() {
        return commitHash;
    }

    public ProgrammingSubmission commitHash(String commitHash) {
        this.commitHash = commitHash;
        return this;
    }

    public void setCommitHash(String commitHash) {
        this.commitHash = commitHash;
    }

    public boolean isBuildFailed() {
        return buildFailed;
    }

    public void setBuildFailed(boolean buildFailed) {
        this.buildFailed = buildFailed;
    }

    public boolean isBuildArtifact() {
        return buildArtifact;
    }

    public void setBuildArtifact(boolean buildArtifact) {
        this.buildArtifact = buildArtifact;
    }

    public List<BuildLogEntry> getBuildLogEntries() {
        return buildLogEntries;
    }

    public void setBuildLogEntries(List<BuildLogEntry> buildLogEntries) {
        this.buildLogEntries = buildLogEntries;
    }

    public boolean belongsToTestRepository() {
        return SubmissionType.TEST.equals(getType());
    }

    @Override
    public boolean isEmpty() {
        return false; // programming submissions cannot be empty, they are only created for actual commits in the git repository
    }

    @Override
    public String toString() {
        return "ProgrammingSubmission{" + "commitHash='" + commitHash + '\'' + ", buildFailed=" + buildFailed + ", buildArtifact=" + buildArtifact + '}';
    }
}


text:
import { NgModule } from '@angular/core';
import { AngularFreezeframeComponent } from './angular-freezeframe.component';

@NgModule({
  declarations: [AngularFreezeframeComponent],
  imports: [
  ],
  exports: [AngularFreezeframeComponent]
})
export class AngularFreezeframeModule { }