text:
<?php include 'assets/Frontend/inc/config.php';?>
<?php include 'assets/Frontend/inc/template_start.php';?>
<?php include 'assets/Frontend/inc/page_head.php';?>

Barangay Cagangohan Geographical Information System.

Make your neighborhood easy to locate.

Flexible Layout

BCGIS is mobile-friendly! It will look great on mobile devices and on desktops at the same time.

To-go capabilities

You can make the residence information hard-bounded. It would make possible by using a printer and print you desired residence information together with its location in a map form.

Locate Residence

BCGIS provides searching of residence location and information through Map.

Up-to-date Records

BCGIS residence information are up to date from the Barangay, CBMS and Panabo City Planning Office records.

Active Admin

BCGIS are maintained by the developers since it is in development. Also, its residence information are monitored by the Barangay Secretary and the Barangay Health Officials.

Fancy Demography

BCGIS admin pane have a fancy view of chart to analyze the total population by purok and total male & female population by age ranges with a style.

<?php include 'assets/Frontend/inc/page_footer.php';?>
<?php include 'assets/Frontend/inc/template_scripts.php';?>
<?php include 'assets/Frontend/inc/template_end.php';?>

redpajama_set_name: RedPajamaGithub


text:
using ArcGIS.Desktop.Core.Portal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConfigWithStartWizard.Models {
    internal class OnlineQuery {

        private static Dictionary<string, string> _onlineQueries = new Dictionary<string, string>();
        private string _portalURL = "";
        private string _contentType = "";
        private string _path = "";
        private string _query = "";
        private string _token = "";
        private string _format = "";
        private string _name = "";
        private string _downloadFileName = "";
        private int _start = 0;

        static OnlineQuery() {
            _onlineQueries.Add("Rule packages", "/sharing/rest/search?q=(type:\"Rule Package\")");
            _onlineQueries.Add("Projects", "/sharing/rest/search?q=(type:\"Project Package\")");
            _onlineQueries.Add("Templates", "/sharing/rest/search?q=(owner:\"esri_solutions\" AND type:\"Project Template\")");
            _onlineQueries.Add("Map Packages", "/sharing/rest/search?q=(type:\"Pro Map\")");
            _onlineQueries.Add("Web Maps", "/sharing/rest/search?q=(type:\"Web Scene\" OR type:\"Web Map\")");
            _onlineQueries.Add("Layers", "/sharing/rest/search?q=(type:\"Layer Package\" OR type:\"Feature Service\" OR type:\"Map Service\")");
            _onlineQueries.Add("Item Data", "/sharing/rest/content/items/{0}/data");
        }

        public static IReadOnlyList<string> Content => _onlineQueries.Keys.ToList();

        public OnlineQuery(string portalURL) {
            _portalURL = portalURL;
        }

        public void Configure(string contentType) {
            Configure(contentType, "", 0);
        }

        public void Configure(string contentType, string token) {
            Configure(contentType, token, 0);
        }

        public void Configure(string contentType, string token, int start) {
            if (!_onlineQueries.ContainsKey(contentType))
                throw new ArgumentException($"Invalid content type: {contentType}");
            _contentType = contentType;
            _token = token;
            _start = start;
            var query = _onlineQueries[_contentType].Split(new char[] { '?' });
            _path = query[0];
            _format = "json";

            _query = query[1] ?? "";
        }

        public void ConfigureData(string token, string id, string name) {
            _contentType = "Item Data";
            _token = token;
            _name = name;
            _start = 0;
            _format = "";
            _query = string.Format(_onlineQueries["Item Data"], id);
            if (!string.IsNullOrEmpty(_token))
                _query += $"?token={_token}";
        }

        public string URL => _portalURL;
        public string Path => _path;

        public int Start
        {
            get
            {
                return _start;
            }
            set
            {
                _start = value;
            }
        }

        public string Query
        {
            get
            {
                var query = _query;
                if (!string.IsNullOrEmpty(_token))
                    query += $"&token={_token}";
                if (_start > 0)
                    query += $"&start={_start}";
                query += $"&f={_format}";
                return query;
            }
        }

        public string Name => _name ;
        public string FinalUrl => URL + Path + "?" + Query;

        public string DownloadUrl => _portalURL + _query;

        public string DownloadFileName
        {
            get
            {
                if (string.IsNullOrEmpty(_downloadFileName))
                    _downloadFileName = ConfigWithStartWizardModule.UniqueFileName(
                                             System.IO.Path.Combine(
                                                  System.IO.Path.Combine(
                                                      Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Downloads"), Name));
                return _downloadFileName;
            }
        }

        private PortalQueryParameters _portalQueryParams;
        public PortalQueryParameters PortalQueryParams
        {
            get
            {
                var types = _query.Split(new char[] { '=' });

                _portalQueryParams = new PortalQueryParameters(types[1]);

                _portalQueryParams.StartIndex = _start;
                return _portalQueryParams;
            }
        }

        public Uri FinalUri => new Uri(this.FinalUrl, UriKind.Absolute);

    }
}


text:
module Atmosphere
  module Api
    module V1
      class ApplianceConfigurationTemplatesController < Atmosphere::Api::ApplicationController
        load_and_authorize_resource :appliance_configuration_template,
          class: 'Atmosphere::ApplianceConfigurationTemplate'

        include Atmosphere::Api::Auditable

        respond_to :json

        def index
          respond_with @appliance_configuration_templates.
                         where(filter).order(:id)
        end

        def show
          respond_with @appliance_configuration_template
        end

        def create
          @appliance_configuration_template.save!

          render json: @appliance_configuration_template,
                 status: :created
        end

        def update
          @appliance_configuration_template.
            update_attributes!(update_params)

          render json: @appliance_configuration_template
        end

        def destroy
          if @appliance_configuration_template.destroy
            render json: {}
          else
            render_error @appliance_configuration_template
          end
        end

        private

        def appliance_configuration_template_params
          params.require(:appliance_configuration_template).
            permit(:name, :payload, :appliance_type_id)
        end

        def update_params
          params.require(:appliance_configuration_template).
            permit(:name, :payload)
        end

        def model_class
          Atmosphere::ApplianceConfigurationTemplate
        end
      end
    end
  end
end


text:
package jodd.buffer;

import org.junit.jupiter.api.Test;

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

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

class FastByteBufferTest extends FastBufferTestBase {

	@Test
	void testAppend() {
		FastByteBuffer buff = new FastByteBuffer(3);

		buff.append(buff);
		buff.append((byte)173);
		buff.append(array((byte)8,(byte)98));

		assertArrayEquals(array((byte)173, (byte)8, (byte)98), buff.toArray());

		buff.append(buff);

		assertArrayEquals(array((byte)173, (byte)8, (byte)98, (byte)173, (byte)8, (byte)98), buff.toArray());

		buff.append(array((byte)173, (byte)5, (byte)3), 1, 1);

		assertArrayEquals(array((byte)173, (byte)8, (byte)98, (byte)173, (byte)8, (byte)98, (byte)5), buff.toArray());

		FastByteBuffer buff2 = new FastByteBuffer(3);
		buff2.append(buff);

		assertEquals(7, buff2.toArray().length);
	}

	@Test
	void testClear() {
		FastByteBuffer buff = new FastByteBuffer();

		assertTrue(buff.isEmpty());

		buff.append((byte)1);

		assertFalse(buff.isEmpty());

		buff.clear();

		assertTrue(buff.isEmpty());

		try {
			buff.get(0);
			fail("error");
		} catch (IndexOutOfBoundsException ignore) {
		}

		byte[] arr = buff.toArray();

		assertEquals(0, arr.length);
	}

	@Test
	void testToArray() {
		final FastByteBuffer buff = new FastByteBuffer();

		byte sum = 0;

		for (int j = 0; j < COUNT; j++) {
			for (int i = 1; i <= SIZE; i++) {
				buff.append((byte)i);
				sum += i;
			}
		}

		buff.append((byte)173);
		sum += 173;

		byte[] array = buff.toArray();
		byte sum2 = 0;
		for (byte l : array) {
			sum2 += l;
		}

		assertEquals(sum, sum2);

		array = buff.toArray(1, buff.size() - 2);
		sum2 = 0;
		for (byte l : array) {
			sum2 += l;
		}

		assertEquals(sum - (byte)1 - (byte)173, sum2);
	}

	@Test
	void testToSubArray() {
		FastByteBuffer buff = new FastByteBuffer();

		int total = SIZE + (SIZE/2);

		for (int i = 1; i <= total; i++) {
			buff.append((byte)i);
		}

		byte[] array = buff.toArray(SIZE + 1, total - SIZE  - 1);

		assertEquals(total - SIZE - 1, array.length);
		assertEquals((byte)(SIZE + 2), array[0]);
	}

	@Test
	void testBig() {
		List<Byte> l = new ArrayList<>();
		FastByteBuffer fbf = new FastByteBuffer();

		Random rnd = new Random();
		for (int i = 0; i < 100_000; i++) {
			int n = rnd.nextInt();
			l.add((byte)n);
			fbf.append((byte)n);
		}

		for (int i = 0; i < l.size(); i++) {
			assertEquals(l.get(i).byteValue(), fbf.get(i));
		}
	}

	protected byte[] array(byte... arr) {
		return arr;
	}

}


text:
layout: doc
title: Usare un GPS Garmin
permalink: /it/mobile-mapping/using-gps/
lang: it
category: mobile-mapping
---

Usare il GPS
====================

> Questa guida può essere scaricata come [gps-garmin_it.odt](/files/gps-garmin_it.odt) o [gps-garmin_it.pdf](/files/gps-garmin_it.pdf)
> Revisionato 2015-06-07

Imparare ad editare è un passo chiave della mappatura, per aggiungere
informazioni alla mappa. Ma un altro compito è collezionare
informazioni, uscire e fare una ricognizione di una zona.

In questo capitolo vedremo cosa fa un GPS e come funziona. Imparerai
a usare un GPS e come usarlo per creare mappe.

Qui spiegheremo come usare il Garmin eTrex Vista HCx, un
comune GPS usato per la mappatura. Ci sono molti altri modelli di GPS che fanno
le stesse cose, quindi se stai lavorando con un modello differente, non ti preoccupare,
 i princìpi sono gli stessi.

<!-- link here to other GPS tutorials when they are ready -->

Cos'è un GPS?
--------------
Un GPS è come un cellulare, a parte il fatto che invece di ricevere i segnali radio
dalle compagnie telefoniche, riceve segnali dai satelliti
che orbitano intorno alla Terra. Ricevendo questi segnali,
un GPS è in grado di calcolare la tua posizione esatta sul
pianeta. Registra la posizione in coordinate, che sono due lunghi
numeri. Un numero ti dice quanto sei ad est o a ovest - è detto
longitudine. Il secondo numero ti dice quanto sei a nord o a sud - questo
è chiamato latitudine. Ognu punto sulla terra ha le sue
coordinate geografiche uniche.

Per esempio: latitudine -8.639298, longitudine 116.311607 sono le ccordinate di
Lombok, Indonesia.

![Google Earth software, showing coordinates of Lombok, Indonesia][]

![Garmin eTrex Vista HCx][]

Accendi il GPS
---------------

- Prima di accendere il tuo GPS, mettiti all'aperto dove puoi avere una buona visuale del
cielo. Questo perché il GPS determina la propria posizione ricevendo segnali
dai satelliti, quindi non funziona al chiuso.

Sul lato destro del tuo GPS, premi e mantieni premuto il tasto Power. Il GPS
si accenderà e mostrerà la schermata dei satelliti. Dovresti vedere
qualcosa di simile all'immagine seguente. Il tuo GPS sta cercando i segnali dai satelliti.
Quando avrà ricevuto un segnale da tre o più satelliti, mostrerà la tua posizione.

![GPS determined location][]

Una volta acquisita la tua posizione, la schermata dei satelliti scomparirà
e vedrai il menù principale.

![GPS main menu][]

I Menù del GPS
----------------

- Il GPS ha differenti schermate e menù che ti permetto di fare
    differenti operazioni. Per cambiare schermata, premi il bottone con la
    "X", appena sopra il pulsante di accensione, sul lato destro dell'unità.
    Questo bottone serve anche per tornare indietro. Se premi qualcosa per
    errore e vuoi cancellare il comando o tornare indietro, premi il bottone "X".
- Premendo il bottone "X", dovresti passare attraverso le
    diverse schermate, simili alle immagini seguenti:

![GPS all][]

- Se torni alla schermata dei satelliti, vedrai che sei
    collegato con tre o più satelliti. In alto a sinistra
    vedrai le tue coordinate attuali: latitudine e longitudine.

- Spostati sulla schermata della mappa e potrai vedere una mappa del luogo in cui ti trovi. Se
    hai aggiunto le mappe OSM al tuo GPS, vedrai strade e luoghi.
    Atrimenti la mappa sarà un po' vuota. Puoi ingrandire o ridurre la visuale premendo
    i pulsanti "Freccia Su" o "Freccia Giù" sul lato sinistro del GPS.

- Puoi trovare ulteriori informazioni per ottenere le mappe OSM per i GPS Garmin e come installarle
  [in the OSM wiki](http://wiki.openstreetmap.org/wiki/OSM_Map_On_Garmin/Download)

Tracce e Punti
--------------------

Il tuo GPS registra due tipi di informazioni che sono utili per creare
mappe o memorizzare le coordinate di un posto. Per prima cosa, ti permette di memorizzare
le tue coordinate nella memoria del GPS. Quando memorizzi una posizione, le
coordinate saranno salvate con un nome. Per esempio, il primo punto memorizzato
sarà chiamato 001, il secondo 002 e così via.

<!-- again not sure if this note should go here -->

> Se il tuo GPS non parte con 001 e vuoi cancellare i
> punti precedentemente memorizzati, individua l'icona "Find" nel menù principale.
> Seleziona "waypoints" e poi il bottone di sottomenù alla destra per
> mostrare il sottomenù Waypoint. Scorri in basso fino a "Delete", fai click
> su "all symbols" e su "Yes".

Quando memorizzi un
punto, puoi scrivere il numero su un pezzo di carta insieme ad una
nota riguardante la sua descrizione, qualsiasi indicazione di attributi o informazioni che vuoi
ricordare. Le informazioni salvate nella memoria del GPS sono chiamate punti o waypoints.

Inoltre, il tuo GPS
può memorizzare le cosiddette tracce o tracks.  Mentre un punto memorizza un solo
luogo, una traccia salva una serie di punti mentre ti muovi. Per
esempio, la traccia registrerà la tua posizione ogni secondo od ogni
metro e il risultato sarà una serie di punti che mostreranno una traccia di
dove sei stato. Le tracce sono utili per mappare oggetti che sono
rappresentati da linee o aree, come il percorso di una strada o la
forma di un campo.

![GPS path][]

Memorizza la tua posizione
-----------------------------------

- Per memorizzare la tua attuale posizione come un punto, premi il bottone "X"
    che non vedrai il menù principale. Usando il joystick, spostati nel
    menù fintanto che la parola "Mark" non è evidenziata. Premi il bottone del joystick
    per aprire la schermata "Save Waypoint". In alternativa puoi premere il
    bottone del joystick su qualsiasi pagina finchè non si aprirà la pagina "Save Waypoint".

![save location 1][]

<!-- note unnecessary perhaps? add to advanced section
> Se usi più di un GPS, assicurati che tutti gli
> apparati siano impostati con i medesimi settaggi. Per verificarlo vai al "Main
> Menu" e cerca "SET up Menu". Fai click su "Units" e assicurati che il Position
> Format sia impostato su gradi decimali (hddd.ddddd°), il Map Datum su WGS 84
> (che è un sistema standard di coordinate, o superficie sferoidale di riferimento
per la Terra) e che distanza, altitudine e profondità siano impostate su metri.
-->

- In questa schermata vedrai alcune informazioni sul punto che
    stai per memorizzare. Innanzitutto il nome. Se questo è il tuo primo punto,
    vedrai probabilmente 001. Questo è il numero che dovrai segnarti su
    carta insieme alle informazioni che hai raccolto
    sull'oggetto. Dopo vedrai la data e l'ora in cui il punto è
    stato memorizzato. Sotto ci sono le coordinate e l'altitudine.
- Usa il joystick per evidenziare il bottone "OK" in fondo alla
    pagina. Premi il bottone del joystick per salvare il punto. Assicurati
    di aver scritto da qualche parte il numero del punto, insieme ad una descrizione del luogo
    e alle informazioni che vuoi
    ricordare.

![save location 2][]

- Premi il pulsante X per tornare alla schermata della mappa. Vedrai il nuovo
    punto sulla mappa.

Abilitare la registrazione delle tracce
---------------------

- Ora che abbiamo imparato a memorizzare i punti, impariamo come
    abilitare o disabilitare la registrazione delle tracce. Quando la registrazione è abilitata, verrà
    automaticamente salvato il percorso da te effettuato. E' buona pratica abilitare
    la registrazione mentre stai mappando e disabilitarla quando hai finito.
    In seguito potrai vedere la traccia sul tuo computer e vedere il
    percorso che hai mappato. Se vuoi mappare il percorso di una strada,
    una buona idea è salvare il punto all'inizio e alla fine della
    strada, annotare il nome della strada e
    qualsiasi informazione aggiuntiva importante.
- Per abilitare la registrazione delle tracce, premi il bottone X finchè non raggiungi la
    schermata chiamata "Track Log".

![turn on track][]

- Se vuoi cancellare delle registrazioni
    precedenti, usa il joystick per selezionare il pulsante "Clear", e premi il
    pulsante del joystick. Sulla barra in alto apparirà "0%".
- Per abilitare la registrazione delle tracce, seleziona col joystick "On" e premi
    il pulsante del joystick. Il sistema sta registrando la traccia.
- Nelle opzioni di "Set up" puoi impostare gli intervalli di tempo o distanza
    con i quali tracciare. Gli intervalli di tempo permettono di registrare la posizione in
    determinati intervalli. Se hai una scheda di memoria nel tuo GPS, è buona
    pratica impostare l'intervallo su 1 secondo, cosicchè ogni secondo la posizione
    verrà registrata nella traccia. Questo può risultare utile quando sono necessarie
    ricognizioni dettagliate.
- Premi il bottone X per tornare alla schermata della mappa. Se ti muovi, vedrai
    una traccia formata da  una serie di punti.

Copiare i punti e le tracce sul computer
-----------------------------------------
Quando hai finito di mappare col GPS, vorrai copiare questi
punti e tracce sul tuo computer in modo da poterli visualizzare in JOSM.

Un modo per copiare i punti e le tracce è utilizzare il programma gratuito
fornito da Garmin, chiamato BaseCamp. Può essere scaricato
[qui](http://www.garmin.com/en-US/shop/downloads/basecamp). Comunque, in
questo capitolo useremo un programma chiamato GPSBabel, che offre meno
caratteristiche addizionali.

### Collega il GPS al computer
- Per prima cosa, disabilita la registrazione delle tracce sul tuo GPS andando nella
     schermata delle tracce e selezionando "Off".
- Collega il GPS al tuo computer col cavo in dotazione. Un connettore del cavo dovrebbe collegarsi
    alla porta USB, mentre l'altro va connesso dietro
    al GPS, tra il bordo gommoso e la parte superiore. Il GPS deve essere
    acceso per copiare i dati sul computer.

### Installa i driver per il GPS

- Potresti aver bisogno di installare i driver del GPS sul tuo computer. Puoi scaricare
    i driver al [Sito Garmin](http://www8.garmin.com/support/download_details.jsp?id=591).
- Fai clic su "Download" per ottenere il file di installazione. Cercalo sul tuo
    computer e fai doppio clic sopra per avviare l'installazione.
- Se non riesci a scaricare il file dal sito Gramin, puoi
    scaricare i driver [qui](/files/USBDrivers_231.exe).

> I sistemi Linux (quantomeno Fedora) non hanno bisogno di driver per comunicare
> con un apparato Gramin (almeno con gli eTrex Vista HCx). Assicurati che il tuo
> Garmin sia acceso e collegato al computer col cavo USB. Puoi utilizzare
> GPSBabel (come spiegato sotto) o GpsPrune per estrarre di dati salvati.

### Ottieni il programma di installazione di GPSBabel
- GPSBabel è un programma che permette la copia di dati dal GPS. Se
    hai già una copia di GPSBabel su un CD o su pennetta USB puoi saltare direttamente
    alla prossima sezione.
- Se non possiedi già GPSbabel, apri il tuo browser
    e naviga all'indirizzo [www.gpsbabel.org](http://www.gpsbabel.org)
- Fai clic su "Downloads" in alto nella pagina.
- Spostati in basso nella pagina. Se il tuo computer usa Windows, scarica
    il file di installazione per Windows. Fai clic su "GPSBabel-1.5.2-Setup.exe".
    Il file verrà scaricato nel tuo computer.

### Installa GPSBabel
- Trova il file di setup di GPSBabel sul tuo computer. Fai doppio clic per lanciare l'installazione.
- Premi "Next".
- Premi "I accept" e "Next".
- Continua a fare clic su "Next" finchè il programma non è installato.
- Quando il programma ha terminato l'istallazione, fai clic su "Finish" per eseguire GPSBabel.

![GPSBabel Interface][]

### Copia punti e tracce

- Fai clic sul punto alla sinistra della parola "Device"in alto nella
    finestra.
- Nel menù a discesa chiamato "Format", seleziona "Garmin serial/USB
    protocol"
- Al centro della finestra, sotto la parola "Output", nel menù a discesa
    chiamato "Format", seleziona  "GPX XML":

![Choose GPX XML][]

- Fai clic su "File Name" e inserisci nel campo il nome con cui vuoi salvare il file. Dovrebbe essere
    un nome che descrive i dati, come ad esempio il luogo e la
    data. Per esempio _Roma-07-07-2011_
- Assicurati che il GPS sia acceso e connesso al computer.
- Fai clic su "Apply" nella finestra, in fondo a destra.
- Se tutto ha funzionato, dovresti vedere una barra che si muove attraverso lo schermo,
    indica il caricamento dei dati dal GPS. Quando ha
    finito, i uoi punti e le tue tracce sono salvati nel file che hai
    selezionato.

### Visualizzare i dati in JOSM

- Ora lancia JOSM.  Nel menù in alto seleziona "File" e poi "Apri..."
- Trova e seleziona il file creato con GPSBabel.  Fai clic su "Apri"
- Dovresti vedere i tuoi punti e tracce caricati in JOSM.

![GPS Files Open in JOSM][]

Conclusioni
-------

Congratulazioni! Adesso hai imparato come usare un
GPS. Se non l'hai già provato, fai pratica salvando i punti di qualche luogo
che conosci.

In questo capitolo hai imparato come registrare le tracce e i punti e a visualizzarli
in JOSM. Successivamente useremo queste informazioni per inserirle
in OpenStreetMap.

[Google Earth software, showing coordinates of Lombok, Indonesia]: /images/mobile-mapping/google-earth-lombok.png
[Garmin eTrex Vista HCx]: /images/mobile-mapping/garmin-etrex.png
[GPS determined location]: /images/mobile-mapping/aquiring-satellites.png
[GPS main menu]: /images/mobile-mapping/gps_main.png
[GPS all]: /images/mobile-mapping/gps_all.png
[GPS path]: /images/mobile-mapping/google-earth.png
[save location 1]: /images/mobile-mapping/save-location1.png
[save location 2]: /images/mobile-mapping/save-location2.png
[turn on track]: /images/mobile-mapping/turn-on-track.png
[GPSBabel Interface]: /images/mobile-mapping/babel.png
[Choose GPX XML]: /images/mobile-mapping/xml.png
[GPS Files Open in JOSM]: /images/mobile-mapping/open-josm.png


text:
Github Webpage for driving school, based in Lanús, Argentina

Includes:
* orginal design, responsive & cross platform
* W3C compliant html code
* custom CSS & javascript


text:
export { AdminComponent } from './admin.component';
export { LoginComponent } from './login/login.component';
export { ListComponent } from './list/list.component';
export { DrawingComponent } from './drawing/drawing.component';
export { AdminService } from './admin.service';


text:
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

/** @file

    @author	Eric Espie
    @version	$Id: objects.h,v 1.3 2003/09/01 06:28:44 torcs Exp $
*/

#ifndef _OBJECTS_H_
#define _OBJECTS_H_

extern void GenerateObjects(tTrack *track, void *TrackHandle, void *CfgHandle, FILE *save_fd, char *meshFile);
extern int GetObjectsNb(void *TrackHandle);

#endif /* _OBJECTS_H_ */


text:
<?php

namespace IrishDan\ResponsiveImageBundle\Generator;

use Sensio\Bundle\GeneratorBundle\Generator\Generator;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpKernel\Bundle\BundleInterface;

/**
 * Generates a Notification inside a bundle.
 */
class ImageEntityGenerator extends Generator
{
    /** @var Filesystem */
    private $filesystem;
    private $overwrite;

    /**
     * NotificationGenerator constructor.
     *
     * @param Filesystem $filesystem
     * @param bool       $overwrite
     */
    public function __construct(Filesystem $filesystem, $overwrite = false)
    {
        $this->filesystem = $filesystem;
        $this->overwrite  = $overwrite;
    }

    /**
     * @param BundleInterface $bundle
     * @param                 $name
     */
    public function generate(BundleInterface $bundle, $name)
    {
        $bundleDir = $bundle->getPath();
        $imageDir  = $bundleDir . '/Entity';
        self::mkdir($imageDir);

        $imageClassName = $name;
        $imageFile      = $imageDir . '/' . $imageClassName . '.php';

        $parameters = [
            'namespace'  => $bundle->getNamespace(),
            'class_name' => $imageClassName,
            'name'       => $name,
            'table'      => strtolower($name), // @TODO: Use the tablize function
        ];

        // Build an array of files to be created
        $filesArray   = [];
        $filesArray[] = [
            'entity/Image.php.twig',
            $imageFile,
            $parameters,
        ];

        if (!empty($filesArray)) {
            $this->generateFiles($filesArray);
        }
    }

    /**
     * @param array $files
     */
    protected function generateFiles(array $files)
    {
        // Set generator to look in correct directory for notifications template.
        $path = __DIR__ . '/../Resources/skeleton';
        $this->setSkeletonDirs([$path]);

        // Check that each file does not already exist
        foreach ($files as $file) {
            if ($this->filesystem->exists($file[1]) && empty($this->overwrite)) {
                throw new \RuntimeException(sprintf('"%s" already exists', $file[1]));
            }
        }

        // Generate each file
        foreach ($files as $file) {
            // Template, destination, params
            $this->renderFile($file[0], $file[1], $file[2]);
        }
    }
}


text:
require 'css_parser'
require 'load_dir'
require 'format'
require 'html_parser'

class ParseDir < LoadDir
  include Format
  include HtmlParser
  include CssParser

  attr_accessor :css, :html

  def initialize(args)
    super(args)
    @css = {}
    @html = {}
    self.segregate
    self.parse_css
  end

  def css?(file)
    true if /\.css\S*\z/.match(file)
  end

  def html?(file)
    true if/\.html\S*\z/.match(file)
  end

  def segregate
    self.files.each do |file, path|
      if self.css?(file)
        self.css[file] = path
      elsif self.html?(file)
        self.html[file] = path
      end
    end
  end

  def parse_css
    hash = {}
    self.css.each do |file, path|
      parser = CssParser::Parser.new
      parser.load_file!(file, path, :all)
      parser.each_selector(:all) do |selector, dec, spec|
        unless /(^\/|\$|@|\d|:hover)/.match(selector)
          hash[selector] = dec
        end
      end
    end
    hash
  end

  def found hash=self.parse_css
    tmp = {}
    self.html.each do |file|
      hash.each do |sel, des|
        if sel.match("#")
          tmp[sel] = des if id_exists?(sel, file.last) == true
        elsif sel.match(/^\./)
          tmp[sel] = des if class_exists?(sel, file.last) == true
        elsif sel.match(/^\w/)
          tmp[sel] = des if  parent_exists?(sel, file.last) == true
        end
      end
    end
    tmp
  end

  def empty
    hash = {}
    all = self.parse_css.inject([]) {|a, k| a << k}
    found_css = self.found.inject([]) {|a, k| a << k}
    empty_css = all - found_css
    empty_css.each {|arr| hash[arr.first] = arr.last}
    hash
  end

  def success?
    if self.write_index
     ParseDir.success_message
    else
     ParseDir.failure_message
    end
  end

  def self.success_message
   puts Time.now.strftime("%B %d %Y %r")
   puts "Your report was generated at #{Dir.pwd}/old_style/index/html"
   true
  end

end


text:
titel: Design Basics
kuerzel: v-db2
verantwortlich: cn
typ: vortrag
pflicht: false
termine: 2017-04-28 11:30
empfohlene-voraussetzungen:
published: true
dauer: 90
raum: 3.102
info: Was sind grundlegende Fragen im Design und welche Rolle spielt Design in der Medieninformatik?
---

## Worum geht es?

Heute befassen wir uns mit einer Reihe von Grundbegriffen und Sichtweisen im Design. Hier mal ein paar Beispiele:

- Welche Rolle spielt Design?
- Welche Rolle kommt dem Design in der Informatik/ Medieninformatik zu?
- Woran erkennen wir gutes Design?
- Wie können wir Design beschreiben?

Außerdem lernen wir die Methoden "Axis Map" und das "Semantische Differential" kennen. Darüber hinaus beschäftigen wir uns mit Grundfragen der Kommunikation, Interaktion und der visuellen Wahrnehmung.

## Material
* [Folien zu Design Basics](../../download/inputs/design-basics-describe.pdf)


text:
// Copyright 2013 Google Inc. 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.

package dfa.axis.v1_20;

import com.google.api.ads.common.lib.auth.OfflineCredentials;
import com.google.api.ads.common.lib.auth.OfflineCredentials.Api;
import com.google.api.ads.dfa.axis.factory.DfaServices;
import com.google.api.ads.dfa.axis.v1_20.CreativeField;
import com.google.api.ads.dfa.axis.v1_20.CreativeFieldRemote;
import com.google.api.ads.dfa.axis.v1_20.CreativeFieldSaveResult;
import com.google.api.ads.dfa.lib.client.DfaSession;
import com.google.api.client.auth.oauth2.Credential;

/**
 * This example creates a creative field associated with a given advertiser. To
 * get an advertiser ID, run GetAdvertisers.java.
 *
 * Credentials and properties in {@code fromFile()} are pulled from the
 * "ads.properties" file. See README for more info.
 */
public class CreateCreativeField {

  // Set the name of associated advertiser for the new creative field.
  private static final String CREATIVE_FIELD_NAME = "INSERT_CREATIVE_FIELD_NAME_HERE";
  private static final String ADVERTISER_ID = "INSERT_ADVERTISER_ID_HERE";

  public static void runExample(
      DfaServices dfaServices, DfaSession session, String creativeFieldName, long advertiserId)
          throws Exception {
    // Request the service.
    CreativeFieldRemote service = dfaServices.get(session, CreativeFieldRemote.class);

    // Create the creative field.
    CreativeField creativeField = new CreativeField();
    creativeField.setId(-1);
    creativeField.setName(creativeFieldName);
    creativeField.setAdvertiserId(advertiserId);

    // Save the creative field.
    CreativeFieldSaveResult creativeFieldSaveResult = service.saveCreativeField(creativeField);

    // Display the new creative field ID.
    System.out.printf("Creative field with ID \"%s\" was created.%n",
        creativeFieldSaveResult.getId());
  }

  public static void main(String[] args) throws Exception {
    // Generate a refreshable OAuth2 credential, which replaces legacy passwords
    // and can be used in place of a service account.
    Credential oAuth2Credential = new OfflineCredentials.Builder()
        .forApi(Api.DFA)
        .fromFile()
        .build()
        .generateCredential();

    // Construct a DfaSession.
    DfaSession session = new DfaSession.Builder()
        .fromFile()
        .withOAuth2Credential(oAuth2Credential)
        .build();

    DfaServices dfaServices = new DfaServices();

    long advertiserId = Long.parseLong(ADVERTISER_ID);

    runExample(dfaServices, session, CREATIVE_FIELD_NAME, advertiserId);
  }
}


text:
package it.eng.liferay.cas.integration;

/*
 *
 * MODIFY FOR OTHER PROJECT
 *
 */

public class AttributeNames {
	public static final String ROLE = "Role";
	public static final String ORGANIZATION = "Organization";
	public static final String VIRTUAL_ENTERPRISE = "VirtualOrganization";
	public static final String NAME = "Name";
	public static final String EMAIL = "Email";

}


text:
use strict;
use warnings;
use v5.10;

use File::Basename;

# consume the progress file
# which maps milestone to progress for each backend
# format is:
#   milestone-name 2c-progress pancake-progress
#
# 2c-progress can be any of:
#   skip - do not test
#   fail-compile - fails to compile in icarus
#   fail-c-compiler - icarus compiles, fails under c compiler
#   fail-runtime - icarus compiles, c compiler compiles, runtime doesn't exit cleanly
#   fail-output - icarus compiles, c compiler compiles, runtime exits clean, output doesn't match
#   pass - icarus compiles, c compiler compiles, runtime exits clean, output matches expected
#
# pancake-progress can be any of:
#   skip - do not test
#   fail-runtime - fails to compile or run
#   fail-output - output is not as expected
#   pass - runs cleanly and output is as expected

# for each *.ic we:
#   2c backend:
#     compile with icarus to c
#     compile the c with a c compiler
#     run the output binary
#     capture exit status
#     compare stdout with matching *.exp file
#   pancake backend:
#     run through pancake backend
#     capture exit status
#     compare stdout with atching *.exp file

# consume progress file
my %progress;
open( my $fh, '<', 't/milestones/progress' ) or
  die "failed to open progress file : $!";

for my $line (<$fh>){
  my @parts = split /\s+/, $line;
  if( @parts != 3 ){
    die "Invalid length for (@parts), expected 3 parts";
  }

  my $milestone = $parts[0];
  my $progress_2c = $parts[1];
  die "unknown option '$progress_2c'" unless in_list($progress_2c, qw/skip fail-compile fail-c-compiler fail-runtime fail-outpiut pass/);
  my $progress_pancake = $parts[2];
  die "unknown option '$progress_pancake" unless in_list($progress_pancake, qw/skip fail-runtime fail-output pass/);

  $progress{$milestone} = {
    '2c' => $progress_2c,
    'pancake' => $progress_pancake,
  };
}

close $fh;

# go through milestone files
my @milestones = sort <t/milestones/*.ic>;

# check if a given item is in a list
# returns 1 if it is
# returns 0 if it is not
sub in_list {
  my $item = shift // die;
  my @list = @_;
  die "in_list: didn't get any items for list" unless @list;

  # using `eq` for strings
  if( grep {$item eq $_} @list ){
    return 1;
  }

  return 0;
}

# run a given command
# die if that command fails
# otherwise return the output of that command
sub run_cmd_die {
  my $cmd = shift // die "no command given";
  die "too many args" if @_;

  my $out = `$cmd`;
  my $ret = $?;

  if ($ret) {
    die "Failed to run command '${cmd}'";
  }

  return $out;
}

# run a given command
# return a boolean on success
#  1 => ran cleanly
#  0 => failed
sub run_cmd_bool {
  my $cmd = shift // die "no command given";
  die "too many args" if @_;

  my $out = `$cmd`;
  my $ret = $?;

  if ($ret) {
    return 0; # fail
  }

  return 1; # success
}

# run a given command
# return output on success (string)
# returns undef on failure
sub run_cmd_undef {
  my $cmd = shift // die "no command given";
  die "too many args" if @_;

  my $out = `$cmd`;
  my $ret = $?;

  if ($ret) {
    return undef;
  }

  return $out;
}

sub slurp {
  my $fn = shift // die;
  die if @_;

  my $contents = "";

  open(my $fh, '<', "$fn") or die "Failed to open file '$fn': $!";
  {
    $/ = undef;
    $contents = <$fh>;
  }
  close($fh);

  return $contents;
}

# compare expected output in file
# to actual output
# returns (1, $exp) if they are equal
# returns (0, $exp) i they are different
sub compare {
  my $exp_fn = shift // die;
  my $got = shift // die;
  die if @_;

  my $exp = slurp("$exp_fn");

  if( $exp eq $got ){
    # success
    return (1, $exp);
  }

  return (0, $exp);
}

sub check_2c {
  my $basename = shift // die;
  my $exp = shift // die;
  my $expected_progress = shift // die;
  die if @_;

  my $cout = "$basename.c";

  # remove all files we want to use
  run_cmd_die("rm -rf $cout");
  run_cmd_die("rm -rf $basename");

  {
    my $cmd_0 = "./icarus 2c t/milestones/${basename}.ic -o ${cout}";
    my $prog_0 = run_cmd_bool($cmd_0);
    if( not $prog_0 ){
      if( 'fail-compile' eq "$expected_progress" ){
        run_cmd_die("rm -rf $cout");
        run_cmd_die("rm -rf $basename");
        return; # success
      }
      die "check_2c:
           when running command '$cmd_0'
           we received exit code '$prog_0'
           this constitues a 'fail-compile'
           but our expected progress was '$expected_progress'"; # failure
    }
  }

  {
    my $cmd_1 = "cc ${cout} -o ${basename}";
    my $prog_1 = run_cmd_bool($cmd_1);
    if( not $prog_1 ){
      if( 'fail-c-compiler' eq "$expected_progress" ){
        run_cmd_die("rm -rf $cout");
        run_cmd_die("rm -rf $basename");
        return; # success
      }
      die "check_2c:
           when running command '$cmd_1'
           we received exit code '$prog_1'
           this constitues a 'fail-c-compiler'
           but our expected progress was '$expected_progress'"; # failure
    }
  }

  {
    my $cmd_2 = "./${basename}";
    my $runtime_output = run_cmd_undef($cmd_2);
    if( not defined $runtime_output ){
      if( 'fail-runtime' eq "$expected_progress" ){
        run_cmd_die("rm -rf $cout");
        run_cmd_die("rm -rf $basename");
        return; # success
      }
      die "check_2c:
           when running command '$cmd_2'
           the program crashed unexpectantly
           this constitues a 'fail-runtime'
           but our expected progress was '$expected_progress'"; # failure
    }

    my ($res, $exp) = compare($exp, $runtime_output);
    unless( 1 == $res ){
      if( 'fail-output' eq "$expected_progress" ){
        run_cmd_die("rm -rf $cout");
        run_cmd_die("rm -rf $basename");
        return;
      }
      say "check_2c:
           when running command '$cmd_2'
           the program gave us output that didn't match out expected
           this constitues a 'fail-output'";
      say "got output:
          '$runtime_output'";
      say "expected output:
          '$exp'";
      die "unexpected fail-output";
    }
  }

  if( 'pass' ne "$expected_progress" ){
    die "check_2c:
         for test '$basename'
         all steps passed
         but expected progress was '$expected_progress'";
  }

  # cleanup
  run_cmd_die("rm -rf $cout");
  run_cmd_die("rm -rf $basename");
}

sub check_pancake {
  my $basename = shift // die;
  my $exp = shift // die;
  my $expected_progress = shift // die;
  die if @_;

  {
    my $cmd_0 = "./icarus pancake t/milestones/${basename}.ic";
    my $runtime_output = run_cmd_undef($cmd_0);
    if( not defined $runtime_output ){
      if( 'fail-runtime' eq "$expected_progress" ){
        return; # success
      }
      die "check_pancake:
           when running command '$cmd_0'
           the program crashed unexpectantly
           this constitues a 'fail-runtime'
           but our expected progress was '$expected_progress'"; # failure
    }

    # FIXME TODO cannot yet get good results here
    # due to debugging noise
    my ($res, $exp) = compare($exp, $runtime_output);
    unless( 1 == $res ){
      if( 'fail-output' eq "$expected_progress" ){
        return
      }
      say "check_pancake
           when running command '$cmd_0'
           the program gave us output that didn't match out expected
           our expected progress was '$expected_progress'
           this constitues a 'fail-output'";
      say "got output:
          '$runtime_output'";
      say "expected output:
          '$exp'";
      die "unexpected fail-output";
    }
  }

  if( 'pass' ne "$expected_progress" ){
    die "check_pancake:
         for test '$basename'
         all steps passed
         but expected progress was '$expected_progress'";
  }
}

for my $milestone (@milestones){
  my $basename = basename($milestone, qw/.ic/);
  my $exp = $milestone;
  $exp =~ s/.ic$/.exp/;
  if( ! -e "$exp" ){
    die "Could not find exp file '$exp' for ic file '$milestone' with basename '$basename'";
  }
  if( ! exists($progress{$basename}) ){
    die "Could not find expected progress for milestone '$milestone'";
  }
  my $progress_2c = $progress{$basename}->{"2c"} || die;
  my $progress_pancake = $progress{$basename}->{"pancake"} || die;

  if( 'skip' ne "$progress_2c" ){
    check_2c($basename, $exp, $progress_2c);
  }

  if( 'skip' ne "$progress_pancake" ){
    check_pancake($basename, $exp, $progress_pancake);
  }
}

say "all milestones match t/milestones/progress";

# FIXME TODO would be better to perform all work in temporary dir


text:
class Calibrator {
public:
  Calibrator(Eyes* frontEye);
  void init();
  void calibrate(int situation);
  void test_calibrate();
  void try_calibrate();

private:
  Eyes* frontEye; // to get the sensor reading
  double turned_angle; // to restore original orientation

  void sided_calibrate();
  void front_calibrate();

  void one_side_calibrate();
  void one_side_calibrate(int times);
  bool calibrate_angle();
  void calibrate_distance();

  unsigned long last_time_trial;
};
#endif


text:
angular.module('opApp').controller('opDateTimeController', ['$scope', '$timeout', 'toaster', 'opConfig', 'opStateService', '$log',
    function ($scope, $timeout, toaster, opConfig, opStateService, $log) {
        'use strict';

        var dateRangeCreated = false;
        $scope.initializing = false;

        var drpOptions = {
            minDate: moment('1970-01-01T00:00:00 Z').utc(),
            maxDate: moment().utc().add('days', 1),
            showDropdowns: true,
            timePicker: true,
            timePicker12Hour: false,
            timePickerIncrement: 1,
            opens: 'right',
            format: 'MM/DD/YYYY HH:mm:ss',
            startDate: $scope.dateRange ? $scope.dateRange[0] : undefined,
            endDate: $scope.dateRange ? $scope.dateRange[1] : undefined
        };

        $scope.dateExpanded = false;
        $scope.valid = {
            duration: false,
            startRange: true,
            startTimeRange: true,
            endRange: true,
            endTimeRange: true
        };

        $scope.validationError = 'sup';
        $scope.dateKey = 'duration';
        $scope.duration = '1';
        $scope.durationKey = 'd';

        $scope.startDate = moment.utc().startOf('d').format('MM/DD/YYYY');
        $scope.startTime = moment.utc().startOf('d').format('HH:mm:ss');
        $scope.endDate = moment.utc().startOf('d').format('MM/DD/YYYY');
        $scope.endTime = moment.utc().endOf('d').format('HH:mm:ss');

        $scope.rangeTimeout = false;

        // Wire in the pre-configured date periods for ranges
        $scope.datelist = opConfig.dateList;

        var oldStart = '', oldEnd = '';
        var oldRange;
        var dateFormat = 'MM/DD/YYYY';
        var timeFormat = 'HH:mm:ss';
        var parseFormat = 'MM/DD/YYYYHH:mm:ss';

        /**
         * Check whether the date range is valid as well as within our app's ability based on our max capabilities
         * @param newDateRange          requested new range
         * @param previousDateRange     previous range that was being used
         * @param maxDaysBack           max time period in days
         */
        var enforceDateRangeLimits = function (newDateRange, previousDateRange, maxDaysBack) {
            var compareFormat = 'MM/DD/YYYYHH:mm:ss';
            var message;
            if(newDateRange[0].diff(newDateRange[1], 'days', true) > 0)
            {
                message = 'Start date cannot be after End date.';
                $log.log(message);
                toaster.pop('note', message);
                newDateRange[0] = previousDateRange[0];
                newDateRange[1] = previousDateRange[1];
            }
            if (Math.abs(newDateRange[0].diff(newDateRange[1], 'days', true)) > maxDaysBack) {
                if (angular.isDefined(previousDateRange)) {
                    if (previousDateRange[0].format(compareFormat) !== newDateRange[0].format(compareFormat) &&
                        previousDateRange[1].format(compareFormat) === newDateRange[1].format(compareFormat)) {
                        newDateRange[1] = moment(newDateRange[0]).add('days', maxDaysBack);
                        message = 'Start date is more than ' + maxDaysBack + ' days before ' +
                            'End Date.  End Date has been adjusted to not exceed this period.';
                        $log.log(message);
                        toaster.pop('note', message);
                    }
                    else if (previousDateRange[0].format(compareFormat) === newDateRange[0].format(compareFormat) &&
                        previousDateRange[1].format(compareFormat) !== newDateRange[1].format(compareFormat)) {
                        newDateRange[0] = moment(newDateRange[1]).subtract('days', maxDaysBack);
                        message = 'End date is more than ' + opConfig.maxDaysBack + ' days after ' +
                            'Start Date.  Start Date has been adjusted to not exceed this period.';
                        $log.log(message);
                        toaster.pop('note', message);
                    }
                }
            }
        };

        /**
         * Get the latest temporal filtering from the state service and set up our filters to be in line visually
         */
        var updateTemporalFilters = function () {
            /*
             use initializing variable to keep filters from being pushed back out to location causing an endless
             update loop
             */
            $scope.initializing = true;
            var filter = opStateService.getTemporalFilter();

            if (filter.type === 'range') {
                $scope.setDateRange([filter.start, filter.stop]);

                drpOptions.startDate = $scope.dateRange[0];
                drpOptions.endDate = $scope.dateRange[1];
                oldRange = $scope.dateRange;
            }
            else if (filter.type === 'duration') {
                $scope.durationKey = filter.interval;
                $scope.duration = filter.value;
                $scope.setDuration();
            }
            $scope.initializing = false;
        };

        $scope.$watch('dateRange', function () {
            if (_.isArray($scope.dateRange)) {
                if ($scope.dateRange.length === 2 &&
                    $scope.dateRange[0].isValid &&
                    $scope.dateRange[1].isValid &&
                    $scope.dateRange[0].isValid() &&
                    $scope.dateRange[1].isValid() &&
                    (oldStart !== $scope.dateRange[0].format(parseFormat) ||
                    oldEnd !== $scope.dateRange[1].format(parseFormat))) {

                    enforceDateRangeLimits($scope.dateRange, oldRange, opConfig.maxDaysBack);

                    $scope.startDate = $scope.dateRange[0].format('MM/DD/YYYY');
                    $scope.startTime = $scope.dateRange[0].format('HH:mm:ss');
                    $scope.endDate = $scope.dateRange[1].format('MM/DD/YYYY');
                    $scope.endTime = $scope.dateRange[1].format('HH:mm:ss');

                    oldStart = $scope.startDate + $scope.startTime;
                    oldEnd = $scope.endDate + $scope.endTime;

                    if (dateRangeCreated) {
                        angular.element('.start, .end').daterangepicker({
                            action: 'update',
                            startDate: $scope.dateRange[0],
                            endDate: $scope.dateRange[1]
                        });

                        $scope.setDateRange($scope.dateRange);
                    }
                }
            }
        });

        /**
         * Set/update date range with val
         * @param val   new date range
         */
        $scope.setDateRange = function (val) {
            $scope.dateKey = 'range';

            if (val && val[0] && val[0].isValid() && val[1] && val[1].isValid()) {
                $scope.dateRange = val;
            } else {
                $scope.dateRange = [
                    moment.utc($scope.startDate + ' ' + $scope.startTime, 'MM/DD/YYYY HH:mm:ss'),
                    moment.utc($scope.endDate + ' ' + $scope.endTime, 'MM/DD/YYYY HH:mm:ss')
                ];
            }

            if ($scope.dateRange[0].isValid() && $scope.dateRange[1].isValid() && !$scope.initializing) {
                opStateService.setTimeRange($scope.dateRange[0], $scope.dateRange[1]);
            }
        };

        /**
         * Determine if a value is an integer
         * @param value     value to test
         * @returns {boolean}   true if int, false otherwise
         */
        var isInt = function (value) {
            return !isNaN(value) && parseInt(Number(value)) == value; // jshint ignore:line
        };

        /**
         * Set the model to duration time type
         */
        $scope.setDuration = function () {
            $scope.dateKey = 'duration';

            if (isInt($scope.duration) && $scope.durationKey.length === 1) {
                var initialValue = $scope.duration;
                var max;
                var unit;
                switch ($scope.durationKey) {
                    case 'h':
                        if (initialValue > opConfig.maxDaysBack * 24) {
                            max = opConfig.maxDaysBack * 24;
                            unit = 'hours';
                        }
                        break;
                    case 'd':
                        if (initialValue > opConfig.maxDaysBack) {
                            max = opConfig.maxDaysBack;
                            unit = 'days';
                        }
                        break;
                    case 'w':
                        if (initialValue > opConfig.maxDaysBack / 7) {
                            max = Math.floor(opConfig.maxDaysBack / 7);
                            unit = 'weeks';
                        }
                        break;
                }
                if (max) {
                    $scope.validationError = 'Please reduce duration value to be less than or equal to ' + max + ' ' + unit + '.';
                    $scope.valid.duration = false;
                    $log.log($scope.validationError);
                    toaster.pop('error', $scope.validationError);
                    return;
                }

                $scope.validationError = '';
                $scope.valid.duration = true;
                if (!$scope.initializing) {
                    opStateService.setDuration($scope.durationKey, $scope.duration);
                }
            }
            else {
                $scope.validationError = 'Please enter whole number value for duration';
                $scope.valid.duration = false;

                $log.log($scope.validationError);
            }
        };

        /**
         * Set duration key (like 'h' for hour, 'm' for minute, etc)
         * @param newKey    new key to set as active
         */
        $scope.setDurationKey = function (newKey) {
            $scope.durationKey = newKey;

            $scope.setDuration();
        };

        /**
         * Helper function to create friendly string to be displayed when the temporal filter is rolled up
         * @returns {string}
         */
        $scope.friendlyDate = function () {
            if ($scope.dateKey === 'duration') {
                var names = {h: ' Hour', d: ' Day', w: ' Week'};
                var rangeName, num = parseInt($scope.duration, 10);
                rangeName = 'Last';
                if (num === 1) {
                    return rangeName + names[$scope.durationKey];
                } else {
                    return rangeName + ' ' + num + names[$scope.durationKey] + 's';
                }
            }
            else if ($scope.dateKey === 'range') {
                return $scope.dateRange[0].format(dateFormat) + ' - ' + $scope.dateRange[1].format(dateFormat);
            }
        };

        /**
         * Set whether the temporal key is duration or range
         * @param key
         */
        $scope.setDateKey = function (key) {
            switch (key) {
                case 'duration':
                    $scope.setDuration();
                    break;
                case 'range':
                    $scope.setDateRange();
                    break;
            }
        };

        /**
         * When user is trying to change the start date/time, lets verify it.
         */
        $scope.updateStart = function () {
            if ($scope.rangeTimeout) {
                $timeout.cancel($scope.rangeTimeout);
            }
            $scope.rangeTimeout = $timeout(function () {
                $scope.valid.startRange = true;
                $scope.valid.startTimeRange = true;

                var startDate = moment($scope.startDate, dateFormat, true);
                if(!startDate.isValid()){
                    $scope.valid.startRange = false;
                }
                var startTime = moment($scope.startTime, timeFormat, true);
                if(!startTime.isValid()){
                    $scope.valid.startTimeRange = false;
                }

                if ((startDate.isValid() && startTime.isValid()) && $scope.dateKey === 'range' && oldStart !== $scope.startDate + $scope.startTime) {
                    var date = moment.utc($scope.startDate + $scope.startTime, parseFormat, true);
                    if (date.isValid()) {
                        oldStart = $scope.startDate + $scope.startTime;
                        $scope.dateRange = [date, $scope.dateRange[1]];

                        enforceDateRangeLimits($scope.dateRange, oldRange, opConfig.maxDaysBack);

                        if (!$scope.initializing) {
                            drpOptions.startDate = $scope.dateRange[0];
                            drpOptions.endDate = $scope.dateRange[1];
                            updateDatePicker($scope.dateRange[0], $scope.dateRange[1]);
                            opStateService.setTimeRange($scope.dateRange[0], $scope.dateRange[1]);

                            if(dateRangeCreated) {
                                angular.element('.start, .end').daterangepicker({
                                    action: 'update',
                                    startDate: $scope.dateRange[0],
                                    endDate: $scope.dateRange[1]
                                });
                            }
                            $scope.setDateRange($scope.dateRange);
                        }
                    }
                }
            }, 200);
        };

        /**
         * When user is trying to change the end date/time, lets verify it.
         */
        $scope.updateEnd = function () {
            if ($scope.rangeTimeout) {
                $timeout.cancel($scope.rangeTimeout);
            }

            $scope.rangeTimeout = $timeout(function () {
                $scope.valid.endRange = true;
                $scope.valid.endTimeRange = true;

                var endDate = moment($scope.endDate, dateFormat, true);
                if(!endDate.isValid()){
                    $scope.valid.endRange = false;
                }
                var endTime = moment($scope.endTime, timeFormat, true);
                if(!endTime.isValid()){
                    $scope.valid.endTimeRange = false;
                }

                if ((endDate.isValid() && endTime.isValid()) && $scope.dateKey === 'range' && oldEnd !== $scope.endDate + $scope.endTime) {
                    var date = moment.utc($scope.endDate + $scope.endTime, parseFormat, true);
                    if (date.isValid()) {
                        oldEnd = $scope.endDate + $scope.endTime;
                        $scope.dateRange = [$scope.dateRange[0], date];

                        enforceDateRangeLimits($scope.dateRange, oldRange, opConfig.maxDaysBack);

                        if (!$scope.initializing) {
                            drpOptions.startDate = $scope.dateRange[0];
                            drpOptions.endDate = $scope.dateRange[1];
                            updateDatePicker($scope.dateRange[0], $scope.dateRange[1]);
                            opStateService.setTimeRange($scope.dateRange[0], $scope.dateRange[1]);

                            if(dateRangeCreated) {
                                angular.element('.start, .end').daterangepicker({
                                    action: 'update',
                                    startDate: $scope.dateRange[0],
                                    endDate: $scope.dateRange[1]
                                });
                            }
                            $scope.setDateRange($scope.dateRange);
                        }
                    }
                }
            }, 200);
        };

        /**
         * Move the date range up by whatever selection we have (hour,  day, etc.) active
         */
        $scope.advanceDateRange = function () {
            var startDate = moment($scope.dateRange[0]);
            var stopDate = moment($scope.dateRange[1]);

            if (startDate.isValid() && stopDate.isValid()) {
                var diff = Math.abs(startDate.diff(stopDate));

                startDate = moment(stopDate);
                stopDate.add('ms', diff);
                $scope.setDateRange([startDate, stopDate]);
            }
        };

        /**
         * Move the date range back by whatever selection we have (hour,  day, etc.) active
         */
        $scope.retreatDateRange = function () {
            var startDate = moment($scope.dateRange[0]);
            var stopDate = moment($scope.dateRange[1]);

            if (startDate.isValid() && stopDate.isValid()) {
                var diff = Math.abs(startDate.diff(stopDate));

                stopDate = moment(startDate);
                startDate.subtract('ms', diff);
                $scope.setDateRange([startDate, stopDate]);
            }
        };

        /**
         * Update the date range picker widget
         * @param start     start date/time
         * @param end       end date/time
         */
        var updateDatePicker = function (start, end) {
            $scope.dateRange = [start, end];
            $scope.$apply();
        };

        /**
         * Broadcast receiver for when filters are updated to update our temporal action
         */
        $scope.$on('filters-updated', function () {
            updateTemporalFilters();
        });

        /**
         * Broadcast receiver for when the latest data button is pressed to be able to set the time filters
         * for whatever the latest time for a layer is as the end time and then that time minus 24 hours as the
         * start time.
         */
        $scope.$on('latest-data-button', function (event, times) {
            $scope.setDateRange(times);
        });

        /**
         * Start this thing!
         */
        var initialize = function () {
            $log.log('Starting up opDateTimeController...');
            updateTemporalFilters();

            $timeout(function () {
                angular.element('.start').daterangepicker(_.extend(drpOptions, {onlyShow: 'start'}), updateDatePicker);
                angular.element('.end').daterangepicker(_.extend(drpOptions, {onlyShow: 'end'}), updateDatePicker);
                dateRangeCreated = true;
            }, 1000);
        };

        // kick start this thang!
        initialize();
    }]);


text:
#include "FeatInterp.hpp"

#include <vector>
#include <opencv2/opencv.hpp>
#include "Log.hpp"
#include "FauxLearner.hpp"

namespace deformable_depth
{
  using namespace std;
  using namespace cv;

  // SECTION: FeatureInterpetation
  FeatureInterpretation::FeatureInterpretation() : total_length(0)
  {

  }

  string FeatureInterpretation::interp_at_pos(int start)
  {
    for(auto && interp : *this)
      if(interp.second[0] == start)
	return interp.first;
    return "NULL";
  }

  std::vector< double > FeatureInterpretation::select(string aspect, const std::vector< double >& w)
  {
    assert(this->find(aspect) != this->end());
    size_t first = (*this)[aspect][0];
    size_t last  = first + (*this)[aspect][1];
    return vector<double>(w.begin()+first,w.begin()+last);
  }

  void FeatureInterpretation::set(string aspect, const SparseVector&value, SparseVector& to) const
  {
    bool has_aspect = (this->find(aspect) != this->end());
    if(!has_aspect)
    {
      cout << "FeatureInterpretation::set missing aspect: " << aspect << endl;
      assert(false);
    }

    bool aspect_size_works = (*this).at(aspect)[1] == value.size();
    if(!aspect_size_works)
    {
      int expected = (*this).at(aspect)[1];
      int acutal = value.size();
      cout << printfpp("aspect size expected %d actual %d",expected,acutal) << endl;
      assert(aspect_size_works);
    }
    to.set((*this).at(aspect)[0],value);
  }

  void FeatureInterpretation::init_include_append_model(ExposedLDAModel& model,string name)
  {
    int cur_length = model.getLearner().getFeatureLength();
    init_include_append_model(cur_length,name);
  }

  void FeatureInterpretation::init_include_append_model(int cur_length, string name)
  {

    log_file << "joint_interp, " << name << " length = " << cur_length << endl;
    (*this)[name] = Vec2i(total_length,cur_length);
    total_length += cur_length;
  }

  string FeatureInterpretation::toString() const
  {
    ostringstream oss;

    for(auto&pair : *this)
      oss << " " << pair.first << " " << pair.second;

    return oss.str();
  }

  void FeatureInterpretation::flush(
    const vector<double>& joint_feat, std::map< string, SettableLDAModel& >& models)
  {
    for(const auto & model : models)
    {
      vector<double> part_wf = select(model.first,joint_feat);
      model.second.setLearner(new FauxLearner(part_wf,0.0f));
      model.second.update_model();
    }
  }

  SparseVector FeatureInterpretation::pack(const map< string, SparseVector >& part_feats)
  {
    SparseVector feature(total_length);

    for(const auto & part_feat : part_feats)
    {
      if(part_feat.second.size() == 0)
	return vector<double>{};

      require_equal<size_t>(part_feat.second.size(),at(part_feat.first)[1]);
      feature.set(at(part_feat.first)[0],part_feat.second);
    }

    return feature;
  }

  void write(FileStorage& fs, string& str, const FeatureInterpretation& interp )
  {
    fs << "{";
    fs << "this"; write(fs,(std::map<string,Vec2i>&)interp);
    fs << "total_length" << (int)interp.total_length;
    fs << "}";
  }

  void write(FileStorage& fs, string& str, const shared_ptr< FeatureInterpretation >& interp)
  {
    write(fs,str,*interp);
  }

  void read(const FileNode& node, FeatureInterpretation& interp, FeatureInterpretation def)
  {
    int total_length;
    node["total_length"] >> total_length;
    interp.total_length = total_length;
    std::map<string,Vec2i>&base_ref = interp;
    read(node["this"],base_ref);
  }

  void read(const FileNode& node, shared_ptr< FeatureInterpretation >& interp,
	    shared_ptr< FeatureInterpretation > )
  {
    interp.reset(new FeatureInterpretation());
    read(node,*interp);
  }
}


text:
#include <sodium.h>

#include <erl_nif.h>

#include "aead.h"
#include "enacl.h"

/*
 * AEAD ChaCha20 Poly1305
 */
ERL_NIF_TERM
enacl_crypto_aead_chacha20poly1305_ietf_KEYBYTES(ErlNifEnv *env, int argc,
                                                 ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env, crypto_aead_chacha20poly1305_ietf_KEYBYTES);
}

ERL_NIF_TERM
enacl_crypto_aead_chacha20poly1305_ietf_NPUBBYTES(ErlNifEnv *env, int argc,
                                                  ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env, crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
}

ERL_NIF_TERM
enacl_crypto_aead_chacha20poly1305_ietf_ABYTES(ErlNifEnv *env, int argc,
                                               ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env, crypto_aead_chacha20poly1305_ietf_ABYTES);
}

ERL_NIF_TERM
enacl_crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX(
    ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env,
                         crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX);
}

ERL_NIF_TERM
enacl_crypto_aead_chacha20poly1305_ietf_encrypt(ErlNifEnv *env, int argc,
                                                ERL_NIF_TERM const argv[]) {
  ERL_NIF_TERM ret;
  ErlNifBinary key, nonce, ad, message, ciphertext;

  if (argc != 4)
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[0], &message))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[1], &ad))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[2], &nonce))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[3], &key))
    goto bad_arg;
  if (key.size != crypto_aead_chacha20poly1305_ietf_KEYBYTES)
    goto bad_arg;
  if (nonce.size != crypto_aead_chacha20poly1305_ietf_NPUBBYTES)
    goto bad_arg;

  if (!enif_alloc_binary(message.size +
                             crypto_aead_chacha20poly1305_ietf_ABYTES,
                         &ciphertext)) {
    goto err;
  }

  crypto_aead_chacha20poly1305_ietf_encrypt(ciphertext.data, NULL, message.data,
                                            message.size, ad.data, ad.size,
                                            NULL, nonce.data, key.data);

  ret = enif_make_binary(env, &ciphertext);
  goto done;

bad_arg:
  return enif_make_badarg(env);
err:
  ret = enacl_internal_error(env);
done:
  return ret;
}

ERL_NIF_TERM
enacl_crypto_aead_chacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc,
                                                ERL_NIF_TERM const argv[]) {
  ERL_NIF_TERM ret;
  ErlNifBinary key, nonce, ad, message, ciphertext;

  if (argc != 4)
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[0], &ciphertext))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[1], &ad))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[2], &nonce))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[3], &key))
    goto bad_arg;

  if (ciphertext.size < crypto_aead_chacha20poly1305_ietf_ABYTES)
    goto bad_arg;
  if (key.size != crypto_aead_chacha20poly1305_ietf_KEYBYTES)
    goto bad_arg;
  if (nonce.size != crypto_aead_chacha20poly1305_ietf_NPUBBYTES)
    goto bad_arg;

  if (!enif_alloc_binary(ciphertext.size -
                             crypto_aead_chacha20poly1305_ietf_ABYTES,
                         &message)) {
    return enacl_internal_error(env);
  }

  if (crypto_aead_chacha20poly1305_ietf_decrypt(
          message.data, NULL, NULL, ciphertext.data, ciphertext.size, ad.data,
          ad.size, nonce.data, key.data) != 0) {
    ret = enacl_error_tuple(env, "failed_verification");
    goto release;
  }

  ret = enif_make_binary(env, &message);
  goto done;
bad_arg:
  return enif_make_badarg(env);
release:
  enif_release_binary(&message);
done:
  return ret;
}

/*
 * AEAD XChaCha20 Poly1305
 */
ERL_NIF_TERM
enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES(ErlNifEnv *env, int argc,
                                                  ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_KEYBYTES);
}

ERL_NIF_TERM
enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES(ErlNifEnv *env, int argc,
                                                   ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
}

ERL_NIF_TERM
enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES(ErlNifEnv *env, int argc,
                                                ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_ABYTES);
}

ERL_NIF_TERM
enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX(
    ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
  return enif_make_int64(env,
                         crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX);
}

ERL_NIF_TERM
enacl_crypto_aead_xchacha20poly1305_ietf_encrypt(ErlNifEnv *env, int argc,
                                                 ERL_NIF_TERM const argv[]) {
  ErlNifBinary key, nonce, ad, message, ciphertext;
  ERL_NIF_TERM ret;

  if (argc != 4)
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[0], &message))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[1], &ad))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[2], &nonce))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[3], &key))
    goto bad_arg;

  if (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES)
    goto bad_arg;
  if (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
    goto bad_arg;

  if (!enif_alloc_binary(message.size +
                             crypto_aead_xchacha20poly1305_ietf_ABYTES,
                         &ciphertext)) {
    goto err;
  }

  crypto_aead_xchacha20poly1305_ietf_encrypt(
      ciphertext.data, NULL, message.data, message.size, ad.data, ad.size, NULL,
      nonce.data, key.data);

  ret = enif_make_binary(env, &ciphertext);
  goto done;

bad_arg:
  return enif_make_badarg(env);
err:
  ret = enacl_internal_error(env);
done:
  return ret;
}

ERL_NIF_TERM
enacl_crypto_aead_xchacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc,
                                                 ERL_NIF_TERM const argv[]) {
  ErlNifBinary key, nonce, ad, message, ciphertext;
  ERL_NIF_TERM ret;

  if (argc != 4)
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[0], &ciphertext))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[1], &ad))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[2], &nonce))
    goto bad_arg;
  if (!enif_inspect_binary(env, argv[3], &key))
    goto bad_arg;

  if (ciphertext.size < crypto_aead_xchacha20poly1305_ietf_ABYTES)
    goto bad_arg;
  if (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES)
    goto bad_arg;
  if (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
    goto bad_arg;

  if (!enif_alloc_binary(ciphertext.size -
                             crypto_aead_xchacha20poly1305_ietf_ABYTES,
                         &message)) {
    return enacl_internal_error(env);
  }

  if (crypto_aead_xchacha20poly1305_ietf_decrypt(
          message.data, NULL, NULL, ciphertext.data, ciphertext.size, ad.data,
          ad.size, nonce.data, key.data) != 0) {
    ret = enacl_error_tuple(env, "failed_verification");
    goto release;
  }

  ret = enif_make_binary(env, &message);
  goto done;

bad_arg:
  return enif_make_badarg(env);
release:
  enif_release_binary(&message);
done:
  return ret;
}


text:
using UnityEngine;
using System.Collections;
using UnityEngine.UI.Windows;
using UnityEngine.UI.Windows.Extensions;
using UnityEngine.Extensions;
using System.Collections.Generic;

namespace UnityEngine.UI.Windows.Components {

	public class LinkerComponent : WindowComponent {

		[ComponentChooser]
		public WindowComponent prefab;

		[HideInInspector]
		private WindowComponent instance;

		public T Get<T>(ref T instance) where T : IComponent {

			instance = this.Get<T>();

			return instance;

		}

		public T Get<T>() where T : IComponent {

			if (this.instance == null) {

				this.InitInstance();

			}

			return (T)(this.instance as IComponent);

		}

		public void InitPool(int capacity) {

			this.prefab.CreatePool(capacity, this.transform);
			if (this.prefab is LinkerComponent) {

				(this.prefab as LinkerComponent).InitPool(capacity);

			}

		}

		public override void OnInit() {

			base.OnInit();

			this.InitInstance();

		}

		private void InitInstance() {

			if (this.instance != null) {

				this.instance.OnInit();

			} else if (this.prefab != null) {

				this.instance = this.prefab.Spawn();
				this.instance.SetParent(this, false);
				this.instance.SetTransformAs(this.prefab);

				this.instance.Setup(this.GetLayoutRoot());
				this.instance.Setup(this.GetWindow());

				this.RegisterSubComponent(this.instance);

				//this.instance.OnInit();

			}

		}
		/*
		public override void OnDeinit() {

			base.OnDeinit();

			var instance = this.instance;
			if (instance != null) instance.OnDeinit();

		}

		public override void OnShowBegin(System.Action callback, bool resetAnimation = true) {

			var counter = 0;
			System.Action callbackItem = () => {

				++counter;
				if (counter < 2) return;

				if (callback != null) callback();

			};

			base.OnShowBegin(callbackItem, resetAnimation);
			this.instance.OnShowBegin(callbackItem, resetAnimation);

		}

		public override void OnShowEnd() {

			base.OnShowEnd();

			var instance = this.instance;
			if (instance != null) instance.OnShowEnd();

		}

		public override void OnHideBegin(System.Action callback, bool immediately = false) {

			var counter = 0;
			System.Action callbackItem = () => {

				++counter;
				if (counter < 2) return;

				if (callback != null) callback();

			};

			base.OnHideBegin(callbackItem, immediately);
			this.instance.OnHideBegin(callbackItem, immediately);

		}

		public override void OnHideEnd() {

			base.OnHideEnd();

			var instance = this.instance;
			if (instance != null) instance.OnHideEnd();

		}*/

	}

}


text:
/*
 * default_strategy.hpp
 *
 *  Created on: Jan 2, 2020
 *      Author: devel
 */

#ifndef SRC_LIBRARY_PC_IDENTIFIER_DEFAULT_STRATEGY_HPP_
#define SRC_LIBRARY_PC_IDENTIFIER_DEFAULT_STRATEGY_HPP_
#include "identification_strategy.hpp"

namespace license {
namespace hw_identifier {

class DefaultStrategy : public IdentificationStrategy {
public:
	DefaultStrategy();
	virtual ~DefaultStrategy();
	virtual LCC_API_HW_IDENTIFICATION_STRATEGY identification_strategy() const;
	virtual FUNCTION_RETURN generate_pc_id(HwIdentifier &pc_id) const;
	virtual std::vector<HwIdentifier> alternative_ids() const;
	virtual LCC_EVENT_TYPE validate_identifier(const HwIdentifier &identifier) const;
};
}  // namespace hw_identifier
} /* namespace license */

#endif /* SRC_LIBRARY_PC_IDENTIFIER_DEFAULT_STRATEGY_HPP_ */


text:
package br.ufc.great.jcaehv.model;

import java.util.LinkedHashSet;
import java.util.Set;

import br.ufc.great.jcaehv.context.ContextExpression;

public class HandlingBehavior {

	private Set<ContextExpression> handlingSteps;

	public HandlingBehavior() {
		handlingSteps = new LinkedHashSet<ContextExpression>();
	}

	public void addHandlingStep(ContextExpression step) {
		this.handlingSteps.add(step);
	}

	public Set<ContextExpression> getHandlingSteps() {
		return handlingSteps;
	}

	public boolean isEmpty() {
		return handlingSteps.isEmpty();
	}
}