text:
using System.Linq;
using System.Threading.Tasks;
using NUnit.Framework;
using SJP.Schematic.Core;

namespace SJP.Schematic.PostgreSql.Tests.Integration.Versions.V11
{
    internal partial class PostgreSqlRelationalDatabaseTableProviderTests : PostgreSql11Test
    {
        [Test]
        public async Task Triggers_GivenTableWithNoTriggers_ReturnsEmptyCollection()
        {
            var table = await GetTableAsync("v11_trigger_test_table_2").ConfigureAwait(false);

            Assert.That(table.Triggers, Is.Empty);
        }

        [Test]
        public async Task Triggers_GivenTableWithTrigger_ReturnsNonEmptyCollection()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);

            Assert.That(table.Triggers, Is.Not.Empty);
        }

        [Test]
        public async Task Triggers_GivenTableWithTrigger_ReturnsCorrectName()
        {
            Identifier triggerName = "v11_trigger_test_table_1_trigger_1";

            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == triggerName);

            Assert.That(trigger.Name, Is.EqualTo(triggerName));
        }

        [Test]
        public async Task Triggers_GivenTableWithTrigger_ReturnsCorrectDefinition()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_1");

            const string expectedDefinition = "EXECUTE PROCEDURE v11_test_trigger_fn()";

            Assert.That(trigger.Definition, Is.EqualTo(expectedDefinition));
        }

        [Test]
        public async Task Triggers_GivenTableWithTriggerForInsert_ReturnsCorrectEventAndTiming()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_1");

            const TriggerQueryTiming timing = TriggerQueryTiming.Before;
            const TriggerEvent events = TriggerEvent.Insert;

            Assert.Multiple(() =>
            {
                Assert.That(trigger.QueryTiming, Is.EqualTo(timing));
                Assert.That(trigger.TriggerEvent, Is.EqualTo(events));
            });
        }

        [Test]
        public async Task Triggers_GivenTableWithTriggerForUpdate_ReturnsCorrectEventAndTiming()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_2");

            const TriggerQueryTiming timing = TriggerQueryTiming.Before;
            const TriggerEvent events = TriggerEvent.Update;

            Assert.Multiple(() =>
            {
                Assert.That(trigger.QueryTiming, Is.EqualTo(timing));
                Assert.That(trigger.TriggerEvent, Is.EqualTo(events));
            });
        }

        [Test]
        public async Task Triggers_GivenTableWithTriggerForDelete_ReturnsCorrectEventAndTiming()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_3");

            const TriggerQueryTiming timing = TriggerQueryTiming.Before;
            const TriggerEvent events = TriggerEvent.Delete;

            Assert.Multiple(() =>
            {
                Assert.That(trigger.QueryTiming, Is.EqualTo(timing));
                Assert.That(trigger.TriggerEvent, Is.EqualTo(events));
            });
        }

        [Test]
        public async Task Triggers_GivenTableWithTriggerAfterInsert_ReturnsCorrectEventAndTiming()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_4");

            const TriggerQueryTiming timing = TriggerQueryTiming.After;
            const TriggerEvent events = TriggerEvent.Insert;

            Assert.Multiple(() =>
            {
                Assert.That(trigger.QueryTiming, Is.EqualTo(timing));
                Assert.That(trigger.TriggerEvent, Is.EqualTo(events));
            });
        }

        [Test]
        public async Task Triggers_GivenTableWithTriggerAfterUpdate_ReturnsCorrectEventAndTiming()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_5");

            const TriggerQueryTiming timing = TriggerQueryTiming.After;
            const TriggerEvent events = TriggerEvent.Update;

            Assert.Multiple(() =>
            {
                Assert.That(trigger.QueryTiming, Is.EqualTo(timing));
                Assert.That(trigger.TriggerEvent, Is.EqualTo(events));
            });
        }

        [Test]
        public async Task Triggers_GivenTableWithTriggerAfterDelete_ReturnsCorrectEventAndTiming()
        {
            var table = await GetTableAsync("v11_trigger_test_table_1").ConfigureAwait(false);
            var trigger = table.Triggers.First(t => t.Name == "v11_trigger_test_table_1_trigger_6");

            const TriggerQueryTiming timing = TriggerQueryTiming.After;
            const TriggerEvent events = TriggerEvent.Delete;

            Assert.Multiple(() =>
            {
                Assert.That(trigger.QueryTiming, Is.EqualTo(timing));
                Assert.That(trigger.TriggerEvent, Is.EqualTo(events));
            });
        }
    }
}


text:
module LocationHelper

  # Renders the location stack for your view. You can add as many stack levels as you wish.
  #
  # Usage:
  # <%= location(level1,leve2,level3,level4,....) %>
  #
  # Output:
  # base > level1 > level2 > level3 > level 4
  #
  # Default configuration:
  # base => "You are here" ("location.base" on config/locales)
  # separator => ">" ("location.separator" on config/locales)
  #
  # Styles and HTML wrapping:
  # partial => location/_location.html.erb
  #
  # Example:
  # 	Render a location with a two leves depth:
  #
  #   	<%= location(link_to(leve1.name, level1.url),link_to(leve2.name, level2.url)) %>
  #
  def location(*stack)
    location_body = t('location.base')
    stack.collect {|level|
      location_body << t('location.separator') + level
    }

    location_div = capture do
      render :partial => "location/location", :locals=>{:location_body => location_body}
    end

    case request.format
      when Mime::JS
      response = <<-EOJ

          $('#map_location').html("#{ escape_javascript(location_div) }");
          EOJ

      response.html_safe
    else
      content_for(:location) do
        location_div
      end
    end

  end
end

redpajama_set_name: RedPajamaGithub


text:
using Microsoft.VisualStudio.TestTools.UnitTesting;
using safnet.iba.Static;

namespace safnet.iba.UnitTests.Static
{
    [TestClass]
    public class t_Conversion
    {
        [TestMethod]
        public void t_GetDateForWeekNumber_1()
        {
            string expected = "12/27";
            string actual = Conversion.GetDateForWeekNumber(1);
            Assert.AreEqual(expected, actual);
        }

        [TestMethod]
        public void t_GetDateForWeekNumber_16()
        {
            string expected = "4/11";
            string actual = Conversion.GetDateForWeekNumber(16);
            Assert.AreEqual(expected, actual);
        }
    }
}


text:
DROP SEQUENCE IF EXISTS "account"."profile_id_seq" CASCADE;
CREATE SEQUENCE "account"."profile_id_seq" INCREMENT 1 START 1 MAXVALUE 9223372036854775807 MINVALUE 1 CACHE 1;
GRANT USAGE ON SEQUENCE "account"."profile_id_seq" TO "twitter_db_role";


text:
package freemarker.ext.beans;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

import freemarker.ext.beans.BeansWrapper.MethodAppearanceDecision;
import freemarker.ext.beans.BeansWrapper.MethodAppearanceDecisionInput;

class GetlessMethodsAsPropertyGettersRule implements MethodAppearanceFineTuner, SingletonCustomizer {

    static final GetlessMethodsAsPropertyGettersRule INSTANCE = new GetlessMethodsAsPropertyGettersRule();

    // Can't be constructed from outside
    private GetlessMethodsAsPropertyGettersRule() { }

    public void process(
            MethodAppearanceDecisionInput in, MethodAppearanceDecision out) {
        legacyProcess(in.getContainingClass(), in.getMethod(), out);
    }

    /** This only exists as the tests need to call this through the deprecated method too. */
    public void legacyProcess(
            Class clazz, Method m, MethodAppearanceDecision decision) {
        if (m.getDeclaringClass() != Object.class
                && m.getReturnType() != void.class
                && m.getParameterTypes().length == 0) {
            String mName = m.getName();
            if (!looksLikePropertyReadMethod(mName)) {
                decision.setExposeMethodAs(null);
                try {
                    decision.setExposeAsProperty(new PropertyDescriptor(
                            mName, clazz, mName, null));
                } catch (IntrospectionException e) {  // Won't happen...
                    throw new RuntimeException(e);
                }
            }
        }
    }

    private static boolean looksLikePropertyReadMethod(String name) {
        final int verbEnd;
        if (name.startsWith("get")) verbEnd = 3;
        else if (name.startsWith("is")) verbEnd = 2;
        else return false;

        return name.length() == verbEnd || Character.isUpperCase(name.charAt(verbEnd));
    }

}


text:
using System.Collections.Generic;
using System.Threading.Tasks;
using SharedLib;

namespace SteamLib.Models
{
    public interface ISteamReportManager
    {
        /// <summary>
        /// Gets a report
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        Task<ISteamReport> GetReport(long id);

        /// <summary>
        /// Creates or updates a report
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        Task<ISteamReport> GenerateReport(ISteamReportGenerationRequest request);

        /// <summary>
        /// Gets existing reports
        /// </summary>
        /// <param name="timeRange"></param>
        /// <returns></returns>
        Task<IEnumerable<ISteamReport>> GetReports(TimeRange timeRange);

        /// <summary>
        /// Gets existing reports
        /// </summary>
        /// <param name="timeRange"></param>
        /// <param name="userID"></param>
        /// <returns></returns>
        Task<IEnumerable<ISteamReport>> GetReports(TimeRange timeRange, long userID);

        /// <summary>
        /// Re-generates the report
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        Task RefreshReport(long id);

        /// <summary>
        /// Re-generates the report
        /// </summary>
        /// <param name="report"></param>
        /// <returns></returns>
        Task RefreshReport(ISteamReport report);

        /// <summary>
        /// Gets report tempalate
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        Task<ISteamReportTemplate> GetReportTemplate(long id);

        /// <summary>
        /// Gets report subscriptions
        /// </summary>
        /// <returns></returns>
        Task<IEnumerable<ISteamReportSubscription>> GetReportSubscriptions();

        /// <summary>
        /// Gets report subscriptions for user
        /// </summary>
        /// <param name="userID"></param>
        /// <returns></returns>
        Task<IEnumerable<ISteamReportSubscription>> GetReportSubscriptions(long userID);

    }
}


text:
import models     from '../models/models';
import model      from '../models/model';
import sortByDate from '../libs/sortByDate';
import config     from '../config';

export default getDataForMainPage;

async function getDataForMainPage() {
    const page = await model.find(models.Page, {
        pageName : config.get('pageNames:mainPage:pageName')
    });
    const mainSlider  = await model.find(models.MainSlider,       {});
    const whySection  = await model.find(models.WhySection,       {});
    const specialties = await model.find(models.Specialties,      {});
    const teachers    = await model.find(models.Teacher,          {});
    const statistics  = await model.find(models.Numbers,          {});
    const graduates   = await model.find(models.GraduatesSection, {});
    const news        = await model.find(models.NewsSection,      {});
    const articlesArr = await model.find(models.Article,          {});
    const articles    = sortByDate(articlesArr).slice(0, 3);

    const content = {
        whySection: whySection[0],
        specialties: specialties[0],
        statistics: statistics[0],
        graduates: graduates[0],
        news: news[0],
        articles,
        mainSlider,
        teachers
    };

    return {
        page : page[0],
        content
    };
}


text:
package cpJson

import (
	"github.com/v2pro/wombat/generic"
	"github.com/v2pro/wombat/cp"
	"reflect"
)

func init() {
	cp.Anything.ImportFunc(copySliceToJson)
	toJsonMap[reflect.Slice] = "CopySliceToJson"
}

var copySliceToJson = generic.DefineFunc(
	"CopySliceToJson(err *error, dst DT, src ST)").
	Param("DT", "the dst type to copy into").
	Param("ST", "the src type to copy from").
	ImportFunc(cp.Anything).
	Source(`
{{ $cpElem := expand "CopyAnything" "DT" .DT "ST" (.ST|elem) }}
if src == nil {
	dst.WriteNil()
	return
}
dst.WriteArrayStart()
for i, elem := range src {
	if i != 0 {
		dst.WriteMore()
	}
	{{$cpElem}}(err, dst, elem)
}
dst.WriteArrayEnd()
`)


text:
package jp.coppermine.samples.hk2.qualifier;

import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.utilities.ServiceLocatorUtilities;

public class AutomaticAppMain {

    public static void main(String[] args) {
        // Obtain a ServiceLocator object
        ServiceLocator locator = ServiceLocatorUtilities.createAndPopulateServiceLocator();

        // Obtain the value from a Message object and output it
        Greeter greeter = locator.getService(Greeter.class);

        System.out.println("All greetings:");
        greeter.getAll().forEach(System.out::println);

        System.out.println();

        System.out.println("Say: " + greeter.greet());
    }

}


text:
Generate massive amounts of fake data for Intersystems IRIS

The language of data is according to configuration of your Caché (Now works with Pt-Br and En-Us(Default)).

## Valid Types
* Address (Street, Latitude, Longitude, City, State, Capital, Country, Street Suffix, Street Prefix, Postcode, Secondary Address)
* App (Function name)
* Coffee (Blend name, Variety, Notes, Origin)
* Color (Hexadecimal, Name, RGB)
* Commerce (Price, CNPJ, Color, Product, Product Name, Promotion Code)
* Company (Profession, Industry)
* Dates (Forward, Backward)
* DragonBall (Character)
* File (Filename, Extension, MimeType)
* Finance (Amount, Credit Card, Bitcoin Address)
* Game (Card, Mortal Kombat, Street Fighter)
* Internet (Username, Email, Protocol, Domain Word, Domain Name, Avatar, Url, Slug, IPV4, IPV6,MAC Address)
* Job (Title, Skills, Field)
* Lorem (Words, Sentences, Paragraphs, Lines, Text, Hipster)
* Name (First name, Last Name, Full Name, Suffix)
* Person (CPF (Brazilian ID))
* Phone (Area code, Phone number, Cell phone)
* Pokemon (Pokemons)
* StarWars (Character, Droid, Planet, Quote, Specie, Vehicle, Wookie word, Wookie Sentence)
* UFC (Category, Fighter, Fighter by category, Nickname)

## Instalation

To install cosFaker, you just need to import the package cosFaker.vX.X.X.xml file.
You can go to Management Portal -> System Explorer -> Classes -> Import and select the XML file or just drag the file over Studio.
Also, if you like terminal like me, execute:

```
Do $system.OBJ.Load("yourpath/cosFaker.vX.X.X.xml","ck")
```

### Docker ###

To install using Docker. Follow this instructions:

Open terminal and clone/git pull the repo into any local directory

```
$ git clone https://github.com/henryhamon/cosfaker.git
```

Open the terminal in this directory and run:

```
$ docker-compose build
```

Run the IRIS container with your project:
```
$ docker-compose up -d
```

## How to Run the Application
Open InterSystems IRIS terminal:

```
$ docker-compose exec iris iris session iris
USER>zn "IRISAPP"
IRISAPP>Write ##class(cosFaker.Name).FullName()
```

## Usage

### On Populate

You can use on Populate event

```cos
Method OnPopulate() As %Status [ ServerOnly = 1 ]
{
	Set ..Login = ##class(cosFaker.Internet).UserName("John","Doe")
	Set ..Url = ##class(cosFaker.Internet).DomainWord()
}
```
Or on a simple Set

```cos
Set ..Name = ##class(cosFaker.Name).FullName()
```

### SQL Class

You can generate data directly on a table

```cos
Do ##class(cosFaker.SQL).Insert("Sample_Data.Clients","City,Name,Salary","city SC,name 2,price 1000 2000 2 R$",2)
//Same as:
//INSERT INTO Sample_Data.Clients (City,Name,Salary) VALUES ('Celso Ramos','Luiggi Dias Nunes Saraiva','R$1654.30')
//INSERT INTO Sample_Data.Clients (City,Name,Salary) VALUES ('Nova Veneza','Fabiano da Costa','R$1255.13')
```

### JSON Class

You can generate data on JSON string or in an object, only passing a JSON string as shown above.

Examples showing JSON strings populated:
```cos
Write ##class(cosFaker.JSON).GetDataJSONFromJSON("{Nome:'name 2',Cidade:'city SC',CPF:'cpf 1',Description:'slug ""person sample example"" ;'}")
// {
//    "CPF":"661.254.048-62",
//    "Cidade":"Brunópolis",
//    "Nome":"Jonathan Ribeiro Ribeiro",
//    "Description":"person;sample;example"
// }
```

```cos
//Suppose you want a person with name, street, phone and his 3 preferred Pokemons
Write ##class(cosFaker.JSON).GetDataJSONFromJSON("{person:['name','street','phone','3 pokemon']}")
// {"person":
//           [
//              "Yango Nogueira",
//              "Viela General Sirineu Nogueira",
//              "(44) 0968-2926",
//              ["Bayleef","Haunter","Golurk"]
//           ]
// }
```

And example showing Object populated:
```cos
Set person = ##class(cosFaker.JSON).GetDataOBJFromJSON("{name:'name 2',birth:'date',profession:'profession',pokemons:'3 pokemon'}",.tSC)

Write person.name
// Flávio Silveira

Set listOfPokemons = person.pokemons
Write listOfPokemons.GetAt(1)
// Diancie

Write listOfPokemons.Count()
// 3
```


text:
/**
 * Created by yves on 19/09/15.
 */

'use strict';

/**
 * Module dependencies.
 */
var mongoose = require('mongoose'),
    Schema = mongoose.Schema;

/**
 * Activity Schema
 */
var HistorySchema = new Schema({
    username: String,
    date: {
        type:[Date]
    },
    activity: [String]
}, {collection:'histories'});

function History(history) {
    this.username = history.username;
    this.date = history.date;
    this.activity = history.activity;
}

var historyModel = mongoose.model('History', HistorySchema);

/*
 Saves an admin to the admin database
 */
History.prototype.save = function() {
    var history = {
        username: this.username,
        date: this.date,
        activity: this.activity
    };
    var newHistory = new historyModel(history);
    newHistory.save(function(err) {
        if (err) {
            console.error('History save failed [history.server.model.js]');
        }
    });
};

/**
 * Find all histories for a user
 */
History.getAll = function(username, callback) {
    historyModel.find(
        {username: username},
        function(err, doc) {
            if (err) {
                return callback(err);
            }
            callback(null, doc);
        });
};

module.exports = History;
module.exports.historyModel = historyModel;


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2015 Oleg Kan, @Simplaapliko
  ~
  ~ 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.
  -->

<resources>
    <integer name="ar_app_rater_days_until_prompt">7</integer>
    <integer name="ar_app_rater_launches_until_prompt">10</integer>

    <!-- if true RateAppDialog will have buttons (positive, negative and neutral)
         if false then dialog will have a list with choices,
            this could be useful if strings are too to fit the buttons. -->
    <bool name="ar_app_rater_dialog_has_buttons">true</bool>
</resources>


text:
<?php

namespace Tests\Feature\Lib;

use Illuminate\Testing\TestResponse;
use Tests\TestCase;

class SessionUnitTest
{
	/**
	 * Logging in.
	 *
	 * @param TestCase $testCase
	 * @param string   $username
	 * @param string   $password
	 * @param string   $result
	 */
	public function login(
		TestCase &$testCase,
		string $username,
		string $password,
		string $result = 'true'
	) {
		$response = $testCase->json('POST', '/api/Session::login', [
			'username' => $username,
			'password' => $password,
		]);
		$response->assertOk();
		$response->assertSee($result, false);
	}

	/**
	 * @param TestCase $testCase
	 * @param string   $result
	 *
	 * @return TestResponse
	 */
	public function init(
		TestCase &$testCase,
		string $result = 'true'
	) {
		$response = $testCase->json('POST', '/api/Session::init', []);
		$response->assertStatus(200);
		if ($result != 'true') {
			$response->assertSee($result, false);
		}

		return $response;
	}

	/**
	 * Logging out.
	 *
	 * @param TestCase $testCase
	 */
	public function logout(TestCase &$testCase)
	{
		$response = $testCase->json('POST', '/api/Session::logout');
		$response->assertOk();
		$response->assertSee('true');
	}

	/**
	 * Set a new login and password.
	 *
	 * @param TestCase $testCase
	 * @param string   $login
	 * @param string   $password
	 * @param string   $result
	 */
	public function set_new(
		TestCase &$testCase,
		string $login,
		string $password,
		string $result = 'true'
	) {
		$response = $testCase->json('POST', '/api/Settings::setLogin', [
			'username' => $login,
			'password' => $password,
		]);
		$response->assertOk();
		$response->assertSee($result, false);
	}

	/**
	 * Set a new login and password.
	 *
	 * @param TestCase $testCase
	 * @param string   $login
	 * @param string   $password
	 * @param string   $oldUsername
	 * @param string   $oldPassword
	 * @param string   $result
	 */
	public function set_old(
		TestCase &$testCase,
		string $login,
		string $password,
		string $oldUsername,
		string $oldPassword,
		string $result = 'true'
	) {
		$response = $testCase->json('POST', '/api/Settings::setLogin', [
			'username' => $login,
			'password' => $password,
			'oldUsername' => $oldUsername,
			'oldPassword' => $oldPassword,
		]);
		$response->assertOk();
		$response->assertSee($result, false);
	}
}


text:
#include <QtCore/QObject>
#include <QtCore/QUrl>

#include "../../EIRlibs/eirBase/Named.h"
#include "VigilCameraInfoList.h"

class IMVIGILSHARED_EXPORT VigilDvr : public QObject, ImVigil
{
    Q_OBJECT
public:
    explicit VigilDvr(QObject * parent=0);
    ~VigilDvr();
    bool isError(void) const;
    QString errorString(void) const;
    bool login(const QUrl & url);
    bool isLoggedIn(void) const;
    VigilCameraInfoList cameraList(void);
    QString serverName(void);
    QString channelName(const int channelIndex);
    VigilSDK::_CVigilLiveFeed * createLiveFeed(void);
    VigilSDK::_CVigilPlayback * createPlayback(void);

signals:
    void loggedin(bool success);
    void updatedInfo(void);

public slots:
    void updateInfo(void);

private:
    VigilSDK::CVigilDVR * _dvr;
    QString error_s;
    QString serverName_s;
    Named<int> channelName_map;
    VigilCameraInfoList _vcil;
};

#endif // VIGILDVR_H


text:
layout: page
title: "Michael Daniel"
comments: true
description: "blanks"
keywords: "Michael Daniel,CU,Boulder"
---
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
<script src="https://dl.dropboxusercontent.com/s/pc42nxpaw1ea4o9/highcharts.js?dl=0"></script>
<!-- <script src="../assets/js/highcharts.js"></script> -->
<style type="text/css">@font-face {
	font-family: "Bebas Neue";
	src: url(https://www.filehosting.org/file/details/544349/BebasNeue Regular.otf) format("opentype");
	}
	h1.Bebas {
		font-family: "Bebas Neue", Verdana, Tahoma;
	}
</style>
</head>

#### TEACHING INFORMATION

**College**: College of Arts and Sciences

**Classes taught**: MATH 1011, MATH 1012, MATH 1081, MATH 1110, MATH 1150, MATH 1300

#### MATH 1011: College Algebra

**Terms taught**: Fall 2014

**Instructor rating**: 4.14

**Standard deviation in instructor rating**: 0.0

**Average grade** (4.0 scale): 2.4

**Standard deviation in grades** (4.0 scale): 0.0

**Average workload** (raw): 2.45

**Standard deviation in workload** (raw): 0.0

#### MATH 1012: Quantitative Reasoning and Mathematical Skills

**Terms taught**: Spring 2016

**Instructor rating**: 5.45

**Standard deviation in instructor rating**: 0.0

**Average grade** (4.0 scale): 3.11

**Standard deviation in grades** (4.0 scale): 0.0

**Average workload** (raw): 2.0

**Standard deviation in workload** (raw): 0.0

#### MATH 1081: Calculus for Social Science and Business

**Terms taught**: Spring 2015, Spring 2015

**Instructor rating**: 3.35

**Standard deviation in instructor rating**: 0.08

**Average grade** (4.0 scale): 2.88

**Standard deviation in grades** (4.0 scale): 0.02

**Average workload** (raw): 2.52

**Standard deviation in workload** (raw): 0.07

#### MATH 1110: SPIRIT/USES OF MATH 1

**Terms taught**: Fall 2006

**Instructor rating**: 4.25

**Standard deviation in instructor rating**: 0.0

**Average grade** (4.0 scale): 3.07

**Standard deviation in grades** (4.0 scale): 0.0

**Average workload** (raw): 2.43

**Standard deviation in workload** (raw): 0.0

#### MATH 1150: Precalculus Mathematics

**Terms taught**: Fall 2014

**Instructor rating**: 3.65

**Standard deviation in instructor rating**: 0.0

**Average grade** (4.0 scale): 2.79

**Standard deviation in grades** (4.0 scale): 0.0

**Average workload** (raw): 2.83

**Standard deviation in workload** (raw): 0.0

#### MATH 1300: Calculus 1

**Terms taught**: Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015, Spring 2015

**Instructor rating**: 5.12

**Standard deviation in instructor rating**: 0.33

**Average grade** (4.0 scale): 2.24

**Standard deviation in grades** (4.0 scale): 0.29

**Average workload** (raw): 3.35

**Standard deviation in workload** (raw): 0.28


text:
#include <folly/SafeAssert.h>

#include <folly/Conv.h>
#include <folly/FileUtil.h>

namespace folly { namespace detail {

namespace {
void writeStderr(const char* s, size_t len) {
  writeFull(STDERR_FILENO, s, len);
}
void writeStderr(const char* s) {
  writeStderr(s, strlen(s));
}
}  // namespace

void assertionFailure(const char* expr, const char* msg, const char* file,
                      unsigned int line, const char* function) {
  writeStderr("\n\nAssertion failure: ");
  writeStderr(expr + 1, strlen(expr) - 2);
  writeStderr("\nMessage: ");
  writeStderr(msg);
  writeStderr("\nFile: ");
  writeStderr(file);
  writeStderr("\nLine: ");
  char buf[20];
  uint32_t n = uint64ToBufferUnsafe(line, buf);
  writeFull(STDERR_FILENO, buf, n);
  writeStderr("\nFunction: ");
  writeStderr(function);
  writeStderr("\n");
  fsyncNoInt(STDERR_FILENO);
  abort();
}

}}  // namespaces


text:
package com.iliev.peter.kata.conventions;

public interface ISortTestSet {

	Integer[] getSortedSet();

	Integer[][] getUnsortedSets();
}


text:
SET NAMES utf8;
SET time_zone = '+00:00';
SET foreign_key_checks = 0;
SET sql_mode = 'NO_AUTO_VALUE_ON_ZERO';

SET NAMES utf8mb4;

DROP TABLE IF EXISTS `category`;
CREATE TABLE `category` (
  `id`    INT(11)                  NOT NULL AUTO_INCREMENT,
  `title` VARCHAR(255)
          COLLATE utf8mb4_czech_ci NOT NULL,
  PRIMARY KEY (`id`)
)
  ENGINE = InnoDB
  AUTO_INCREMENT = 2
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_czech_ci;

INSERT INTO `category` (`id`, `title`) VALUES
  (1, 'Nová kategorie');


text:
from __future__ import unicode_literals

from django.db import migrations

class Migration(migrations.Migration):

    dependencies = [("order", "0001_initial")]

    operations = [
        migrations.AlterModelOptions(name="payment", options={"ordering": ("-pk",)})
    ]


text:
package metadata

import (
	"encoding/json"
	"github.com/robfig/revel"
	"gollery/app/common"
	"gollery/monitor"
	"gollery/utils"
	"os"
	"path"
	"path/filepath"
	"sync"
)

const (
	METADATA_FILENAME = ".gollery.metadata"
)

type FSMetadataManager struct {
	RootDir       string
	monitor       *monitor.Monitor
	monitorEvents chan monitor.Event
	data          map[string]*AlbumMetadata
	dataMutex     sync.Mutex
}

func (m *FSMetadataManager) indexAlbumMetadataFile(filePath string) error {
	fd, err := os.Open(filePath)

	if err != nil {
		return utils.WrapError(err, "Cannot open metadata file for reading")
	}

	defer fd.Close()

	data := &AlbumMetadata{}

	err = json.NewDecoder(fd).Decode(data)

	if err != nil {
		return utils.WrapError(err, "Cannot decode album metadata")
	}

	m.dataMutex.Lock()
	defer m.dataMutex.Unlock()
	m.data[common.AlbumNameFromFile(filePath)] = data

	return nil
}

func (m *FSMetadataManager) getMetadata(album string) *AlbumMetadata {
	m.dataMutex.Lock()
	defer m.dataMutex.Unlock()
	return m.data[album]
}

func (m *FSMetadataManager) deleteMetadata(album string) {
	m.dataMutex.Lock()
	defer m.dataMutex.Unlock()
	delete(m.data, album)
}

func (m *FSMetadataManager) monitorEventsRoutine() {
	for x := range m.monitorEvents {
		if basename := path.Base(x.Path()); basename != METADATA_FILENAME {
			continue
		}

		if ev, ok := x.(*monitor.DeleteEvent); ok {
			var albumName string

			if ev.IsDirectory {
				// An album was deleted, drop the metadata
				albumName = common.AlbumNameFromDir(ev.Path())
			} else if fileName := path.Base(ev.Path()); fileName == METADATA_FILENAME {
				albumName = common.AlbumNameFromFile(ev.Path())
			}

			revel.INFO.Printf("Deleted album metadata for %s", albumName)
			m.deleteMetadata(albumName)
		}

		if ev, ok := x.(*monitor.CreateEvent); ok {
			var metadataFilePath string

			if ev.Info.Mode().IsRegular() {
				metadataFilePath = ev.Path()
			} else if ev.Info.IsDir() {
				metadataFilePath = path.Join(ev.Path(), METADATA_FILENAME)

				_, err := os.Stat(metadataFilePath)

				if os.IsNotExist(err) {
					continue
				}

				if err != nil {
					revel.ERROR.Printf("Cannot check for metadata file presence in dir %s: %s", ev.Path(), err)
					continue
				}
			}

			if metadataFilePath == "" {
				continue
			}

			revel.INFO.Printf("(re)Indexing metadata file %s", metadataFilePath)

			err := m.indexAlbumMetadataFile(metadataFilePath)

			if err != nil {
				revel.ERROR.Printf("Cannot parse album metadata for file %s: %s", metadataFilePath, err)
			}

			revel.INFO.Printf("Indexed album metadata %s", metadataFilePath)
		}
	}
}

func (m *FSMetadataManager) walkAlbumMetadata(filePath string, info os.FileInfo, err error) error {
	if err != nil {
		return filepath.SkipDir
	}

	if !info.Mode().IsRegular() {
		return nil
	}

	if info.Name() != METADATA_FILENAME {
		return nil
	}

	// Metadata is only for albums
	if info.Name() == path.Join(m.RootDir, METADATA_FILENAME) {
		return nil
	}

	err = m.indexAlbumMetadataFile(filePath)

	if err != nil {
		revel.ERROR.Printf("Error while reading album metadata %s: %s (skipping)", filePath, err)
	}

	return nil
}

func NewFSMetadataManager(rootDir string, mon *monitor.Monitor) (*FSMetadataManager, error) {
	m := &FSMetadataManager{
		RootDir:       rootDir,
		monitor:       mon,
		monitorEvents: make(chan monitor.Event, 100),
		data:          map[string]*AlbumMetadata{},
	}

	mon.Listen(m.monitorEvents)

	go m.monitorEventsRoutine()

	go func() {
		err := filepath.Walk(rootDir, m.walkAlbumMetadata)

		if err != nil {
			revel.ERROR.Printf("Error while walking the albums for metadata: %s", err)
		}
	}()

	return m, nil
}

func (m *FSMetadataManager) GetAlbumSecretToken(album string) string {
	metadata := m.getMetadata(album)

	if metadata == nil {
		return ""
	}

	return metadata.SecretToken
}

func (m *FSMetadataManager) IsAlbumPublic(album string) bool {
	metadata := m.getMetadata(album)

	return metadata == nil || metadata.Public
}


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>
//------------------------------------------------------------------------------

namespace SIM.Properties {
    using System;

    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class BResources {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal BResources() {
        }

        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SIM.Properties.BResources", typeof(BResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }

        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Please choose any one of the following backups:.
        /// </summary>
        public static string ChooseBackup {
            get {
                return ResourceManager.GetString("ChooseBackup", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' database already exists.
        /// </summary>
        public static string DatabaseAlreadyExists {
            get {
                return ResourceManager.GetString("DatabaseAlreadyExists", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0} xml element is missing.
        /// </summary>
        public static string ElementMissing {
            get {
                return ResourceManager.GetString("ElementMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Something wrong with extracted files.
        /// </summary>
        public static string ExtractedDataIsWrong {
            get {
                return ResourceManager.GetString("ExtractedDataIsWrong", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' file is missing.
        /// </summary>
        public static string FileIsMissing {
            get {
                return ResourceManager.GetString("FileIsMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' folder already contains subfolder with the '{1}' name.
        /// </summary>
        public static string FolderContainsSubfolder {
            get {
                return ResourceManager.GetString("FolderContainsSubfolder", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The location folder path must be physical i.e. contain a drive letter. Please choose another location folder.
        /// </summary>
        public static string FolderNotPhysical {
            get {
                return ResourceManager.GetString("FolderNotPhysical", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The \Website\App_Config\Include folder doesn't exist.
        /// </summary>
        public static string IncludeFolderNotExist {
            get {
                return ResourceManager.GetString("IncludeFolderNotExist", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' instance can't be found.
        /// </summary>
        public static string InstanceNotFound {
            get {
                return ResourceManager.GetString("InstanceNotFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Default Root Folder isn't specified in the Settings dialog.
        /// </summary>
        public static string InstancesFolderIsMissing {
            get {
                return ResourceManager.GetString("InstancesFolderIsMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to License isn't specified in the Settings dialog.
        /// </summary>
        public static string LicenseIsMissing {
            get {
                return ResourceManager.GetString("LicenseIsMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Sitecore installs isn't specified in the Settings dialog.
        /// </summary>
        public static string LocalRepositoryIsMissing {
            get {
                return ResourceManager.GetString("LocalRepositoryIsMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to There is no backups to restore.
        /// </summary>
        public static string NoBackupsToRestore {
            get {
                return ResourceManager.GetString("NoBackupsToRestore", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' product zip install package can't be found.
        /// </summary>
        public static string ProductPackageNotFound {
            get {
                return ResourceManager.GetString("ProductPackageNotFound", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Restoring isn't possible due to missing backup files.
        /// </summary>
        public static string RestoringNotPossibleDueToMissingBackupFiles {
            get {
                return ResourceManager.GetString("RestoringNotPossibleDueToMissingBackupFiles", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to SQL Connection String isn't set in the Settings dialog.
        /// </summary>
        public static string SqlConnectionStringIsMissing {
            get {
                return ResourceManager.GetString("SqlConnectionStringIsMissing", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The website with the same name already exists, please choose another instance name..
        /// </summary>
        public static string WebsiteAlreadyExists {
            get {
                return ResourceManager.GetString("WebsiteAlreadyExists", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The '{0}' xml file is not well-formatted.
        /// </summary>
        public static string XmlFileIsCorrupted {
            get {
                return ResourceManager.GetString("XmlFileIsCorrupted", resourceCulture);
            }
        }
    }
}


text:
module UserManipulator
  extend ActiveSupport::Concern

  def promote_user!(params)
    raise PermissionError.new unless super_admin?
    return unless ["admin", "super_admin"].include? params[:role]
    user = User.find params[:id]
    return if user.super_admin?
    user.role = params[:role]
    user.save!
  end

  module Anonymous
    extend ActiveSupport::Concern

    def promote_user!(params)
      raise PermissionError.new
    end
  end
end


text:
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**title** | **str** | Title for API Key. |
**expires** | **datetime** | The date the API key expired. |
**platform** | **str** | The third-party platform the API key is valid for. Use `none` for a generic API key to be used from your own integration layer.  | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)


text:
Imports System.Data
Imports cusAplicacion
Partial Class rAuditorias_Usuarios_Auto
    Inherits vis2formularios.frmReporteAutomatico
    'Inherits vis2formularios.frmReporte

    Dim loObjetoReporte As CrystalDecisions.CrystalReports.Engine.ReportDocument

    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

        'Try

        Dim lcParametro0Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(0), goServicios.enuOpcionesRedondeo.KN_FechaInicioDelDia)
        Dim lcParametro0Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(0), goServicios.enuOpcionesRedondeo.KN_FechaFinDelDia)
        Dim lcParametro1Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(1))
        Dim lcParametro1Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(1))
        Dim lcParametro2Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(2))
        Dim lcParametro2Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(2))
        Dim lcParametro3Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(3))
        Dim lcParametro3Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(3))
        Dim lcParametro4Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(4))
        Dim lcParametro4Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(4))
        Dim lcParametro5Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(5))
        Dim lcParametro5Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(5))
        Dim lcParametro6Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(6))
        Dim lcParametro6Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(6))

        Dim lcOrdenamiento As String = cusAplicacion.goReportes.pcOrden
        Dim loComandoSeleccionar As New StringBuilder()

        loComandoSeleccionar.AppendLine(" SELECT Cod_Usu, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Apertura'	THEN 1 ELSE 0 END)) As Apertura, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Agregar'	    THEN 1 ELSE 0 END)) As Agregar, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Anular'		THEN 1 ELSE 0 END)) As Anular, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Eliminar'	THEN 1 ELSE 0 END)) As Eliminar, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Modificar' OR Accion = 'Confirmar' OR Accion = 'Reversar'    THEN 1 ELSE 0 END)) As Modificar, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Reporte'	OR Accion = 'Formato'	THEN 1 ELSE 0 END)) As Reporte, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = ''	THEN 1 ELSE 0 END)) As Vacio, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Importar'	THEN 1 ELSE 0 END)) As Importar, ")
        loComandoSeleccionar.AppendLine(" 			SUM((CASE WHEN Accion = 'Procesar'	THEN 1 ELSE 0 END)) As Procesar, ")
        loComandoSeleccionar.AppendLine(" 			SUM(1) As TotalReporte ")
        loComandoSeleccionar.AppendLine(" FROM Auditorias ")
        loComandoSeleccionar.AppendLine(" WHERE Registro Between " & lcParametro0Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro0Hasta)
        loComandoSeleccionar.AppendLine(" 			And Cod_Usu Between " & lcParametro1Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro1Hasta)
        loComandoSeleccionar.AppendLine(" 			And Tabla Between " & lcParametro2Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro2Hasta)
        loComandoSeleccionar.AppendLine(" 			And Opcion Between " & lcParametro3Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro3Hasta)
        loComandoSeleccionar.AppendLine(" 			And Documento Between " & lcParametro4Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro4Hasta)
        loComandoSeleccionar.AppendLine(" 			And Codigo Between " & lcParametro5Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro5Hasta)
        loComandoSeleccionar.AppendLine(" 			And Cod_Emp Between " & lcParametro6Desde)
        loComandoSeleccionar.AppendLine(" 			And " & lcParametro6Hasta)
        loComandoSeleccionar.AppendLine(" GROUP BY  Auditorias.Cod_Usu ")
        loComandoSeleccionar.AppendLine(" ORDER BY " & lcOrdenamiento)

        Dim loServicios As New cusDatos.goDatos

        Dim laDatosReporte As DataSet = loServicios.mObtenerTodosSinEsquema(loComandoSeleccionar.ToString(), "curReportes")

        '-------------------------------------------------------------------------------------------------------
        ' Verificando si el select (tabla nº0) trae registros
        '-------------------------------------------------------------------------------------------------------
        If (laDatosReporte.Tables(0).Rows.Count <= 0) Then
            Me.WbcAdministradorMensajeModal.mMostrarMensajeModal("Información", _
                                      "No se Encontraron Registros para los Parámetros Especificados. ", _
                                       vis3Controles.wbcAdministradorMensajeModal.enumTipoMensaje.KN_Informacion, _
                                       "350px", _
                                       "200px")
        End If

        loObjetoReporte = cusAplicacion.goReportes.mCargarReporte("rAuditorias_Usuarios_Auto", laDatosReporte)

        Me.mTraducirReporte(loObjetoReporte)

        Me.mFormatearCamposReporte(loObjetoReporte)

        Me.crvrAuditorias_Usuarios_Auto.ReportSource = loObjetoReporte

        'Catch loExcepcion As Exception
        '
        '   Me.WbcAdministradorMensajeModal.mMostrarMensajeModal("Error", _
        '                 "No se pudo Completar el Proceso: " & loExcepcion.Message, _
        '                 vis3Controles.wbcAdministradorMensajeModal.enumTipoMensaje.KN_Error, _
        '                "auto", _
        '               "auto")
        '
        'End Try

    End Sub

    Protected Sub Page_Unload(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Unload

        Try

            loObjetoReporte.Close()

        Catch loExcepcion As Exception

        End Try

    End Sub

End Class
'-------------------------------------------------------------------------------------------'
' Fin del codigo
'-------------------------------------------------------------------------------------------'
' EAG: 31/07/15: Codigo inicial
'-------------------------------------------------------------------------------------------'


text:
// Copyright 2013 The Closure Library Authors. All Rights Reserved.
//
// 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.

goog.module('goog.labs.i18n.ListFormatTest');
goog.setTestOnly();

const GenderInfo = goog.require('goog.labs.i18n.GenderInfo');
const ListFormat = goog.require('goog.labs.i18n.ListFormat');
/** @suppress {extraRequire} */
const ListFormatSymbols = goog.require('goog.labs.i18n.ListFormatSymbols');
const ListFormatSymbols_el = goog.require('goog.labs.i18n.ListFormatSymbols_el');
const ListFormatSymbols_en = goog.require('goog.labs.i18n.ListFormatSymbols_en');
const ListFormatSymbols_fr = goog.require('goog.labs.i18n.ListFormatSymbols_fr');
const ListFormatSymbols_ml = goog.require('goog.labs.i18n.ListFormatSymbols_ml');
const ListFormatSymbols_zu = goog.require('goog.labs.i18n.ListFormatSymbols_zu');
const testSuite = goog.require('goog.testing.testSuite');

testSuite({
  setUp() {
    // Always switch back to English on before the next test.
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;
  },

  testListFormatterArrayDirect() {
    const fmt = new ListFormat();
    assertEquals('One', fmt.format(['One']));
    assertEquals('One and Two', fmt.format(['One', 'Two']));
    assertEquals('One, Two, and Three', fmt.format(['One', 'Two', 'Three']));
    assertEquals(
        'One, Two, Three, Four, Five, and Six',
        fmt.format(['One', 'Two', 'Three', 'Four', 'Five', 'Six']));
  },

  testListFormatterArrayIndirect() {
    const fmt = new ListFormat();

    const items = [];

    items.push('One');
    assertEquals('One', fmt.format(items));

    items.push('Two');
    assertEquals('One and Two', fmt.format(items));
    items.push('Three');
    assertEquals('One, Two, and Three', fmt.format(items));

    items.push('Four');
    items.push('Five');
    items.push('Six');
    assertEquals('One, Two, Three, Four, Five, and Six', fmt.format(items));
  },

  testListFormatterFrench() {
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_fr;

    const fmt = new ListFormat();
    assertEquals('One', fmt.format(['One']));
    assertEquals('One et Two', fmt.format(['One', 'Two']));
    assertEquals('One, Two et Three', fmt.format(['One', 'Two', 'Three']));
    assertEquals(
        'One, Two, Three, Four, Five et Six',
        fmt.format(['One', 'Two', 'Three', 'Four', 'Five', 'Six']));

    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;
  },

  // Malayalam and Zulu are the only two locales with pathers
  // different than '{0} sometext {1}'
  testListFormatterSpecialLanguages() {
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_ml;
    const fmt_ml = new ListFormat();
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_zu;
    const fmt_zu = new ListFormat();
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;

    // Only the end pattern is special with Malayalam
    // Escaped for safety, the string is 'One, Two, Three എന്നിവ'
    assertEquals(
        'One, Two, Three \u0D0E\u0D28\u0D4D\u0D28\u0D3F\u0D35',
        fmt_ml.format(['One', 'Two', 'Three']));

    // Only the two items pattern is special with Zulu
    assertEquals('One ne-Two', fmt_zu.format(['One', 'Two']));
  },

  testVariousObjectTypes() {
    const fmt = new ListFormat();
    const booleanObject = new Boolean(1);
    const arrayObject = ['black', 'white'];
    // Not sure how "flaky" this is. Firefox and Chrome give the same results,
    // but I am not sure if the JavaScript standard specifies exactly what
    // Array toString does, for instance.
    assertEquals(
        'One, black,white, 42, true, and Five',
        fmt.format(['One', arrayObject, 42, booleanObject, 'Five']));
  },

  testListGendersNeutral() {
    const Gender = GenderInfo.Gender;

    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;
    const listGen = new GenderInfo();

    assertEquals(Gender.MALE, listGen.getListGender([Gender.MALE]));
    assertEquals(Gender.FEMALE, listGen.getListGender([Gender.FEMALE]));
    assertEquals(Gender.OTHER, listGen.getListGender([Gender.OTHER]));

    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.MALE, Gender.MALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.FEMALE, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.OTHER, Gender.OTHER]));

    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.OTHER, Gender.MALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.FEMALE, Gender.MALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.OTHER, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.FEMALE, Gender.OTHER]));

    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.MALE, Gender.FEMALE, Gender.OTHER]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.MALE, Gender.OTHER, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.FEMALE, Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.FEMALE, Gender.OTHER, Gender.MALE]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.OTHER, Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.OTHER, Gender.FEMALE, Gender.MALE]));
  },

  testListGendersMaleTaints() {
    const Gender = GenderInfo.Gender;

    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_fr;
    const listGen = new GenderInfo();
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;

    assertEquals(Gender.MALE, listGen.getListGender([Gender.MALE]));
    assertEquals(Gender.FEMALE, listGen.getListGender([Gender.FEMALE]));
    assertEquals(Gender.OTHER, listGen.getListGender([Gender.OTHER]));

    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.MALE]));
    assertEquals(
        Gender.FEMALE, listGen.getListGender([Gender.FEMALE, Gender.FEMALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.OTHER, Gender.OTHER]));

    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.OTHER, Gender.MALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.FEMALE, Gender.MALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.OTHER, Gender.FEMALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.FEMALE, Gender.OTHER]));

    assertEquals(
        Gender.MALE,
        listGen.getListGender([Gender.MALE, Gender.FEMALE, Gender.OTHER]));
    assertEquals(
        Gender.MALE,
        listGen.getListGender([Gender.MALE, Gender.OTHER, Gender.FEMALE]));
    assertEquals(
        Gender.MALE,
        listGen.getListGender([Gender.FEMALE, Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.MALE,
        listGen.getListGender([Gender.FEMALE, Gender.OTHER, Gender.MALE]));
    assertEquals(
        Gender.MALE,
        listGen.getListGender([Gender.OTHER, Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.MALE,
        listGen.getListGender([Gender.OTHER, Gender.FEMALE, Gender.MALE]));
  },

  testListGendersMixedNeutral() {
    const Gender = GenderInfo.Gender;

    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_el;
    const listGen = new GenderInfo();
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;

    assertEquals(Gender.MALE, listGen.getListGender([Gender.MALE]));
    assertEquals(Gender.FEMALE, listGen.getListGender([Gender.FEMALE]));
    assertEquals(Gender.OTHER, listGen.getListGender([Gender.OTHER]));

    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.MALE]));
    assertEquals(
        Gender.FEMALE, listGen.getListGender([Gender.FEMALE, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.OTHER, Gender.OTHER]));

    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.OTHER, Gender.MALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.FEMALE, Gender.MALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.OTHER, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER, listGen.getListGender([Gender.FEMALE, Gender.OTHER]));

    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.MALE, Gender.FEMALE, Gender.OTHER]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.MALE, Gender.OTHER, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.FEMALE, Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.FEMALE, Gender.OTHER, Gender.MALE]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.OTHER, Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.OTHER,
        listGen.getListGender([Gender.OTHER, Gender.FEMALE, Gender.MALE]));
  },

  testListGendersVariousCallTypes() {
    const Gender = GenderInfo.Gender;

    // Using French because with English the results are mostly Gender.OTHER
    // so we can detect fewer problems
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_fr;
    const listGen = new GenderInfo();
    goog.labs.i18n.ListFormatSymbols = ListFormatSymbols_en;

    // Anynymous Arrays
    assertEquals(Gender.MALE, listGen.getListGender([Gender.MALE]));
    assertEquals(Gender.FEMALE, listGen.getListGender([Gender.FEMALE]));
    assertEquals(Gender.OTHER, listGen.getListGender([Gender.OTHER]));

    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.MALE]));
    assertEquals(
        Gender.FEMALE, listGen.getListGender([Gender.FEMALE, Gender.FEMALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.OTHER, Gender.OTHER]));

    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.FEMALE]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.MALE, Gender.OTHER]));
    assertEquals(
        Gender.MALE, listGen.getListGender([Gender.FEMALE, Gender.OTHER]));

    // Arrays
    const arrayM = [Gender.MALE];
    const arrayF = [Gender.FEMALE];
    const arrayO = [Gender.OTHER];

    const arrayMM = [Gender.MALE, Gender.MALE];
    const arrayFF = [Gender.FEMALE, Gender.FEMALE];
    const arrayOO = [Gender.OTHER, Gender.OTHER];

    const arrayMF = [Gender.MALE, Gender.FEMALE];
    const arrayMO = [Gender.MALE, Gender.OTHER];
    const arrayFO = [Gender.FEMALE, Gender.OTHER];

    assertEquals(Gender.MALE, listGen.getListGender(arrayM));
    assertEquals(Gender.FEMALE, listGen.getListGender(arrayF));
    assertEquals(Gender.OTHER, listGen.getListGender(arrayO));

    assertEquals(Gender.MALE, listGen.getListGender(arrayMM));
    assertEquals(Gender.FEMALE, listGen.getListGender(arrayFF));
    assertEquals(Gender.MALE, listGen.getListGender(arrayOO));

    assertEquals(Gender.MALE, listGen.getListGender(arrayMF));
    assertEquals(Gender.MALE, listGen.getListGender(arrayMO));
    assertEquals(Gender.MALE, listGen.getListGender(arrayFO));
  },
});


text:
package com.intellij.codeInspection.deprecation;

import com.intellij.codeInsight.AnnotationUtil;
import com.intellij.codeInsight.daemon.JavaErrorMessages;
import com.intellij.codeInsight.daemon.impl.analysis.HighlightMessageUtil;
import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil;
import com.intellij.codeInspection.BaseJavaBatchLocalInspectionTool;
import com.intellij.codeInspection.LocalQuickFix;
import com.intellij.codeInspection.ProblemHighlightType;
import com.intellij.codeInspection.ProblemsHolder;
import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel;
import com.intellij.lang.annotation.HighlightSeverity;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.util.TextRange;
import com.intellij.pom.java.LanguageLevel;
import com.intellij.psi.*;
import com.intellij.psi.impl.JavaConstantExpressionEvaluator;
import com.intellij.psi.impl.PsiImplUtil;
import com.intellij.psi.infos.MethodCandidateInfo;
import com.intellij.psi.javadoc.PsiDocComment;
import com.intellij.psi.javadoc.PsiDocTag;
import com.intellij.psi.util.*;
import com.intellij.refactoring.util.RefactoringChangeUtil;
import com.intellij.util.ObjectUtils;
import one.util.streamex.MoreCollectors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;

abstract class DeprecationInspectionBase extends BaseJavaBatchLocalInspectionTool {
  public boolean IGNORE_IN_SAME_OUTERMOST_CLASS;

  @Override
  public boolean isEnabledByDefault() {
    return true;
  }

  protected static class DeprecationElementVisitor extends JavaElementVisitor {
    private final ProblemsHolder myHolder;
    private final boolean myIgnoreInsideDeprecated;
    private final boolean myIgnoreAbstractDeprecatedOverrides;
    private final boolean myIgnoreImportStatements;
    private final boolean myIgnoreMethodsOfDeprecated;
    private final boolean myIgnoreInSameOutermostClass;
    private final boolean myForRemoval;
    private final ProblemHighlightType myHighlightType;

    DeprecationElementVisitor(@NotNull ProblemsHolder holder,
                              boolean ignoreInsideDeprecated,
                              boolean ignoreAbstractDeprecatedOverrides,
                              boolean ignoreImportStatements,
                              boolean ignoreMethodsOfDeprecated,
                              boolean ignoreInSameOutermostClass,
                              boolean forRemoval,
                              @Nullable HighlightSeverity severity) {
      myHolder = holder;
      myIgnoreInsideDeprecated = ignoreInsideDeprecated;
      myIgnoreAbstractDeprecatedOverrides = ignoreAbstractDeprecatedOverrides;
      myIgnoreImportStatements = ignoreImportStatements;
      myIgnoreMethodsOfDeprecated = ignoreMethodsOfDeprecated;
      myIgnoreInSameOutermostClass = ignoreInSameOutermostClass;
      myForRemoval = forRemoval;
      myHighlightType = forRemoval && severity == HighlightSeverity.ERROR
                        ? ProblemHighlightType.LIKE_MARKED_FOR_REMOVAL
                        : ProblemHighlightType.LIKE_DEPRECATED;
    }

    @Override
    public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
      JavaResolveResult result = reference.advancedResolve(true);
      PsiElement resolved = result.getElement();
      checkDeprecated(resolved, reference.getReferenceNameElement(), null, myIgnoreInsideDeprecated, myIgnoreImportStatements,
                      myIgnoreMethodsOfDeprecated, myIgnoreInSameOutermostClass, myHolder, myForRemoval, myHighlightType);
    }

    @Override
    public void visitImportStaticStatement(PsiImportStaticStatement statement) {
      PsiFile file = statement.getContainingFile();
      if (file instanceof PsiJavaFile && ((PsiJavaFile)file).getLanguageLevel().isAtLeast(LanguageLevel.JDK_1_9)) return;
      final PsiJavaCodeReferenceElement importReference = statement.getImportReference();
      if (importReference != null) {
        PsiElement resolved = importReference.resolve();
        checkDeprecated(resolved, importReference.getReferenceNameElement(), null, myIgnoreInsideDeprecated,
                        false, true, myIgnoreInSameOutermostClass, myHolder, myForRemoval, myHighlightType);
      }
    }

    @Override
    public void visitReferenceExpression(PsiReferenceExpression expression) {
      visitReferenceElement(expression);
    }

    @Override
    public void visitNewExpression(PsiNewExpression expression) {
      PsiType type = expression.getType();
      PsiExpressionList list = expression.getArgumentList();
      if (!(type instanceof PsiClassType)) return;
      PsiClassType.ClassResolveResult typeResult = ((PsiClassType)type).resolveGenerics();
      PsiClass aClass = typeResult.getElement();
      if (aClass == null) return;
      if (aClass instanceof PsiAnonymousClass) {
        type = ((PsiAnonymousClass)aClass).getBaseClassType();
        typeResult = ((PsiClassType)type).resolveGenerics();
        aClass = typeResult.getElement();
        if (aClass == null) return;
      }
      final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(expression.getProject()).getResolveHelper();
      final PsiMethod[] constructors = aClass.getConstructors();
      if (constructors.length > 0 && list != null) {
        JavaResolveResult[] results = resolveHelper.multiResolveConstructor((PsiClassType)type, list, list);
        MethodCandidateInfo result = null;
        if (results.length == 1) result = (MethodCandidateInfo)results[0];

        PsiMethod constructor = result == null ? null : result.getElement();
        if (constructor != null && expression.getClassOrAnonymousClassReference() != null) {
          if (expression.getClassReference() == null && constructor.getParameterList().getParametersCount() == 0) return;
          checkDeprecated(constructor, expression.getClassOrAnonymousClassReference(), null, myIgnoreInsideDeprecated,
                          myIgnoreImportStatements, true, myIgnoreInSameOutermostClass, myHolder, myForRemoval, myHighlightType);
        }
      }
    }

    @Override
    public void visitMethod(PsiMethod method) {
      MethodSignatureBackedByPsiMethod methodSignature = MethodSignatureBackedByPsiMethod.create(method, PsiSubstitutor.EMPTY);
      if (!method.isConstructor()) {
        List<MethodSignatureBackedByPsiMethod> superMethodSignatures = method.findSuperMethodSignaturesIncludingStatic(true);
        checkMethodOverridesDeprecated(methodSignature, superMethodSignatures, myIgnoreAbstractDeprecatedOverrides, myHolder, myForRemoval,
                                       myHighlightType);
      }
      else {
        checkImplicitCallToSuper(method);
      }
    }

    private void checkImplicitCallToSuper(PsiMethod method) {
      final PsiClass containingClass = method.getContainingClass();
      assert containingClass != null;
      final PsiClass superClass = containingClass.getSuperClass();
      if (hasDefaultDeprecatedConstructor(superClass, myForRemoval)) {
        if (superClass instanceof PsiAnonymousClass) {
          final PsiExpressionList argumentList = ((PsiAnonymousClass)superClass).getArgumentList();
          if (argumentList != null && argumentList.getExpressions().length > 0) return;
        }
        final PsiCodeBlock body = method.getBody();
        if (body != null) {
          final PsiStatement[] statements = body.getStatements();
          if (statements.length == 0 || !JavaHighlightUtil.isSuperOrThisCall(statements[0], true, true)) {
            registerDefaultConstructorProblem(superClass, method.getNameIdentifier(), false);
          }
        }
      }
    }

    private void registerDefaultConstructorProblem(PsiClass superClass, PsiElement nameIdentifier, boolean asDeprecated) {
      String description =
        JavaErrorMessages.message(myForRemoval ? "marked.for.removal.default.constructor" : "deprecated.default.constructor",
                                  superClass.getQualifiedName());
      ProblemHighlightType type = asDeprecated ? myHighlightType : ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
      myHolder.registerProblem(nameIdentifier, getDescription(description, myForRemoval, myHighlightType), type);
    }

    @Override
    public void visitClass(PsiClass aClass) {
      if (aClass instanceof PsiTypeParameter) return;
      final PsiMethod[] currentConstructors = aClass.getConstructors();
      if (currentConstructors.length == 0) {
        final PsiClass superClass = aClass.getSuperClass();
        if (hasDefaultDeprecatedConstructor(superClass, myForRemoval)) {
          final boolean isAnonymous = aClass instanceof PsiAnonymousClass;
          if (isAnonymous) {
            final PsiExpressionList argumentList = ((PsiAnonymousClass)aClass).getArgumentList();
            if (argumentList != null && argumentList.getExpressions().length > 0) return;
          }
          registerDefaultConstructorProblem(superClass,
                                            isAnonymous ? ((PsiAnonymousClass)aClass).getBaseClassReference() : aClass.getNameIdentifier(),
                                            isAnonymous);
        }
      }
    }

    @Override
    public void visitRequiresStatement(PsiRequiresStatement statement) {
      PsiJavaModuleReferenceElement refElement = statement.getReferenceElement();
      if (refElement != null) {
        PsiPolyVariantReference ref = refElement.getReference();
        PsiElement target = ref != null ? ref.resolve() : null;
        if (target instanceof PsiJavaModule &&
            isMarkedForRemoval((PsiJavaModule)target, myForRemoval) &&
            PsiImplUtil.isDeprecatedByAnnotation((PsiJavaModule)target)) {
          String description = JavaErrorMessages.message(myForRemoval ? "marked.for.removal.symbol" : "deprecated.symbol",
                                                         HighlightMessageUtil.getSymbolName(target));
          myHolder.registerProblem(refElement, getDescription(description, myForRemoval, myHighlightType), myHighlightType);
        }
      }
    }
  }

  private static boolean hasDefaultDeprecatedConstructor(PsiClass superClass, boolean forRemoval) {
    return superClass != null && Arrays.stream(superClass.getConstructors())
      .anyMatch(constructor -> constructor.getParameterList().getParametersCount() == 0 &&
                               constructor.isDeprecated() &&
                               isMarkedForRemoval(constructor, forRemoval));
  }

  //@top
  static void checkMethodOverridesDeprecated(MethodSignatureBackedByPsiMethod methodSignature,
                                             List<MethodSignatureBackedByPsiMethod> superMethodSignatures,
                                             boolean ignoreAbstractDeprecatedOverrides, ProblemsHolder holder,
                                             boolean forRemoval, @NotNull ProblemHighlightType highlightType) {
    PsiMethod method = methodSignature.getMethod();
    PsiElement methodName = method.getNameIdentifier();
    if (methodName == null) return;
    for (MethodSignatureBackedByPsiMethod superMethodSignature : superMethodSignatures) {
      PsiMethod superMethod = superMethodSignature.getMethod();
      PsiClass aClass = superMethod.getContainingClass();
      if (aClass == null) continue;
      // do not show deprecated warning for class implementing deprecated methods
      if (ignoreAbstractDeprecatedOverrides && !aClass.isDeprecated() && superMethod.hasModifierProperty(PsiModifier.ABSTRACT)) continue;
      if (superMethod.isDeprecated() && isMarkedForRemoval(superMethod, forRemoval)) {
        String description = JavaErrorMessages.message(forRemoval ? "overrides.marked.for.removal.method" : "overrides.deprecated.method",
                                                       HighlightMessageUtil.getSymbolName(aClass, PsiSubstitutor.EMPTY));
        holder.registerProblem(methodName, getDescription(description, forRemoval, highlightType), highlightType);
      }
    }
  }

  static void checkDeprecated(PsiElement refElement,
                              PsiElement elementToHighlight,
                              @Nullable TextRange rangeInElement,
                              boolean ignoreInsideDeprecated,
                              boolean ignoreImportStatements,
                              boolean ignoreMethodsOfDeprecated,
                              boolean ignoreInSameOutermostClass,
                              ProblemsHolder holder,
                              boolean forRemoval,
                              @NotNull ProblemHighlightType highlightType) {
    if (!(refElement instanceof PsiDocCommentOwner) ||
        !isMarkedForRemoval((PsiDocCommentOwner)refElement, forRemoval) ||
        isInSameOutermostClass(refElement, elementToHighlight, ignoreInSameOutermostClass)) {
      return;
    }

    if (!((PsiDocCommentOwner)refElement).isDeprecated()) {
      if (!ignoreMethodsOfDeprecated) {
        checkDeprecated(((PsiDocCommentOwner)refElement).getContainingClass(), elementToHighlight, rangeInElement,
                        ignoreInsideDeprecated, ignoreImportStatements, false, ignoreInSameOutermostClass,
                        holder, forRemoval, highlightType);
      }
      return;
    }

    if (ignoreInsideDeprecated) {
      PsiElement parent = elementToHighlight;
      while ((parent = PsiTreeUtil.getParentOfType(parent, PsiDocCommentOwner.class, true)) != null) {
        if (((PsiDocCommentOwner)parent).isDeprecated()) return;
      }
    }

    if (ignoreImportStatements && PsiTreeUtil.getParentOfType(elementToHighlight, PsiImportStatementBase.class) != null) {
      return;
    }

    String description = JavaErrorMessages.message(forRemoval ? "marked.for.removal.symbol" : "deprecated.symbol",
                                                   HighlightMessageUtil.getSymbolName(refElement, PsiSubstitutor.EMPTY));

    LocalQuickFix quickFix = null;
    PsiMethodCallExpression methodCall = getMethodCall(elementToHighlight);
    if (refElement instanceof PsiMethod && methodCall != null) {
      PsiMethod replacement = findReplacementInJavaDoc((PsiMethod)refElement, methodCall);
      if (replacement != null) {
        quickFix = new ReplaceMethodCallFix((PsiMethodCallExpression)elementToHighlight.getParent().getParent(), replacement);
      }
    }

    holder.registerProblem(elementToHighlight, getDescription(description, forRemoval, highlightType), highlightType, rangeInElement, quickFix);
  }

  private static boolean isMarkedForRemoval(PsiModifierListOwner element, boolean forRemoval) {
    return isMarkedForRemoval(element) == forRemoval;
  }

  private static boolean isInSameOutermostClass(PsiElement refElement, PsiElement elementToHighlight, boolean ignoreInSameOutermostClass) {
    if (!ignoreInSameOutermostClass) {
      return false;
    }
    PsiClass outermostClass = CachedValuesManager.getCachedValue(
      refElement,
      () -> new CachedValueProvider.Result<>(getOutermostClass(refElement), PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT));
    return outermostClass != null && outermostClass == getOutermostClass(elementToHighlight);
  }

  private static PsiClass getOutermostClass(PsiElement element) {
    PsiElement maybeClass = PsiTreeUtil.findFirstParent(element, e -> e instanceof PsiClass && e.getParent() instanceof PsiFile);
    return maybeClass instanceof PsiClass ? (PsiClass)maybeClass : null;
  }

  private static boolean isMarkedForRemoval(@Nullable PsiModifierListOwner element) {
    PsiAnnotation annotation = AnnotationUtil.findAnnotation(element, CommonClassNames.JAVA_LANG_DEPRECATED);
    if (annotation == null) {
      return false;
    }
    PsiAnnotationMemberValue value = annotation.findAttributeValue("forRemoval");
    Object result = null;
    if (value instanceof PsiLiteral) {
      result = ((PsiLiteral)value).getValue();
    }
    else if (value instanceof PsiExpression) {
      result = JavaConstantExpressionEvaluator.computeConstantExpression((PsiExpression)value, false);
    }
    return result instanceof Boolean && ((Boolean)result);
  }

  protected static void addSameOutermostClassCheckBox(MultipleCheckboxOptionsPanel panel) {
    panel.addCheckbox("Ignore in the same outermost class", "IGNORE_IN_SAME_OUTERMOST_CLASS");
  }

  private static String getDescription(String description, boolean forRemoval, ProblemHighlightType highlightType) {
    if (ApplicationManager.getApplication().isUnitTestMode()) {
      ProblemHighlightType defaultType = forRemoval ? ProblemHighlightType.LIKE_MARKED_FOR_REMOVAL : ProblemHighlightType.LIKE_DEPRECATED;
      if (highlightType != defaultType) {
        return description + "(" + highlightType + ")";
      }
    }
    return description;
  }

  private static PsiMethod findReplacementInJavaDoc(@NotNull PsiMethod method, @NotNull PsiMethodCallExpression call) {
    if (method instanceof PsiConstructorCall) return null;
    PsiDocComment doc = method.getDocComment();
    if (doc == null) return null;

    Collection<PsiDocTag> docTags = PsiTreeUtil.findChildrenOfType(doc, PsiDocTag.class);
    if (docTags.isEmpty()) return null;
    PsiMethod tagMethod = (PsiMethod)docTags
      .stream()
      .filter(t -> {
        String name = t.getName();
        return "link".equals(name) || "see".equals(name);
      })
      .map(tag -> tag.getValueElement())
      .filter(Objects::nonNull)
      .map(value -> value.getReference())
      .filter(Objects::nonNull)
      .map(reference -> reference.resolve())
      .filter(Objects::nonNull)
      .distinct()
      .collect(MoreCollectors.onlyOne())
      .filter(resolved -> resolved instanceof PsiMethod)
      .orElse(null);
    return tagMethod == null || tagMethod.isDeprecated() || tagMethod.isEquivalentTo(method) || !areReplaceable(method, tagMethod, call)
           ? null
           : tagMethod;
  }

  private static boolean areReplaceable(@NotNull PsiMethod initial,
                                        @NotNull PsiMethod suggestedReplacement,
                                        @NotNull PsiMethodCallExpression call) {
    if (!PsiResolveHelper.SERVICE.getInstance(call.getProject()).isAccessible(suggestedReplacement, call, null)) {
      return false;
    }

    boolean isInitialStatic = initial.hasModifierProperty(PsiModifier.STATIC);
    boolean isSuggestedStatic = suggestedReplacement.hasModifierProperty(PsiModifier.STATIC);
    if (isInitialStatic && !isSuggestedStatic) {
      return false;
    }
    if (!isInitialStatic && !isSuggestedStatic && !InheritanceUtil.isInheritorOrSelf(getQualifierClass(call), suggestedReplacement.getContainingClass(), true)) {
      return false;
    }

    String qualifierText;
    if (isInitialStatic) {
      qualifierText = ObjectUtils.notNull(suggestedReplacement.getContainingClass()).getQualifiedName() + ".";
    } else {
      PsiExpression qualifierExpression = call.getMethodExpression().getQualifierExpression();
      qualifierText = qualifierExpression == null ? "" : (qualifierExpression.getText() + ".");
    }

    PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(initial.getProject());
    PsiExpressionList arguments = call.getArgumentList();
    PsiMethodCallExpression suggestedCall = (PsiMethodCallExpression)elementFactory
      .createExpressionFromText(qualifierText + suggestedReplacement.getName() + arguments.getText(), call);

    MethodCandidateInfo result = ObjectUtils.tryCast(suggestedCall.resolveMethodGenerics(), MethodCandidateInfo.class);
    return result != null && result.isApplicable();
  }

  @Nullable
  private static PsiClass getQualifierClass(@NotNull PsiMethodCallExpression call) {
    PsiExpression expression = call.getMethodExpression().getQualifierExpression();
    if (expression == null) {
      return RefactoringChangeUtil.getThisClass(call);
    }
    return PsiUtil.resolveClassInType(expression.getType());
  }

  @Nullable
  private static PsiMethodCallExpression getMethodCall(@NotNull PsiElement element) {
    if (!(element instanceof PsiIdentifier)) return null;
    PsiElement parent = element.getParent();
    if (!(parent instanceof PsiReferenceExpression)) return null;
    return ObjectUtils.tryCast(parent.getParent(), PsiMethodCallExpression.class);
  }
}


text:
using System.Collections.Generic;

public class WeeklyCalendar
{
    public List<WeeklyEntry> WeeklySchedule { get; }

    public WeeklyCalendar()
    {
        this.WeeklySchedule = new List<WeeklyEntry>();
    }

    public void AddEntry(string weekday, string notes)
    {
        this.WeeklySchedule.Add(new WeeklyEntry(weekday, notes));
    }
}


text:
"use strict";

const iotdb = require('iotdb');
const _ = iotdb._;

const fs = require('fs');

exports.command = "set";
exports.boolean = [ "list", "boolean", "number", "integer", "uuid" ];
exports.summary = "set a value in the keystore";

exports.help = function () {
    console.log("usage: homestar set [--list|boolean|number|integer|uuid] <key> <value> [<value>...]");
    console.log("");
    console.log("Set a key/value in '.iotdb/keystore.json'");
    console.log("");
    console.log("* If you need to set multiple values, use --list");
    console.log("* If you need to set a random UUID, use --uuid");
    console.log("* Hierarchy is expressed by a '/' in the key");
};

exports.run = function (ad) {
    if (ad._.length < 3) {
        console.log("missing arguments");
        console.log("");
        exports.help();
        process.exit(1);
    } else if (!ad.list && ad._.length > 3) {
        console.log("too many arguments -- make sure to use '--list' if you want to set multiple items");
        console.log("");
        exports.help();
        process.exit(1);
    }

    let key = ad._[1];
    if (key.indexOf('/') === 0) {
        key = key.substring(1);
    } else {
        key = "homestar/runner/" + key;
    }

    let value;
    if (ad.list) {
        value = ad._.slice(2);
    } else if (ad.boolean) {
        const v = ad._[2].toLowerCase();
        const truey = [ "true", "t", "yes", "y", "1" ];
        const falsey = [ "false", "f", "no", "no", "0", "" ];
        if (truey.indexOf(v) > -1) {
            value = true;
        } else if (falsey.indexOf(v) > -1) {
            value = false;
        }
    } else if (ad.number) {
        value = parseFloat(ad._[2]);
    } else if (ad.integer) {
        value = parseInt(ad._[2]);
    } else if (ad.uuid) {
        value = _.id.uuid.v4();
    } else {
        value = ad._[2];
    }

    iotdb.settings().save(key, value);

    console.log("homestar: added key/value to keystore",
        "\n  key", key,
        "\n  value", value
    );
};


text:
namespace ITACO.Entidades
{
    using System;
    using System.Collections.Generic;
    using ITACO.Entidades.Wrapper;

    public partial class Producto : ProductoCore
    {
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
        public Producto()
        {
            this.Producto_Tiene_Ingrediente = new HashSet<Producto_Tiene_Ingrediente>();
            this.Venta_Tiene_Producto = new HashSet<Venta_Tiene_Producto>();
        }

        public virtual TipoProducto TipoProducto { get; set; }
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
        public virtual ICollection<Producto_Tiene_Ingrediente> Producto_Tiene_Ingrediente { get; set; }
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
        public virtual ICollection<Venta_Tiene_Producto> Venta_Tiene_Producto { get; set; }
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<GeocodeResponse>
 <status>OK</status>
 <result>
  <type>locality</type>
  <type>political</type>
  <formatted_address>6522 Faggen, Austria</formatted_address>
  <address_component>
   <long_name>Faggen</long_name>
   <short_name>Faggen</short_name>
   <type>locality</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Gemeinde Faggen</long_name>
   <short_name>Gemeinde Faggen</short_name>
   <type>administrative_area_level_3</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Landeck District</long_name>
   <short_name>Landeck District</short_name>
   <type>administrative_area_level_2</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Tyrol</long_name>
   <short_name>Tyrol</short_name>
   <type>administrative_area_level_1</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Austria</long_name>
   <short_name>AT</short_name>
   <type>country</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>6522</long_name>
   <short_name>6522</short_name>
   <type>postal_code</type>
  </address_component>
  <geometry>
   <location>
    <lat>47.0790745</lat>
    <lng>10.6738763</lng>
   </location>
   <location_type>APPROXIMATE</location_type>
   <viewport>
    <southwest>
     <lat>47.0714755</lat>
     <lng>10.6578689</lng>
    </southwest>
    <northeast>
     <lat>47.0866724</lat>
     <lng>10.6898837</lng>
    </northeast>
   </viewport>
  </geometry>
  <place_id>ChIJQ4WFA2DQnEcRhWjNY2_481w</place_id>
 </result>
</GeocodeResponse>


text: from elementtidy.TidyHTMLTreeBuilder import *


text:
<?php
    session_start();
    include "header.php";
?>

Tables des prix

Accueil

Tables des prix

Redevance d'atterrissage

                        €1830
                        à partir de

 Mono-turbine / Bi-turbine

 Réacteur mono/multi

 Week-end et semaine

 Avion basé et non basé

S'inscrire !

Redevance stationnement

                        €276
                        à partir de

 Un prix par m²

 Par semaine

 Franchise de 2 semaines

 Pour tout types d'avion

S'inscrire !

Redevance d'abris

                        €1299
                        à partir de

 Un service qui varie

 La taille totale

 La masse maximum

 Vos machines en sécurité

S'inscrire !

Redevance avitaillement

                        €10.1 /L
                        à partir de

JETAI Sans TIC

JETAI A1 TIC

AVGAS 100LL sans TIC

AVGAS 100LL TIC

S'inscire !

Cotisation Aero-club

                        €178
                        à partir de

 Accès aux locaux et aux avions

 Ouvert du 15 avril au 15 octobre

 Ouverture hors saison

 samedi, dimanche, jours fériés

 Valable une année civile pleine

S'inscrire !

Adhésion FFA

                        €74
                        à partir de

 Licence + assurance

 Licen + assurance + revu mensuelle

 2 types d'avions disponiles

 des utilisations variées

 Des tarifs attractifs

S'inscrire!

<?php
    include "footer.php";
?>


text:
package iot.jcypher.database.remote;

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

import org.neo4j.driver.v1.AuthToken;
import org.neo4j.driver.v1.AuthTokens;
import org.neo4j.driver.v1.Driver;
import org.neo4j.driver.v1.GraphDatabase;
import org.neo4j.driver.v1.Session;
import org.neo4j.driver.v1.StatementResult;
import org.neo4j.driver.v1.Transaction;

import iot.jcypher.database.DBProperties;
import iot.jcypher.database.internal.DBUtil;
import iot.jcypher.database.util.QParamsUtil;
import iot.jcypher.query.JcQuery;
import iot.jcypher.query.JcQueryResult;
import iot.jcypher.query.result.JcError;
import iot.jcypher.query.writer.CypherWriter;
import iot.jcypher.query.writer.QueryParam;
import iot.jcypher.query.writer.WriterContext;
import iot.jcypher.transaction.ITransaction;

public class BoltDBAccess extends AbstractRemoteDBAccess {

	private static final String pathPrefix = "://";
	private static final String bolt = "bolt";

	private ThreadLocal<BoltTransactionImpl> transaction = new ThreadLocal<BoltTransactionImpl>();
	private AuthToken authToken;
	private Driver driver;
	private Session session;

	public BoltDBAccess() {
		super();
	}

	public BoltDBAccess(Driver driver) {
		super();
		this.driver = driver;
	}

	@Override
	public List<JcQueryResult> execute(List<JcQuery> queries) {
		List<Statement> statements = new ArrayList<Statement>(queries.size());
		for (JcQuery query : queries) {
			WriterContext context = new WriterContext();
			QueryParam.setExtractParams(query.isExtractParams(), context);
			CypherWriter.toCypherExpression(query, context);
			String cypher = context.buffer.toString();
			Map<String, Object> paramsMap = QParamsUtil.createQueryParams(context);
			statements.add(new Statement(cypher, paramsMap));
		}

		Transaction tx;
		BoltTransactionImpl btx = this.transaction.get();
		if (btx != null)
			tx = btx.getTransaction();
		else
			tx = getSession().beginTransaction();

		Throwable dbException = null;
		List<JcQueryResult> ret = new ArrayList<JcQueryResult>(queries.size());
		StatementResult result;
		try {
			for (Statement statement : statements) {
				if (statement.parameterMap != null)
					result = tx.run(statement.cypher, statement.parameterMap);
				else
					result = tx.run(statement.cypher);
				ret.add(new JcQueryResult(result, this));
			}
			if (btx == null)
				tx.success();
		} catch (Throwable e) {
			dbException = e;
			if (btx != null)
				btx.failure();
			tx.failure();
		} finally {
			if (btx == null && tx != null) {
				try {
					tx.close();
				} catch(Throwable e1) {
					dbException = e1;
				}
			}
		}

		if (dbException != null) {
			String typ = dbException.getClass().getSimpleName();
			String msg = dbException.getLocalizedMessage();
			JcError err = new JcError(typ, msg, DBUtil.getStacktrace(dbException));
			if (ret.size() < queries.size()) {
				for(int i = ret.size(); i < queries.size(); i++) {
					JcQueryResult res = new JcQueryResult(null, this);
					res.getDBErrors().add(err);
					ret.add(res);
				}
			} else {
				JcQueryResult res = ret.get(ret.size() - 1);
				res.getDBErrors().add(err); // the last one must have been erroneous
			}
		}

		return ret;
	}

	@Override
	public ITransaction beginTX() {
		BoltTransactionImpl tx = this.transaction.get();
		if (tx == null) {
			tx = new BoltTransactionImpl(this);
			this.transaction.set(tx);
		}
		return tx;
	}

	@Override
	public ITransaction getTX() {
		return this.transaction.get();
	}

	@Override
	public synchronized void close() {
		super.close();

		this.session = null;
		this.driver = null;
	}

	@Override
	public void setAuth(String userId, String password) {
		if (userId != null && password != null)
			this.authToken = AuthTokens.basic(userId, password);
	}

	@Override
	public void setAuth(AuthToken authToken) {
		this.authToken = authToken;
	}

	@Override
	protected void shutDown() {
		try {
			if (session != null)
				session.close();
		} catch (Throwable e) {
			// do nothing
		}
		try {
			if (driver != null)
				driver.close();
		} catch (Throwable e) {
			// do nothing
		}
	}

	void removeTx() {
		this.transaction.remove();
	}

	private Driver getDriver() {
		if (this.driver == null) {
			String uri = this.properties.getProperty(DBProperties.SERVER_ROOT_URI);
			if (this.authToken != null)
				this.driver = GraphDatabase.driver(uri, this.authToken);
			else
				this.driver = GraphDatabase.driver(uri);
			this.shutdownHook = registerShutdownHook();
		}
		return this.driver;
	}

	public synchronized Session getSession() {
		if (this.session == null)
			this.session = getDriver().session();
		return this.session;
	}

	public static boolean isBoltProtocol(String uri) {
		boolean ret = false;
		if (uri != null) {
			int idx = uri.indexOf(pathPrefix);
			if (idx > 0) {
				String prot = uri.substring(0, idx);
				ret = bolt.equalsIgnoreCase(prot);
			}
		}
		return ret;
	}

	/*******************************************/
	private static class Statement {
		private String cypher;
		private Map<String, Object> parameterMap;

		private Statement(String cypher, Map<String, Object> parameterMap) {
			super();
			this.cypher = cypher;
			this.parameterMap = parameterMap;
		}
	}
}


text:
using Android.Content;
using Android.Graphics;
using Android.Util;
using Android.Views;
using Android.Widget;

namespace TwitterCover
{
    public class TwitterCoverListView : ListView
    {
        private TwitterCoverImplementor implementor;

        public TwitterCoverListView(Context context, IAttributeSet attrs, int defStyle)
            : base(context, attrs, defStyle)
        {
            // get the default
            var coverHeight = context.Resources.GetDimensionPixelSize(Resource.Dimension.twitterCover_default_coverHeight);
            // get the default
            var a = context.ObtainStyledAttributes(attrs, Resource.Styleable.TwitterCover, defStyle, 0);
            coverHeight = a.GetDimensionPixelSize(Resource.Styleable.TwitterCover_twitterCoverHeight, coverHeight);
            a.Recycle();

            Init(context, coverHeight);
        }

        public TwitterCoverListView(Context context, IAttributeSet attrs)
            : base(context, attrs)
        {
            // get the default
            var coverHeight = context.Resources.GetDimensionPixelSize(Resource.Dimension.twitterCover_default_coverHeight);
            // get the local
            var a = context.ObtainStyledAttributes(attrs, Resource.Styleable.TwitterCover);
            coverHeight = a.GetDimensionPixelSize(Resource.Styleable.TwitterCover_twitterCoverHeight, coverHeight);
            a.Recycle();

            Init(context, coverHeight);
        }

        public TwitterCoverListView(Context context, int coverHeight)
            : base(context)
        {
            Init(context, coverHeight);
        }

        public TwitterCoverListView(Context context)
            : base(context)
        {
            // get the default
            var coverHeight = context.Resources.GetDimensionPixelSize(Resource.Dimension.twitterCover_default_coverHeight);

            Init(context, coverHeight);
        }

        private void Init(Context context, int coverHeight)
        {
            OverScrollMode = OverScrollMode.Never;

            implementor = new TwitterCoverImplementor(context, coverHeight);

            var header = new RelativeLayout(context);
            header.LayoutParameters = new AbsListView.LayoutParams(ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.MatchParent);
            header.AddView(implementor.CoverContainer);
            AddHeaderView(header);
        }

        public virtual void SetHeaderImage(Bitmap value)
        {
            implementor.SetHeaderImage(value);
        }

        protected override void OnScrollChanged(int l, int t, int oldl, int oldt)
        {
            base.OnScrollChanged(l, t, oldl, oldt);

            implementor.HandleScrollChanged();
        }

        protected override bool OverScrollBy(int deltaX, int deltaY, int scrollX, int scrollY, int scrollRangeX, int scrollRangeY, int maxOverScrollX, int maxOverScrollY, bool isTouchEvent)
        {
            implementor.HandleOverScrollBy(deltaY, isTouchEvent);

            return base.OverScrollBy(deltaX, deltaY, scrollX, scrollY, scrollRangeX, scrollRangeY, maxOverScrollX, maxOverScrollY, isTouchEvent);
        }

        public override bool OnTouchEvent(MotionEvent ev)
        {
            if (ev.Action == MotionEventActions.Up)
            {
                implementor.HandleRelease();
            }
            return base.OnTouchEvent(ev);
        }
    }
}


text:
namespace scm {
namespace gl {

class __scm_export(gl_core) render_target
{
public:
    virtual ~render_target();

    virtual data_format     format() const = 0;
    virtual math::vec2ui    dimensions() const = 0;
    virtual unsigned        array_layers() const = 0;
    virtual unsigned        mip_map_layers() const = 0;
    virtual unsigned        samples() const = 0;

protected:
    render_target();

    virtual unsigned        object_id() const = 0;
    virtual unsigned        object_target() const = 0;

private:

    friend class render_device;
    friend class render_context;
    friend class frame_buffer;
}; // class render_target

} // namespace gl
} // namespace scm

#include <scm/core/utilities/platform_warning_enable.h>

#endif // SCM_GL_CORE_RENDER_TARGET_H_INCLUDED