text:
package org.apache.hadoop.hbase.client;

import java.io.IOException;
import java.util.List;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HRegionLocation;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.RegionLocations;
import org.apache.hadoop.hbase.ServerName;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.backoff.ClientBackoffPolicy;
import org.apache.hadoop.hbase.ipc.RpcControllerFactory;
import org.apache.yetus.audience.InterfaceAudience;

import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService;
import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService;

/** Internal methods on Connection that should not be used by user code. */
@InterfaceAudience.Private
// NOTE: Although this class is public, this class is meant to be used directly from internal
// classes and unit tests only.
public interface ClusterConnection extends Connection {

  /**
   * Key for configuration in Configuration whose value is the class we implement making a
   * new Connection instance.
   */
  String HBASE_CLIENT_CONNECTION_IMPL = "hbase.client.connection.impl";

  /**
   * @return - true if the master server is running
   * @deprecated this has been deprecated without a replacement
   */
  @Deprecated
  boolean isMasterRunning()
      throws MasterNotRunningException, ZooKeeperConnectionException;

  /**
   * Use this api to check if the table has been created with the specified number of
   * splitkeys which was used while creating the given table.
   * Note : If this api is used after a table's region gets splitted, the api may return
   * false.
   * @param tableName
   *          tableName
   * @param splitKeys
   *          splitKeys used while creating table
   * @throws IOException
   *           if a remote or network exception occurs
   */
  boolean isTableAvailable(TableName tableName, byte[][] splitKeys) throws
      IOException;

  /**
   * A table that isTableEnabled == false and isTableDisabled == false
   * is possible. This happens when a table has a lot of regions
   * that must be processed.
   * @param tableName table name
   * @return true if the table is enabled, false otherwise
   * @throws IOException if a remote or network exception occurs
   */
  boolean isTableEnabled(TableName tableName) throws IOException;

  /**
   * @param tableName table name
   * @return true if the table is disabled, false otherwise
   * @throws IOException if a remote or network exception occurs
   */
  boolean isTableDisabled(TableName tableName) throws IOException;

  /**
   * Retrieve TableState, represent current table state.
   * @param tableName table state for
   * @return state of the table
   */
  TableState getTableState(TableName tableName)  throws IOException;

  /**
   * Find the location of the region of tableName that row
   * lives in.
   * @param tableName name of the table row is in
   * @param row row key you're trying to find the region of
   * @return HRegionLocation that describes where to find the region in
   *   question
   * @throws IOException if a remote or network exception occurs
   */
  HRegionLocation locateRegion(final TableName tableName,
      final byte [] row) throws IOException;

  /**
   * @deprecated {@link #clearRegionLocationCache()} instead.
   */
  @Deprecated
  default void clearRegionCache() {
    clearRegionLocationCache();
  }

  void cacheLocation(final TableName tableName, final RegionLocations location);

  /**
   * Allows flushing the region cache of all locations that pertain to
   * tableName
   * @param tableName Name of the table whose regions we are to remove from
   *   cache.
   */
  void clearRegionCache(final TableName tableName);

  /**
   * Deletes cached locations for the specific region.
   * @param location The location object for the region, to be purged from cache.
   */
  void deleteCachedRegionLocation(final HRegionLocation location);

  /**
   * Find the location of the region of tableName that row
   * lives in, ignoring any value that might be in the cache.
   * @param tableName name of the table row is in
   * @param row row key you're trying to find the region of
   * @return HRegionLocation that describes where to find the region in
   *   question
   * @throws IOException if a remote or network exception occurs
   */
  HRegionLocation relocateRegion(final TableName tableName,
      final byte [] row) throws IOException;

  /**
   * Find the location of the region of tableName that row
   * lives in, ignoring any value that might be in the cache.
   * @param tableName name of the table row is in
   * @param row row key you're trying to find the region of
   * @param replicaId the replicaId of the region
   * @return RegionLocations that describe where to find the region in
   *   question
   * @throws IOException if a remote or network exception occurs
   */
  RegionLocations relocateRegion(final TableName tableName,
      final byte [] row, int replicaId) throws IOException;

  /**
   * Update the location cache. This is used internally by HBase, in most cases it should not be
   *  used by the client application.
   * @param tableName the table name
   * @param regionName the region name
   * @param rowkey the row
   * @param exception the exception if any. Can be null.
   * @param source the previous location
   */
  void updateCachedLocations(TableName tableName, byte[] regionName, byte[] rowkey,
                                    Object exception, ServerName source);

  /**
   * Gets the location of the region of regionName.
   * @param regionName name of the region to locate
   * @return HRegionLocation that describes where to find the region in
   *   question
   * @throws IOException if a remote or network exception occurs
   */
  HRegionLocation locateRegion(final byte[] regionName)
  throws IOException;

  /**
   * Gets the locations of all regions in the specified table, tableName.
   * @param tableName table to get regions of
   * @return list of region locations for all regions of table
   * @throws IOException if IO failure occurs
   */
  List<HRegionLocation> locateRegions(final TableName tableName) throws IOException;

  /**
   * Gets the locations of all regions in the specified table, tableName.
   * @param tableName table to get regions of
   * @param useCache Should we use the cache to retrieve the region information.
   * @param offlined True if we are to include offlined regions, false and we'll leave out offlined
   *          regions from returned list.
   * @return list of region locations for all regions of table
   * @throws IOException if IO failure occurs
   */
  List<HRegionLocation> locateRegions(final TableName tableName,
      final boolean useCache,
      final boolean offlined) throws IOException;

  /**
   *
   * @param tableName table to get regions of
   * @param row the row
   * @param useCache Should we use the cache to retrieve the region information.
   * @param retry do we retry
   * @return region locations for this row.
   * @throws IOException if IO failure occurs
   */
  RegionLocations locateRegion(TableName tableName,
                               byte[] row, boolean useCache, boolean retry) throws IOException;

 /**
  *
  * @param tableName table to get regions of
  * @param row the row
  * @param useCache Should we use the cache to retrieve the region information.
  * @param retry do we retry
  * @param replicaId the replicaId for the region
  * @return region locations for this row.
  * @throws IOException if IO failure occurs
  */
  RegionLocations locateRegion(TableName tableName, byte[] row, boolean useCache, boolean retry,
     int replicaId) throws IOException;

  /**
   * Returns a {@link MasterKeepAliveConnection} to the active master
   */
  MasterKeepAliveConnection getMaster() throws IOException;

  /**
   * Get the admin service for master.
   */
  AdminService.BlockingInterface getAdminForMaster() throws IOException;

  /**
   * Establishes a connection to the region server at the specified address.
   * @param serverName the region server to connect to
   * @return proxy for HRegionServer
   * @throws IOException if a remote or network exception occurs
   */
  AdminService.BlockingInterface getAdmin(final ServerName serverName) throws IOException;

  /**
   * Establishes a connection to the region server at the specified address, and returns
   * a region client protocol.
   *
   * @param serverName the region server to connect to
   * @return ClientProtocol proxy for RegionServer
   * @throws IOException if a remote or network exception occurs
   *
   */
  ClientService.BlockingInterface getClient(final ServerName serverName) throws IOException;

  /**
   * Find region location hosting passed row
   * @param tableName table name
   * @param row Row to find.
   * @param reload If true do not use cache, otherwise bypass.
   * @return Location of row.
   * @throws IOException if a remote or network exception occurs
   */
  HRegionLocation getRegionLocation(TableName tableName, byte[] row, boolean reload)
      throws IOException;

  /**
   * Clear any caches that pertain to server name sn.
   * @param sn A server name
   */
  void clearCaches(final ServerName sn);

  /**
   * @return Nonce generator for this ClusterConnection; may be null if disabled in configuration.
   */
  NonceGenerator getNonceGenerator();

  /**
   * @return Default AsyncProcess associated with this connection.
   */
  AsyncProcess getAsyncProcess();

  /**
   * Returns a new RpcRetryingCallerFactory from the given {@link Configuration}.
   * This RpcRetryingCallerFactory lets the users create {@link RpcRetryingCaller}s which can be
   * intercepted with the configured {@link RetryingCallerInterceptor}
   * @param conf configuration
   * @return RpcRetryingCallerFactory
   */
  RpcRetryingCallerFactory getNewRpcRetryingCallerFactory(Configuration conf);

  /**
   * @return Connection's RpcRetryingCallerFactory instance
   */
  RpcRetryingCallerFactory getRpcRetryingCallerFactory();

  /**
   * @return Connection's RpcControllerFactory instance
   */
  RpcControllerFactory getRpcControllerFactory();

  /**
   * @return a ConnectionConfiguration object holding parsed configuration values
   */
  ConnectionConfiguration getConnectionConfiguration();

  /**
   * @return the current statistics tracker associated with this connection
   */
  ServerStatisticTracker getStatisticsTracker();

  /**
   * @return the configured client backoff policy
   */
  ClientBackoffPolicy getBackoffPolicy();

  /**
   * @return the MetricsConnection instance associated with this connection.
   */
  MetricsConnection getConnectionMetrics();

  /**
   * @return true when this connection uses a {@link org.apache.hadoop.hbase.codec.Codec} and so
   *         supports cell blocks.
   */
  boolean hasCellBlockSupport();

  /**
   * @return the number of region servers that are currently running
   * @throws IOException if a remote or network exception occurs
   */
  int getCurrentNrHRS() throws IOException;
}


text:
// ========================================================================
// Copyright (c) 2009-2009 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
// You may elect to redistribute this code under either of these licenses.
// ========================================================================

package org.eclipse.jetty.start;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/* ------------------------------------------------------------ */
/**
 */
public class StartIniParser
{
    /**
     * If a start.ini is present in the CWD, then load it into the argument list.
     */
    public List<String> loadStartIni(String ini)
    {
        String jettyHome = System.getProperty("jetty.home");
        File startIniFile = ini == null?((jettyHome != null)?new File(jettyHome,"start.ini"):new File("start.ini")):new File(ini);
        if (!startIniFile.exists())
        {
            if (ini != null)
            {
                System.err.println("Warning - can't find ini file: " + ini);
            }
            // No start.ini found, skip load.
            return Collections.emptyList();
        }

        List<String> args = new ArrayList<String>();

        List<File> startIniFiles = new ArrayList<File>();
        startIniFiles.add(startIniFile);
        startIniFiles.addAll(getAdditionalStartIniFiles());

        for (File file : startIniFiles)
        {
            FileReader reader = null;
            BufferedReader buf = null;
            try
            {
                reader = new FileReader(file);
                buf = new BufferedReader(reader);

                String arg;
                while ((arg = buf.readLine()) != null)
                {
                    arg = arg.trim();
                    if (arg.length() == 0 || arg.startsWith("#"))
                    {
                        continue;
                    }
                    args.add(arg);
                }
            }
            catch (IOException e)
            {
                // usageExit(e,ERR_UNKNOWN);
            }
            finally
            {
                Main.close(buf);
                Main.close(reader);
            }
        }

        return args;
    }

    List<File> getAdditionalStartIniFiles()
    {
        String jettyHome = System.getProperty("jetty.home") == null?".":System.getProperty("jetty.home");
        File file = new File(jettyHome + "/start.d");
        if (file.exists())
            return Arrays.asList(file.listFiles(new iniExtensionFilter()));
        return Collections.emptyList();
    }

    private class iniExtensionFilter implements FilenameFilter
    {
        public boolean accept(File dir, String name)
        {
            return (name.endsWith(".ini"));
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
from tools.load import LoadMatrix
from sg import sg
lm=LoadMatrix()

traindna=lm.load_dna('../data/fm_train_dna.dat')
testdna=lm.load_dna('../data/fm_test_dna.dat')
parameter_list=[[traindna,testdna,10],
		[traindna,testdna,11]]

def kernel_localalignmentstring (fm_train_dna=traindna,fm_test_dna=testdna,
			    size_cache=10):

	sg('set_features', 'TRAIN', fm_train_dna, 'DNA')
	sg('set_features', 'TEST', fm_test_dna, 'DNA')
	sg('set_kernel', 'LOCALALIGNMENT', 'CHAR', size_cache)
	km=sg('get_kernel_matrix', 'TRAIN')
	km=sg('get_kernel_matrix', 'TEST')
	return km

if __name__=='__main__':
	print('LocalAlignmentString')
	kernel_localalignmentstring(*parameter_list[0])


text:
---
id: 587d8249367417b2b2512c41
title: Convertitore Metrico-Imperiale
challengeType: 4
forumTopicId: 301570
dashedName: metric-imperial-converter
---

# --description--

Costruisci un'app JavaScript full-stack che sia funzionalmente simile a questa: <https://metric-imperial-converter.freecodecamp.rocks/>. Lavorare su questo progetto ti porterà a scrivere il tuo codice utilizzando uno dei seguenti metodi:

- Clonare [questo repository GitHub](https://github.com/freeCodeCamp/boilerplate-project-metricimpconverter/) e completare il tuo progetto localmente.
- Usare [la nostra bozza di progetto su Replit](https://replit.com/github/freeCodeCamp/boilerplate-project-metricimpconverter) per completare il tuo progetto.
- Usare un costruttore di siti a tua scelta per completare il progetto. Assicurati di incorporare tutti i file del nostro repository GitHub.

Quando hai finito, assicurati che una demo funzionante del tuo progetto sia ospitata in qualche percorso pubblico. Quindi invia l'URL nel campo `Solution Link`. Facoltativamente, invia anche un link al codice sorgente del tuo progetto nel campo `GitHub Link`.

# --instructions--

- Completa la logica di conversione necessaria in `/controllers/convertHandler.js`
- Completa le rotte necessarie in `/routes/api.js`
- Copia il file `sample.env` su `.env` e imposta le variabili in modo appropriato
- Per eseguire i test togli i commenti dalla riga `NODE_ENV=test` nel tuo file `.env`
- Per eseguire i test nella console, utilizza il comando `npm run test`. Per aprire la console di Replit, premi Ctrl+Maiusc+P (Cmd se su un Mac) e digita "open shell"

Scrivi i seguenti test in `tests/1_unit-tests.js`:

- `convertHandler` dovrebbe leggere correttamente un numero intero inserito.
- `convertHandler` dovrebbe leggere correttamente un numero decimale inserito.
- `convertHandler` dovrebbe leggere correttamente una frazione inserita.
- `convertHandler` dovrebbe leggere correttamente un input frazionario con un decimale.
- `convertHandler` dovrebbe restituire correttamente un errore su una doppia frazione (cioè `3/2/3`).
- `convertHandler` dovrebbe essere correttamente predefinito con un input numerico di `1` quando non viene fornito alcun input numerico.
- `convertHandler` dovrebbe leggere correttamente ogni input valido.
- `convertHandler` dovrebbe restituire un errore per ogni input non valido.
- `convertHandler` dovrebbe restituire l'unità di ritorno corretta per ogni unità di input valida.
- `convertHandler` dovrebbe restituire correttamente l'unità di misura scritta per esteso per ogni unità di input valida.
- `convertHandler` dovrebbe convertire correttamente `gal` in `L`.
- `convertHandler` dovrebbe convertire correttamente `L` in `gal`.
- `convertHandler` dovrebbe convertire correttamente `mi` in `km`.
- `convertHandler` dovrebbe convertire correttamente `km` in `mi`.
- `convertHandler` dovrebbe convertire correttamente `lbs` in `kg`.
- `convertHandler` dovrebbe convertire correttamente `kg` in `lbs`.

Scrivi i seguenti test in `tests/2_functional-tests.js`:

- Converti un input valido come `10L`: richiesta `GET` a `/api/convert`.
- Converti un input non valido come `32g`: richiesta `GET` a `/api/convert`.
- Converti un input non valido come `3/7.2/4kg`: richiesta `GET` a `/api/convert`.
- Converti un input non valido come `3/7.2/4kilomegagram`: richiesta `GET` a `/api/convert`.
- Converti un input senza alcun numero come `kg`: richiesta `GET` a `/api/convert`.

# --hints--

È necessario fornire il proprio progetto, non l'URL di esempio.

```js
getUserInput => {
  assert(
    !/.*\/metric-imperial-converter\.freecodecamp\.rocks/.test(
      getUserInput('url')
    )
  );
};
```

È possibile ottenere (`GET`) `/api/convert` con un singolo parametro contenente un numero e un'unità validi e convertirlo. (Suggerimento: Dividi l'input cercando l'indice del primo carattere, che segnerà l'inizio dell'unità)

```js

```

Puoi convertire `'gal'` in `'L'` e viceversa. (1 gal in 3.78541 L)

```js
async getUserInput => {
  try {
    const data1 = await $.get(getUserInput('url') + '/api/convert?input=1gal');
    assert.equal(data1.returnNum, 3.78541);
    assert.equal(data1.returnUnit, 'L');
    const data2 = await $.get(getUserInput('url') + '/api/convert?input=10gal');
    assert.equal(data2.returnNum, 37.8541);
    assert.equal(data2.returnUnit, 'L');
    const data3 = await $.get(getUserInput('url') + '/api/convert?input=1l');
    assert.equal(data3.returnNum, 0.26417);
    assert.equal(data3.returnUnit, 'gal');
    const data4 = await $.get(getUserInput('url') + '/api/convert?input=10l');
    assert.equal(data4.returnNum, 2.64172);
    assert.equal(data4.returnUnit, 'gal');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Puoi convertire `'lbs'` in `'kg'` e viceversa. (1 lbs in 0,453592 kg)

```js
async getUserInput => {
  try {
    const data1 = await $.get(getUserInput('url') + '/api/convert?input=1lbs');
    assert.equal(data1.returnNum, 0.45359);
    assert.equal(data1.returnUnit, 'kg');
    const data2 = await $.get(getUserInput('url') + '/api/convert?input=10lbs');
    assert.equal(data2.returnNum, 4.53592);
    assert.equal(data2.returnUnit, 'kg');
    const data3 = await $.get(getUserInput('url') + '/api/convert?input=1kg');
    assert.equal(data3.returnNum, 2.20462);
    assert.equal(data3.returnUnit, 'lbs');
    const data4 = await $.get(getUserInput('url') + '/api/convert?input=10kg');
    assert.equal(data4.returnNum, 22.04624);
    assert.equal(data4.returnUnit, 'lbs');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Puoi convertire `'mi'` in `'km'` e viceversa. (1 mi in 1.60934 km)

```js
async getUserInput => {
  try {
    const data1 = await $.get(getUserInput('url') + '/api/convert?input=1mi');
    assert.equal(data1.returnNum, 1.60934);
    assert.equal(data1.returnUnit, 'km');
    const data2 = await $.get(getUserInput('url') + '/api/convert?input=10mi');
    assert.equal(data2.returnNum, 16.0934);
    assert.equal(data2.returnUnit, 'km');
    const data3 = await $.get(getUserInput('url') + '/api/convert?input=1km');
    assert.equal(data3.returnNum, 0.62137);
    assert.equal(data3.returnUnit, 'mi');
    const data4 = await $.get(getUserInput('url') + '/api/convert?input=10km');
    assert.equal(data4.returnNum, 6.21373);
    assert.equal(data4.returnUnit, 'mi');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Tutte le unità in entrata dovrebbero essere accettate sia in maiuscolo che in minuscolo, ma dovrebbero essere restituite in minuscolo sia per `initUnit` che `returnUnit`, ad eccezione del litro, che dovrebbe essere rappresentato come una `'L'` maiuscola.

```js
async getUserInput => {
  try {
    const data1 = await $.get(getUserInput('url') + '/api/convert?input=1gal');
    assert.equal(data1.initUnit, 'gal');
    assert.equal(data1.returnUnit, 'L');
    const data2 = await $.get(getUserInput('url') + '/api/convert?input=10L');
    assert.equal(data2.initUnit, 'L');
    assert.equal(data2.returnUnit, 'gal');
    const data3 = await $.get(getUserInput('url') + '/api/convert?input=1l');
    assert.equal(data3.initUnit, 'L');
    assert.equal(data3.returnUnit, 'gal');
    const data4 = await $.get(getUserInput('url') + '/api/convert?input=10KM');
    assert.equal(data4.initUnit, 'km');
    assert.equal(data4.returnUnit, 'mi');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Se l'unità di misura non è valida, sarà restituito `'invalid unit'`.

```js
async getUserInput => {
  try {
    const data = await $.get(getUserInput('url') + '/api/convert?input=1min');
    assert(data.error === 'invalid unit' || data === 'invalid unit');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Se il numero non è valido, sarà restituito `'invalid number'`.

```js
async getUserInput => {
  try {
    const data = await $.get(
      getUserInput('url') + '/api/convert?input=1//2gal'
    );
    assert(data.error === 'invalid number' || data === 'invalid number');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Se sia l'unità che il numero non sono validi, sarà restituito `'invalid number and unit'`.

```js
async getUserInput => {
  try {
    const data = await $.get(
      getUserInput('url') + '/api/convert?input=1//2min'
    );
    assert(
      data.error === 'invalid number and unit' ||
        data === 'invalid number and unit'
    );
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

È possibile utilizzare frazioni, decimali o entrambi nel parametro (es. 5, 1/2, 2.5/6), ma se non viene fornito nulla il valore predefinito sarà 1.

```js
async getUserInput => {
  try {
    const data1 = await $.get(getUserInput('url') + '/api/convert?input=mi');
    assert.approximately(data1.initNum, 1, 0.001);
    assert.approximately(data1.returnNum, 1.60934, 0.001);
    assert.equal(data1.returnUnit, 'km');
    const data2 = await $.get(getUserInput('url') + '/api/convert?input=1/5mi');
    assert.approximately(data2.initNum, 1 / 5, 0.1);
    assert.approximately(data2.returnNum, 0.32187, 0.001);
    assert.equal(data2.returnUnit, 'km');
    const data3 = await $.get(
      getUserInput('url') + '/api/convert?input=1.5/7km'
    );
    assert.approximately(data3.initNum, 1.5 / 7, 0.001);
    assert.approximately(data3.returnNum, 0.13315, 0.001);
    assert.equal(data3.returnUnit, 'mi');
    const data4 = await $.get(
      getUserInput('url') + '/api/convert?input=3/2.7km'
    );
    assert.approximately(data4.initNum, 3 / 2.7, 0.001);
    assert.approximately(data4.returnNum, 0.69041, 0.001);
    assert.equal(data4.returnUnit, 'mi');
  } catch (err) {
    throw new Error(err.responseText || err.message);
  }
};
```

Il tuo risultato consisterà in `initNum`, `initUnit`, `returnNum`, `returnUnit`, e `string` che indica le unità nel formato `'{initNum} {initUnitString} converts to {returnNum} {returnUnitString}'` con il risultato arrotondato a 5 decimali.

```js
async getUserInput => {
  try {
    const data = await $.get(getUserInput('url') + '/api/convert?input=2mi');
    assert.equal(data.initNum, 2);
    assert.equal(data.initUnit, 'mi');
    assert.approximately(data.returnNum, 3.21868, 0.001);
    assert.equal(data.returnUnit, 'km', 'returnUnit did not match');
    assert.equal(data.string, '2 miles converts to 3.21868 kilometers');
  } catch (xhr) {
    throw new Error(xhr.responseText || xhr.message);
  }
};
```

Tutti i 16 test funzionali richiesti sono completi e superati.

```js
async getUserInput => {
  try {
    const getTests = await $.get(getUserInput('url') + '/_api/get-tests');
    assert.isArray(getTests);
    const unitTests = getTests.filter(test => {
      return !!test.context.match(/Unit Tests/gi);
    });
    assert.isAtLeast(unitTests.length, 16, 'At least 16 tests passed');
    unitTests.forEach(test => {
      assert.equal(test.state, 'passed', 'Tests in Passed State');
      assert.isAtLeast(
        test.assertions.length,
        1,
        'At least one assertion per test'
      );
    });
  } catch (err) {
    throw new Error(err.responseText || err.message);
  }
};
```

Tutti i 5 test funzionali richiesti sono completi e superati.

```js
async getUserInput => {
  try {
    const getTests = await $.get(getUserInput('url') + '/_api/get-tests');
    assert.isArray(getTests);
    const functTests = getTests.filter(test => {
      return !!test.context.match(/Functional Tests/gi);
    });
    assert.isAtLeast(functTests.length, 5, 'At least 5 tests passed');
    functTests.forEach(test => {
      assert.equal(test.state, 'passed', 'Tests in Passed State');
      assert.isAtLeast(
        test.assertions.length,
        1,
        'At least one assertion per test'
      );
    });
  } catch (err) {
    throw new Error(err.responseText || err.message);
  }
};
```

# --solutions--

```js
/**
  Backend challenges don't need solutions,
  because they would need to be tested against a full working project.
  Please check our contributing guidelines to learn more.
*/
```


text:
Framework V3
============

A more comprehensible react-redux framework. *not isomorphic :D*

Install
-------

1. Edit package.json:
 * change "name"
 * change "description"

2. Download & install dependencies:
 `npm install`

3. Delete examples:
 - `/src/example/`
 - `/src/example2/`
 - __*/src/routes.js*__: `/* examples */ ... /* end examples */`
 - __*/src/reducer.js*__: `/* examples */ ... /* end examples */`

Develop
-------

1. Start a dev server:
 `npm start`

2. Load in browser:
 `http://localhost:3000`

3. Edit sources in __*/src*__

Production Build
----------------

1. Compile bundle.js (and other assets) to /public/static/:
 `npm run build`

2. Host the public/ directory (eg. drag it into netlify or `surge .`)

About the dependencies
----------------------

**Manage javascript dependencies with `import` and `export`**
```json
    "webpack": "^3.4.1",
    "webpack-dev-server": "^2.6.1",
```

**Write beautiful futuristic javascript**
```json
    "babel-core": "^6.25.0",
    "babel-eslint": "^7.2.3",
    "babel-loader": "^7.1.1",
    "babel-preset-es2015": "^6.24.1",
    "babel-preset-react": "^6.24.1",
    "babel-preset-stage-0": "^6.24.1",
    "babel-register": "^6.24.1",
```

**CSS and image dependencies in javascript code**
```json
    "file-loader": "^1.0.0",
    "url-loader": "^0.5.9",
    "style-loader": "^0.18.2",
    "css-loader": "^0.28.4",
    "postcss-loader": "^2.0.6",
    "extract-text-webpack-plugin": "^3.0.0",
```

**Forget about browser compatibility**
```json
    "autoprefixer": "^7.1.2",
    "normalize.css": "^7.0.0"
```

**Goodbye `XMLHTTPRequest`**
```json
    "isomorphic-fetch": "2.2.1",
```

**Use the Flux paradigm**
```json
    "redux": "^3.7.2",
    "redux-thunk": "^2.2.0",
    "reselect": "^3.0.1",
```

**Write reusable reactive web components**
```json
    "react": "^15.6.1",
    "react-dom": "^15.6.1",
    "react-helmet": "^5.1.3",
    "react-hot-loader": "^3.0.0-beta.7",
    "react-redux": "^5.0.5",
    "react-router": "^4.1.2",
    "react-router-dom": "^4.1.2",
```

**Catch compile time errors**
```json
    "eslint": "^4.3.0",
    "eslint-loader": "^1.9.0",
    "eslint-plugin-import": "^2.7.0",
    "eslint-plugin-react": "^7.1.0",
```

**Write tests**
```json
    "mocha": "^3.4.2",
    "mocha-eslint": "^4.1.0",
```

Tutorials
========

Create a new page at a new url
------------------------------

1. `cd src`
2. `cp -r example example2`

3. Change component name to Example2

 __*/src/example2/index.js*__
 ```javascript
 export default class Example2 extends Component
 ```

4. Give the component a URL and nest it in our App route

 __*/src/routes.js*__
 ```javascript
 ...
 import Example2 from './example2'

 <Route path="/" component={App}>
   ...
   <Route path="/example2" component={Example2}/>
 </Route>
 ```

Manage state with reducers and actions
--------------------------------------

__*/src/example2/actions.js*__

Create a click *action type* and *action creator*.
Action types must be unique strings.
Action creators must return either:
- an action `{type: ACTION_TYPE_CONSTANT, ...}`
- a function that eventually dispatches actions `(dispatch, getState) => {...}`

```javascript
export const CLICK = 'example2/CLICK'
export const click = () => ({ type: CLICK })
```

__*/src/example2/reducer.js*__

Create a state reducer that:
- is initially 0
- increments on CLICK actions and
- stays constant for all other actions

```javascript
import { CLICK } from './actions'
export default (state = 0, action) => (
  action.type == CLICK
    ? state + 1
    : state
)
```

__*/src/reducer.js*__

Add our reducer to the global reducer. Reducers can be composed to form a single state tree.

```javascript
import { combineReducers } from 'redux'
import numberOfClicks from './example2/reducer'

export default combineReducers({numberOfClicks})
```

Use the global state in your component
--------------------------------------

Assume the global state is like:
  `{numberOfClicks: 0}`
and you want it in your component as:
  `this.props.count`

__*/src/example2/index.js*__

```javascript
import { connect } from 'react-redux'
```

```javascript
class Example2 extends Component {...}
export default connect(
  state => ({
    count: state.numberOfClicks
  })
)(Example2)
```

Change the global state from your component
-------------------------------------------

__*/src/example2/index.js*__

Connect the component to the action

```javascript
import { click } from './actions'

...

export default connect(
  mapStateToProps,
  { click }
)(Example2)
```

Tie our component's onClick handler to our click action

```javascript
<div onClick={this.props.click}>
```


text:
class CEnvAmbientLight : public CSpatialEntity
{
	DECLARE_CLASS( CEnvAmbientLight, CSpatialEntity );

public:
	DECLARE_SERVERCLASS();
	DECLARE_DATADESC();

	virtual void Spawn( void );

	void InputSetColor(inputdata_t &inputdata);
	void SetColor( const Vector &vecColor );

private:
	color32	m_Color;

	CNetworkVector( m_vecColor );
};

#endif // _INCLUDED_ENV_AMBIENT_LIGHT_H


text:
layout: post
title:  "Galileu - Landing page"
date: 2015-03-15
excerpt: "Landing Page for a portuguese education center"
project: true
tag:
- landing page
- education
- Galileu
- Portugal
comments: true
---

![Galileu]({{ site.url }}/assets/img/projects/galileu/login.jpg){: .login-img }

 Landing page made for one course of a portuguese education center called Galileu.

## Preview

{% capture images %}
	{{ site.url }}/assets/img/projects/galileu/screen-0.jpg
	{{ site.url }}/assets/img/projects/galileu/screen-1.jpg
	{{ site.url }}/assets/img/projects/galileu/screen-2.jpg
{% endcapture %}
{% include gallery images=images caption="Screenshots of Galileu" cols=3 %}

You can find the landing page [here](http://cursos-redes-sistemas.galileu.pt/)


text:
<!DOCTYPE html>

<title>Canvas test: 2d.path.isPointInPath.nonfinite</title>

<link rel="stylesheet" href="/common/canvas-tests.css">

2d.path.isPointInPath.nonfinite

isPointInPath() returns false for non-finite arguments

Actual output:

<canvas id="c" class="output" width="100" height="50">
FAIL (fallback content)
</canvas>


text:
package org.auraframework.impl.root.parser.handler.design;

import java.util.Collections;
import java.util.Set;

import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;

import org.auraframework.def.design.DesignDef;
import org.auraframework.def.design.DesignItemsDef;
import org.auraframework.def.design.DesignLayoutAttributeDef;
import org.auraframework.def.design.DesignLayoutComponentDef;
import org.auraframework.impl.design.DesignItemsDefImpl;
import org.auraframework.impl.root.parser.handler.ContainerTagHandler;
import org.auraframework.impl.root.parser.handler.ParentedTagHandler;
import org.auraframework.impl.system.DefDescriptorImpl;
import org.auraframework.system.Source;
import org.auraframework.throwable.quickfix.QuickFixException;
import org.auraframework.util.AuraTextUtil;

public class DesignItemsDefHandler extends ParentedTagHandler<DesignItemsDef, DesignDef>{
    public final static String TAG = "design:layoutitems";
    private final static String ATTRIBUTE_NAME = "name";

    private DesignItemsDefImpl.Builder builder = new DesignItemsDefImpl.Builder();

    public DesignItemsDefHandler() {
        super();
    }

    public DesignItemsDefHandler(ContainerTagHandler<DesignDef> parentHandler, XMLStreamReader xmlReader, Source<?> source) {
        super(parentHandler, xmlReader, source);
        builder.setDescriptor(DefDescriptorImpl.getAssociateDescriptor(getParentDefDescriptor(), DesignItemsDef.class,
                TAG));
    }

    @Override
    protected void handleChildTag() throws XMLStreamException, QuickFixException {
        String tag = getTagName();
        if (DesignLayoutAttributeDefHandler.TAG.equalsIgnoreCase(tag)) {
            DesignLayoutAttributeDef item = new DesignLayoutAttributeDefHandler(getParentHandler(), xmlReader, source).getElement();
            builder.addAttribute(item);
        } else if(isInPrivilegedNamespace() && DesignLayoutComponentDefHandler.TAG.equalsIgnoreCase(tag)) {
            //Component injection is only allowed in privileged namespaces
            DesignLayoutComponentDef cmp = new DesignLayoutComponentDefHandler(getParentHandler(), xmlReader, source).getElement();
            builder.addComponent(cmp);
        } else {
            throw new XMLStreamException(String.format("<%s> can not contain tag %s", getHandledTag(), tag));
        }

    }

    @Override
    protected void readAttributes() throws QuickFixException {
        String name = getAttributeValue(ATTRIBUTE_NAME);
        if (name != null) {
            builder.setName(name);
        }
    }

    @Override
    protected void handleChildText() throws XMLStreamException, QuickFixException {
        String text = xmlReader.getText();
        if (!AuraTextUtil.isNullEmptyOrWhitespace(text)) {
            error("No literal text allowed in attribute design definition");
        }
    }

    @Override
    public Set<String> getAllowedAttributes() {
        return Collections.singleton(ATTRIBUTE_NAME);
    }

    @Override
    public String getHandledTag() {
        return TAG;
    }

    @Override
    protected DesignItemsDef createDefinition() throws QuickFixException {
        return builder.build();
    }
}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<name>jrobotx - Java Robot Exclusion Compliance Library</name>
	<packaging>jar</packaging>
	<url>https://github.com/sampov2/jrobotx</url>
	<groupId>com.github.sampov2</groupId>
	<licenses>
		<license>
			<name>The Apache Software License, Version 2.0</name>
			<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
			<distribution>repo</distribution>
		</license>
	</licenses>

	<parent>
		<groupId>spatineo</groupId>
		<artifactId>nuclear-pom-jdk6</artifactId>
		<version>0.19</version>
	</parent>

	<artifactId>jrobotx</artifactId>
	<version>0.7-SNAPSHOT</version>

	<developers>
		<developer>
			<name>Alan Krueger</name>
			<email>alan@trigonic.com</email>
			<timezone>-6</timezone>
		</developer>
		<developer>
			<name>Sampo Savolainen</name>
			<email>sampo.savolainen@spatineo.com</email>
			<timezone>2</timezone>
		</developer>
	</developers>

	<scm>
		<connection>scm:git:git@github.com:sampov2/jrobotx.git</connection>
		<developerConnection>scm:git:git@github.com:sampov2/jrobotx.git</developerConnection>
		<url>git@github.com:sampov2/jrobotx.git</url>
	  <tag>HEAD</tag>
  </scm>

	<dependencies>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.16</version>
		</dependency>
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>1.4</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.easymock</groupId>
			<artifactId>easymock</artifactId>
			<version>2.4</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.easymock</groupId>
			<artifactId>easymockclassextension</artifactId>
			<version>2.4</version>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<inherited>true</inherited>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-source-plugin</artifactId>
				<executions>
					<execution>
						<id>attach-sources</id>
						<goals>
							<goal>jar</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<inherited>true</inherited>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-javadoc-plugin</artifactId>
				<executions>
					<execution>
						<id>attach-javadocs</id>
						<goals>
							<goal>jar</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-deploy-plugin</artifactId>
				<configuration>
					<uniqueVersion>false</uniqueVersion>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>


text:
%% Nicholas Czarnek
% SSPACISS Laboratory, Duke University
% 7 August 2014
%
% getOnOffLevels.m
% The purpose of this function is to establish the energies that should be
% assigned to the on and off periods during the energy assignment phase.
%
% Inputs:
%   eventFeatures:    matrix of features all ordered as on then off or vice
%                     versa
%   bufferSize:       number of samples around the midpoint to ignore in
%                     the level calculation
%
% Outputs:
%   levels:           structure with
%                     - on    - assumed to be the max
%                     - off   - assumed to be the min

function levels = getOnOffLevels(eventFeatures,bufferSize,classLabel)

midPoint        = floor(size(eventFeatures,2)/2) + 1;

beforeFeatures  = eventFeatures(:,1:midPoint-1-bufferSize);
afterFeatures   = eventFeatures(:,midPoint+1+bufferSize:end);

beforeMean      = mean(beforeFeatures(:));
afterMean       = mean(afterFeatures(:));

levels.on       = max(beforeMean,afterMean);
levels.off      = min(beforeMean,afterMean);
levels.class    = classLabel;


text:
using System;
using Sharpex2D.Rendering;
using Sharpex2D.Surface;

namespace Sharpex2D
{
    [Developer("ThuCommix", "developer@sharpex2d.de")]
    [TestState(TestState.Tested)]
    public class Configurator : IConfigurator
    {
        /// <summary>
        /// Initializes a new Configurator class.
        /// </summary>
        /// <param name="gameInstance">The GameInstance.</param>
        /// <param name="renderTarget">The RenderTarget.</param>
        public Configurator(Game gameInstance, RenderTarget renderTarget)
            : this(60, new BackBuffer(640, 480), gameInstance, renderTarget)
        {
        }

        /// <summary>
        /// Initializes a new Configurator class.
        /// </summary>
        /// <param name="backbuffer">The BackBuffer.</param>
        /// <param name="gameInstance">The GameInstance.</param>
        /// <param name="renderTarget">The RenderTarget.</param>
        public Configurator(BackBuffer backbuffer, Game gameInstance, RenderTarget renderTarget)
            : this(60, backbuffer, gameInstance, renderTarget)
        {
        }

        /// <summary>
        /// Initializes a new Configurator class.
        /// </summary>
        /// <param name="targetFrameRate">The TargetFrameRate.</param>
        /// <param name="backbuffer">The BackBuffer.</param>
        /// <param name="gameInstance">The GameInstance.</param>
        /// <param name="renderTarget">The RenderTarget.</param>
        public Configurator(int targetFrameRate, BackBuffer backbuffer, Game gameInstance,
            RenderTarget renderTarget)
        {
            if (!renderTarget.IsValid)
            {
                throw new InvalidOperationException("RenderTarget is not valid.");
            }

            TargetFrameRate = targetFrameRate;
            BackBuffer = backbuffer;
            GameInstance = gameInstance;
            RenderTarget = renderTarget;
        }

        /// <summary>
        /// Gets or sets the BackBuffer.
        /// </summary>
        public BackBuffer BackBuffer { private set; get; }

        /// <summary>
        /// Gets or sets the TargetFrameRate.
        /// </summary>
        public int TargetFrameRate { private set; get; }

        /// <summary>
        /// Gets the Game.
        /// </summary>
        public Game GameInstance { private set; get; }

        /// <summary>
        /// Gets the TargetHandle.
        /// </summary>
        public RenderTarget RenderTarget { get; private set; }

        /// <summary>
        /// Gets the default initializer.
        /// </summary>
        /// <param name="gameInstance">The GameInstance.</param>
        /// <returns>SGLInitializer</returns>
        public static Configurator Default(Game gameInstance)
        {
            return new Configurator(gameInstance, RenderTarget.Default);
        }
    }
}


text:
[![Build](https://github.com/andygrunwald/FOM-LaTeX-Template/actions/workflows/Check.yml/badge.svg)](https://github.com/andygrunwald/FOM-LaTeX-Template/actions/workflows/Check.yml)

Eine [LaTeX](https://de.wikipedia.org/wiki/LaTeX)-Vorlage für den persönlichen Gebrauch für Haus-, Seminar-, Bachelor und Master-Arbeiten an der [FOM Hochschule für Oekonomie & Management](https://www.fom.de/).

Wie das **Ergebnis** aussieht, könnt ihr euch in der Datei [*thesis_main.pdf*](./thesis_main.pdf) ansehen.

Diese Vorlage hat weder einen Anspruch auf Richtigkeit, noch auf Vollständigkeit.
Verbesserungen sind jederzeit willkommen (siehe [Ich möchte mithelfen, diese Vorlage zu verbessern](#ich-möchte-mithelfen-diese-vorlage-zu-verbessern)).

---

## Inhaltsverzeichnis

1. [Für die eigene Arbeit nutzen](#für-die-eigene-arbeit-nutzen)
    1. [Klassischer Download](#klassischer-download)
    2. [Fork auf Github](#fork-auf-github)
1. [Vorlage personalisieren](#vorlage-personalisieren)
1. [Dokumentensprache](#dokumentensprache)
1. [TextCommands](#textcommands)
1. [Zitation](#zitation)
    1. [Chicago-Style in Fußnoten](#chicago-style-in-fußnoten)
    2. [IEEE-Style im Text](#ieee-style-im-text)
1. [Inhaltsverzeichnis Latex](#inhaltsverzeichnis-latex)
1. [Literaturverzeichnis](#literaturverzeichnis)
1. [Sperrvermerk](#sperrvermerk)
1. [Quellcode einbinden](#quellcode-einbinden)
1. [Schriftarten](#schriftarten)
1. [PlantUML](#plantuml)
1. [LaTeX zu PDF kompilieren](#latex-zu-pdf-kompilieren)
    1. [Docker unter Linux / macOS / Windows](#docker-unter-linux--macos--windows)
    2. [LaTeX-Pakete](#latex-pakete)
    3. [Image selbst bauen](#image-selbst-bauen)
    4. [Fehlerbehandlung](#fehlerbehandlung)
1. [LaTeX mit Windows Subsystem for Linux kompilieren](#latex-mit-windows-subsystem-for-linux-kompilieren)
1. [IDE zur Bearbeitung nutzen](#ide-zur-bearbeitung-nutzen)
    1. [Texpad](#texpad)
    2. [Visual Studio Code](#visual-studio-code)
1. [Wörter zählen](#wörter-zählen)
    1. [TeXcount](#texcount)
    2. [Unix / macOS Script](#unix--macos-script)
1. [Ich habe eine Frage oder ein Problem](#ich-habe-eine-frage-oder-ein-problem)
1. [Ich möchte mithelfen, diese Vorlage zu verbessern](#ich-möchte-mithelfen-diese-vorlage-zu-verbessern)
1. [Disclaimer](#disclaimer)
1. [Lizenz](#lizenz)

## Für die eigene Arbeit nutzen

Aufgrund der gewählten [Lizenz](./LICENSE) [MIT Lizenz](https://en.wikipedia.org/wiki/MIT_License), darfst du diese Vorlage für den persönlichen oder kommerziellen Gebrauch nutzen und abändern.
Um dies zu tun, gibt es mehrere Möglichkeiten, die wir nachfolgend kurz vorstellen.

**Generell gilt**:
Dieses Dokument beschreibt eine ganze Menge Details, die dir beim Erstellen und bearbeiten des Dokuments hilfreich sein könnten.
Leider wird es unmöglich sein, jede Frage abzudecken.
Solltest du uns kontaktieren wollen, um eine Frage zu stellen, ein Problem mit zuteilen oder um einfach nur mal Danke sagen zu wollen, eröffne doch ein [neues Issue](https://github.com/andygrunwald/FOM-LaTeX-Template/issues/new) in diesem Projekt.

### Klassischer Download

Über den *Clone or Download* Button in der oberen rechten Ecke kannst du dir diese Vorlage herunterladen ([ZIP-Archiv](https://github.com/andygrunwald/FOM-LaTeX-Template/archive/master.zip)).
Danach kannst du, wie gewohnt, die Dateien lokal bearbeiten, deine Arbeit schreiben, Drucken und abgeben.

### Fork auf Github

Die bessere Alternative zum klassischen Download ist ein *Fork* auf Github.
Wie das im Detail funktioniert beschreibt der Artikel [Fork A Repo](https://help.github.com/articles/fork-a-repo/).
Das Ganze hat primär zwei Vorteile:

* Du hast automatisch ein Backup deiner Arbeit auf Github
* Andere Personen / Studenten können sich deine Arbeit ansehen, diese verbessern, diese weiter verwenden (und ggf. Zeit sparen) oder daraus lernen (bedenke, all diese Vorteile hast du auch durch dieses Projekt)
* Wenn du es nicht mehr öffentlich zur Verfügung stellen kannst, kannst du das Projekt als *privat* markieren oder löschen

## Vorlage personalisieren

Wenn du diese Vorlage nutzt, ist der erste Einstiegspunkt die Datei [`skripte/meta.tex`](./skripte/meta.tex).
In der Datei haben wir einige Variablen hinterlegt, die im Dokument (u. a. auf dem Deckblatt) genutzt werden.

Ersetze die Muster-Werte durch deine persönlichen Angaben und diese werden automatisch im Dokument verwendet.

## Dokumentensprache

Die Vorlage ist sowohl auf Deutsch, als auch auf Englisch umgesetzt. Dadurch wird das Titelblatt, Verzeichnisüberschriften und auch der Inhalt des Literaturverzeichnisses auf die englische Sprache umgestellt.
Um die Datei auf Englisch zu kompilieren, muss mit docker-compose folgender Befehl umgesetzt werden:
```
docker-compose run --service-ports fom ./compile.sh en
```
Ohne Docker muss die Datei mit der compile.sh folgendermaßen aufgerufen werden:
```
./compile.sh en
```
Für die Batch-Datei ist das Kompilieren auf Englisch über folgenden Workaround möglich.
1. Suche in der thesis_main.tex nach der Codezeile `%\def\FOMEN{}`
2. Entkommentiere diese Codezeile, indem du das Prozentzeichen entfernst
3. Kompiliere neu

Anmerkung: Der beschriebene Workaround funktioniert auch, wenn du Overleaf oder einen anderen TEX-Editor verwendest und die compile.bat nicht benötigst.

Nach dem kompilieren findet sich das Ergebnis in der Datei [`thesis_main.pdf`](./thesis_main.pdf). Die [`thesis_englisch.pdf`](./thesis_englisch.pdf) ist nur dazu da auf Github die Möglichkeit aufzuzeigen.

## TextCommands

Das Arbeiten mit Commands innerhalb des Textes kann eine schöne Möglichkeit darstellen um:
- Wörter oder Abkürzungen, welche häufig falsch geschrieben werden, einmalig zu definieren
- bestimmte Wörter die z. B. einfach zu lang sind durch ein Kürzel schneller schreiben zu können
- Wörter oder Abkürzungen die häufig verwendet werden nie an der falschen Stelle zu trenen

In meinen Arbeiten haben ich gemerkt, dass es sinnvoll ist verschiedene standard Abkürzungen zu verwenden und diese nur einmalig zu definieren. Beispielsweise habe ich die Abkürzung von "zum Beispiel" --> "z. B." immer ohne Leerzeichen geschrieben. Allerdings ist die Schreibweise mit Leerzeichen [wesentlich korrekter](https://de.wiktionary.org/wiki/z._B.#:~:text=Anmerkung%3A,z.B.). Einmal richtig definiert, lässt sich die Abkürzung "z. B." im Text-File einfach durch folgenden Code aufrufen:
```
\zb
```
Man sparrt sich sogar 2 Tastaturanschläge ;-)

Auf der Seite skripte\textcommands.tex befinden sich zwei Bereiche:
- common textCommands
- project individual textCommands

Hier könnt ihr die verschiedenen Commands definieren und dann sind sie auch zentral an einer Stelle verfügbar und pflegbar.

TextCommands können bei Bedarf auch zweisprachig gepflegt werden:
```
\newcommand{\vglf}{\langde{Vgl.}\langen{compare}}
```

## Zitation
Es gibt viele Zitationsstile, deshalb schaut ihr am besten in den für euch gültigen Leitfaden und sprecht dann die präferierte/vorgegebene Zitationsweise mit eurem Dozenten ab.

### Chicago-Style in Fußnoten
**Achtung, nicht für Arbeiten in der Wirtschaftspsychologie**

Das Standard-Format kann mit `\footcite[Vgl. ][Seite 1]{Balzert.2008}` genutzt werden und gibt Folgendes aus:

```
Vgl. Balzert et al. (2008), Seite 1.
```

Es besteht auch die Möglichkeit, den Vornamen des Autors mit auszugeben.
Dazu kann der Custom-Befehl `\fullfootcite[Vgl. ][Seite 1]{Balzert.2008}` genutzt werden, der folgendes Resultat liefert:

```
Vgl. Balzert, Helmut et al. (2008), Seite 1.
```

Wird die englische Version genutzt, muss "Vgl." durch "compare" und "S." durch "p." ersetzt werden.
Beim verwenden von [Textcommands](#textcommands) müssen "Vgl." und "S." nicht manuell geändert werden. Dies wird automatisch erledigt.
Beispiel für die Verwendung von Textcommands (der Output sieht wie oben aus):
```
\footcite[\vglf][\pagef 1]{Balzert.2008}
```

### IEEE-Style im Text
**Achtung, nur im Hochschulbereich IT-Management**

Der IEEE Zitationsstil wird hauptsächlich in technischen Studiengängen verwendet und ist ein sehr einfacher Zitationsstil, da hier nicht auf Dinge wie z.B. "vgl."/"ebd." geachtet werden muss. Ein direktes Zitat steht in Anführungszeichen. Wird ohne Anführungszeichen zitiert weiß man, dass es ein indirektes Zitat ist ("vgl." kann dann weg gelassen werden). Normalerweise müssten auch keine Seitenzahlen angegeben werden, jedoch steht im aktuellen Leitfaden des Hochschulbereichs IT-Management, dass bei jeglicher Zitationsweise die Seitenzahl anzugeben ist, deshalb auch bei IEEE.
Um IEEE zu nutzen, müssen die Optionen des package BibLaTeX (`\usepackage[options]{biblatex}`) in der `thesis_main.tex` angepasst werden:
```
\usepackage[
backend=biber,
style=ieee,
maxcitenames=3,	% mindestens 3 Namen ausgeben bevor et. al. kommt
maxbibnames=999,
date=iso,
seconds=true, %werden nicht verwendet, so werden aber Warnungen unterdrückt.
urldate=iso,
dashed=false,
autocite=inline,
useprefix=true, % 'von' im Namen beachten (beim Anzeigen)
mincrossrefs = 1
]{biblatex}%iso dateformat für YYYY-MM-DD
```
Des Weiteren müssen die Modifikationen für BibLaTeX auskommentiert werden:
```
%\input{skripte/modsBiblatex2018}
```
Nach dem Auskommentieren der Modifikationen für das Literaturverzeichnis stimmt es leider nicht mehr zu 100% mit den Vorgaben überein, wobei der Leitfaden hier auch sehr vage formuliert ist. Am besten mit dem Dozenten sprechen, ob das BibLaTeX-Format passt.

Durch das Auskommentieren der BibLaTeX Modifikationen müssen im Anschluss folgende Zeilen hinzugefügt werden:
```
%% et al. anstatt u. a. bei mehr als drei Autoren.
\DefineBibliographyStrings{ngerman}{
	andothers = {{et\,al\adddot}},
}
\DefineBibliographyStrings{english}{
	andothers = {{et\,al\adddot}},
}
```

Im Text kann anschließend mit `\cite[S.~99]{Kornmeier2018}` oder `\cite[S.~99-102]{Kornmeier2018}` oder `\cite{Kornmeier2018}` zitiert werden:
```
Im Text kann anschließend mit [1, S. 99] oder [1, S. 99-102] oder [1] zitiert werden.
```

## Inhaltsverzeichnis Latex

**Ebene des ausgegebenen Inhaltsverzeichnis einstellen**

Bis zu welcher Ebene das Inhaltsverzeichnis aufgelistet wird, kann über tocdepth Parameter eingestellt werden
```latex
\setcounter{tocdepth}{4}
```

**Tabellen- und Abbildungsverzeichnis im Inhaltsverzeichnis**

Die Anzeige des Tabbellen- und des Abbildungsverzeichnis lässt sich gleich am Anfang in der \documentclass einstellen.

**Glossar im Inhaltsverzeichnis**

Folgenden Eintrag auskommentieren, damit das Glossar nicht im Inhaltsverzeichnis angezeigt wird
```latex
\glstoctrue
```

**Symbolverzeichnis**

Damit das Symbolverzeichnis nicht mehr angezeigt wird, folgendes auskommentieren
```latex
 \addcontentsline{toc}{section}{Symbolverzeichnis}
```

**Abkürzungsverzeichnis**

Damit das Symbolverzeichnis nicht mehr angezeigt wird, folgendes auskommentieren
```latex
\addcontentsline{toc}{section}{Abkürzungsverzeichnis}
```

## Literaturverzeichnis

Einige Professoren bevorzugen ein sortiertes (Webseite, Buch, Artikel...) Literaturverzeichnis.
Dies kann mit folgender Änderung im Quellcode ([*thesis_main.tex*](./thesis_main.tex)) erreicht werden:

Zunächst diese Zeile auskommentieren:

```latex
%\printbibliography
```

Und die folgenden Zeilen einkommentieren und ggf. anpassen.

```latex
\printbibheading
\printbibliography[type=article,heading=subbibliography,title={Artikel}]
\printbibliography[type=book,heading=subbibliography,title={Bücher}]
\printbibliography[type=online,heading=subbibliography,title={Webseiten}]
```

## Sperrvermerk

Sollte ein Sperrvermerk für die Arbeit notwendig sein, so kann dieser durch Einkommentieren der folgenden Zeile aktiviert werden:

```latex
\input{kapitel/anhang/sperrvermerk}
```

Die Angaben zu Titel der Arbeit und Name der Firma werden dabei aus den Metadaten entnommen.

## Quellcode einbinden

Um euren Quellcode einzubinden, wurde bereits das Paket *listings* in der Datei [*thesis_main.tex*](./thesis_main.tex) eingebunden.
Dieses wird dort auch mit den Farben für Kommentare, Strings, etc. konfiguriert.
Folgendermaßen könnt ihr Quellcode einbauen:

```latex
\lstinputlisting[language=JavaScript]{./Quellcode/Dateiname.js}
```

Für [Javascript](https://de.wikipedia.org/wiki/JavaScript) wurde eine eigene Definition erstellt und eingebaut.
Für eine genauere Beschreibung aller im Standard verfügbaren Sprachen empfehlen wir folgenden Artikel: [LaTeX/Source Code Listings @ Wikibooks](http://en.wikibooks.org/wiki/LaTeX/Source_Code_Listings).

## Schriftarten

Die voreingestellte Schriftart enthält Serifen. Mit den folgenden Zeilen kann in der Datei [*thesis_main.tex*](./thesis_main.tex) die Nutzung der Schriftart Helvet erzwungen werden.

```latex
% Überschreibe die default Schriftart mit helvet
\usepackage[scaled]{helvet}
\renewcommand\familydefault{\sfdefault}
```

## PlantUML
PlantUML ist ein Open-Source-Tool, mit dem UML-Diagramme aus einfacher Textsprache erstellt werden können.

Um PlantUml benutzen zu können, müssen folgende Voraussetzungen erfüllt sein:

* Das Prozentzeichen muss vor der Zeile `\usepackage{plantuml}` in der `thesis_main.tex` entfernt werden
* Der PlantUML Code muss von `\begin{plantuml}` `\end{plantuml}` umhüllt werden
* Die `plantuml.jar` muss vorhanden sein, Download unter [PlantUML](https://sourceforge.net/projects/plantuml/files/plantuml.jar/download)
* Kopiere die `plantuml.jar` zu einem lokalen Ordner (z.B., `mkdir -p ~/bin/plantuml && cp ~/Downloads/plantuml.jar ~/bin/plantuml`)
* Installiere Graphviz (PlantUML ist davon abhängig).

Folgendes muss in der `~/.bashrc` oder `zshconfig` sein:

```
export JAVA_HOME='/Library/Java/JavaVirtualMachines/jdk1.8.0_102.jdk/Contents/Home'
export PLANTUML_JAR='$HOME/bin/plantuml/plantuml.jar'
export GRAPHVIZ_DOT='/usr/local/bin/dot'
```

## LaTeX zu PDF kompilieren

Wir empfehlen das Dokument mit Docker (siehe unten) zu kompilieren.

Alternativ kann auch über die Ausführung der Skripte kompiliert werden, dafür müssen aber die unten beschriebenen [LaTeX-Pakete](#latex-pakete) installiert sein.
Unter **Windows** muss dafür die beiliegende `compile.bat` ausführen.
Benutzer von **macOS** und **Linux** verwenden bitte die ```compile.sh```.

Wenn das Kompilieren nicht ohne Fehler möglich ist, kontrolliert bitte ganz genau eure LaTeX-Versionen oder nutzt Docker.

### Docker unter Linux / macOS / Windows

Mit Docker wird das Dokument direkt in einem isolierten Container kompiliert.
In diesem Container sind alle Vorraussetzungen mit der richtigen Software und den richtigen Versionen gegeben.

Voraussetzung ist eine installierte [Docker engine](https://docs.docker.com/engine/installation/).

Um die **PDF-Datei ohne die Installation der LaTeX-Pakete zu kompilieren, muss folgender Befehl in eurem Projekt-Ordner** ( da wo die compile.sh bzw compile.bat liegt) ausgeführt werden:

```
docker-compose up
```

Den Befehl lasst ihr einfach über eure Kommandozeile bzw. PowerShell laufen (in Windows cmd.exe bzw. powershell.exe, beim Mac ist es das Terminal). Zum Projektordner könnt ihr kommen, indem ihr über den cd Befehl dorthin navigiert oder im Windows-Explorer in diesen Ordner wechselt und dann bei gedrückter Shift-Taste die rechte Maus-Taste klickt. Dort müsst ihr dann im Menü den Eintrag: "Öffne Kommandozeile hier" auswählen.

Falls es hier zu Problemen kommt, wenn ein gecachtes Image verwendet wird, können die folgenden Befehle ausgeführt werden:

```
docker-compose build --no-cache
docker-compose up
```

Wird Docker unter Windows 10 verwendet, muss der Daemon wie folgt konfiguriert werden:

![Docker Konfiguration unter Windows 10](https://cloud.githubusercontent.com/assets/6319666/17108377/7c3aef54-5293-11e6-95e3-bd99f42820f0.png)

Die benötigten Pakete befinden sich in dem Docker-Image, welches auf [Docker Hub unter andygrunwald/fom-latex-template](https://hub.docker.com/r/andygrunwald/fom-latex-template/) zur Verfügung steht.
Es wird bei der Ausführung automatisch heruntergeladen.

### LaTeX-Pakete

Für das kompilieren ohne Docker ist LaTeX Grundvoraussetzung.
Wenn Du _[MikTex](http://miktex.org/)_ oder _[MacTex](http://tug.org/mactex/)_ verwendest, dann brauchst Du keine weiteren LaTeX-Pakete installieren.

Weiterhin wird _[Biblatex](http://www.ctan.org/pkg/biblatex)_ und _Biber_ (>= Version 1.8) für das Literaturverzeichnisses benötigt.

### Fehlerbehandlung

Falls unter Windows der folgende Fehler auftritt, checkt `git` die Dateien mit Windows Line Endings aus. Dies verursacht im Ubuntu Container einen Fehler.

```
  env: bash\r: No such file or directory
```

Mit dem folgenden Befehl kann man `git` dazu zwingen alle Dateien mit UNIX Zeilenendungen zu laden (siehe [stackoverflow](https://stackoverflow.com/questions/29045140/env-bash-r-no-such-file-or-directory)):

```
git config --global core.autocrlf true
```

#### Image selbst bauen

Wenn Du das Docker Image selbst bauen möchtest, kannst Du es mit dem nachfolgenden Befehl tun:

```
docker build -t andygrunwald/fom-latex-template .
```

## LaTeX mit Windows Subsystem for Linux kompilieren
Eine mögliche Alternative zu Docker:

1. WSL und Distribution installieren und konfigurieren (siehe [Microsoft Docs](https://docs.microsoft.com/en-US/windows/wsl/install-win10))
1. Fork des Repositories erzeugen (siehe oben) und Dein Repository klonen (siehe [Github](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository))
1. TexLive und benötigte Pakete installieren
```
sudo apt-get install texlive texlive-lang-german texlive-latex-extra texlive-bibtex-extra texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended texlive-lang-german texlive-luatex biber xz-utils
```
4. Installation überprüfen, durch Erzeugen der PDF-Datei.
```
./compile.sh
```
5. (optional) Visual Studio Code mit Extension "Remote - WSL" benutzen (siehe [Microsoft VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl&WT.mc_id=-blog-scottha))

## IDE zur Bearbeitung nutzen

Prinzipiell reicht ein normaler Text-Editor zur Bearbeitung aus.
Jedoch kannst du zum Schreiben der Arbeit auch ein IDE verwenden.
Hierzu gibt es nachfolgend einige Software:

- [TeXstudio](http://texstudio.sourceforge.net/) (Windows, macOS, Linux)
- [Texpad](https://www.texpadapp.com/) (macOS, iOS)
- [Visual Studio Code](https://code.visualstudio.com/) (macOS, iOS, Linux)

### Texpad

Für die Nutzung von Texpad unter macOS müssen einige Einstellungen beachtet werden.
Standardmäßig ist _biber_ nicht aktiviert.
Dies führt dazu, dass das Literaturverzeichnis einfach "verschwindet", wenn man mit Texpad kompliliert.
Daher musst Du unter _Preferences_ > _Typesettings_ > _Bibliography Compilation_ als Engine _biber_ auswählen.

### Visual Studio Code

Wer eine etwas moderne IDE benutzen möchte, kann auch Visual Studio Code verwenden. Folgende Extension ist notwendig:

[Latex Workshop](https://marketplace.visualstudio.com/items?itemName=James-Yu.latex-workshop)

Mit Hilfe der Extension kann das Projekt kompiliert und als Vorschau angesehen werden. In der ```settings.json``` sind die Einstellungen der ```compile.sh``` für Latex Workshop hinterlegt.

Zusätzlich kann die Extension [LTeX](https://marketplace.visualstudio.com/items?itemName=valentjn.vscode-ltex) hilfreich sein, die eine **offline Grammatik- und Rechtschreibprüfung** für LaTeX-Dokumente bietet.

## Overleaf zur Bearbeitung nutzen

Anstatt dir einen TEX-Editor und alle weiteren Pakete selber zu installieren und wie oben beschrieben zu kompilieren etc. kannst du auch Online-Tools wie Overleaf (https://www.overleaf.com/) verwenden. Beides hat seine Vor- und Nachteile auf die hier nicht näher eingegangen wird.

Zum Einbinden dieser Vorlage in Overleaf gibt es zwei Möglichkeiten:
1. Der [klassische Download](#klassischer-download) wonach du das ZIP-File einfach bei Overleaf wieder hochlädst.
2. Du kannst deinen [Fork von Github](#fork-auf-github) in Overleaf einbinden.

## Wörter zählen

Gerade bei der Verwendung eines Texteditors ist das Zählen der Wörter unter umständen eine mühselige Aufgabe. Mit den folgenden Vorschlägen kann man die Wörter der Arbeit zählen:

### TeXcount

Über die Seite [TeXcount](https://app.uio.no/ifi/texcount/online.php) können Latex Dateien hochgeladen und gezählt werden.

### Unix / macOS Script

Unter Unix und macOS kann das mitgelieferte Script helfen die Wörter zu zählen. Dafür muss nur [detex](https://github.com/pkubowicz/opendetex) installiert werden. Unter macOS kann `detex` mittels [homebrew](https://brew.sh/index_de) über den Befehl `brew install opendetex` installiert werden.

Das Skript wird einfach über `sh ./countwords.sh` gestartet.

## Ich habe eine Frage oder ein Problem

Ab und zu kommt es vor, dass es nicht klappt wie beschrieben oder man eine Frage hat.
Ich würde euch bitten mir nicht persönlich eine E-Mail zu schreiben, sondern lieber ein [neues Issue](https://github.com/andygrunwald/FOM-LaTeX-Template/issues/new) in diesem Projekt eröffnet.
Dies hat folgende Vorteile:

* andere Personen können zur Lösung beitragen (weil sie diese ggf. auch hatten)
* wir haben eine Dokumentation an vorhandenen und gelösten Fehlern / Fragen
* gelöste / wiederkehrende Probleme müssen nicht erneut beantwortet werden

## Ich möchte mithelfen, diese Vorlage zu verbessern

Verbesserungen an dieser Vorlage sind stets erwünscht und willkommen.
Github (diese Plattform) selbst ist dafür gemacht, um zusammen an Open Source Projekten zu arbeiten.
Deswegen werden Änderungen über [Pull Requests](https://github.com/andygrunwald/FOM-LaTeX-Template/pulls) sehr gerne entgegen genommen.

Wenn du das erste mal mit [Git](https://git-scm.com/), [Github](https://github.com/) und Pull Requests arbeitest, können dir folgende zwei Artikel weiter helfen:

* [Using pull requests](https://help.github.com/articles/using-pull-requests/)
* [Creating a pull request](https://help.github.com/articles/creating-a-pull-request/)

## Disclaimer

Die Nutzung des Projektes ist auf eigene Gefahr und es kann keine Vollständigkeit gewährleistet werden.
Bitte überprüfe das Ergebnis erneut anhand der entsprechenden Leitfäden deines Studiengangs.
Einzelne Standorte und Professoren stellen abgeänderte Leitfäden bereit.

## Lizenz

Dieses Projekt ist unter den Bedingungen der [MIT Lizenz](http://en.wikipedia.org/wiki/MIT_License) öffentlich verfügbar.


text:
<resources>
    <string name="app_name">Buzzer Game</string>

    <string name="hello_world">Hello world!</string>
    <string name="action_settings">Settings</string>
    <string name="button_label">2 Player</string>
    <string name="button_label3">3 Player</string>
    <string name="title_activity_single_user_mode">Single Player</string>
    <string name="title_activity_stats">Stats</string>
    <string name="title_activity_multi_player_mode">MultiPlayerMode</string>
    <string name="title_activity_two_player_mode">TwoPlayerMode</string>
    <string name="title_activity_three_player_mode">ThreePlayerMode</string>
    <string name="title_activity_four_player_mode">Four Player Mode</string>
    <string name="title_activity_single_player_dialog">SinglePlayerDialog</string>
    <string name="title_activity_single_dialog">SingleDialog</string>
</resources>


text:
package uk.co.ordnancesurvey.gpx.extensions;

import org.alternativevision.gpx.beans.GPX;
import org.alternativevision.gpx.beans.Route;
import org.alternativevision.gpx.beans.Track;
import org.alternativevision.gpx.beans.Waypoint;
import org.alternativevision.gpx.extensions.IExtensionParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

public class RoutePointAzimuthParser implements IExtensionParser {

	private static final Logger LOG = LoggerFactory
			.getLogger(RoutePointAzimuthParser.class);

	public RoutePointAzimuthParser() {
		// TODO Auto-generated constructor stub
	}

	public static final String MYID = ExtensionConstants.AZIMUTH;

	@Override
	public String getId() {
		return MYID;
	}

	@Override
	public Object parseWaypointExtension(Node node) {
		String value = "";
		for (int idx = 0; idx < node.getChildNodes().getLength(); idx++) {
			Node currentNode = node.getChildNodes().item(idx);
			LOG.debug("Node Type is " + currentNode.getNodeType() + " And node name is" + currentNode.getNodeName() + " And node value is " + currentNode.getTextContent());
			if ("gh:azimuth".equals(currentNode.getNodeName())) {
				value = currentNode.getTextContent();
				break;
			}
		}
		return value;
	}

	@Override
	public Object parseTrackExtension(Node node) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Object parseGPXExtension(Node node) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Object parseRouteExtension(Node node) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void writeGPXExtensionData(Node node, GPX wpt, Document doc) {
		// TODO Auto-generated method stub
	}

	@Override
	public void writeWaypointExtensionData(Node node, Waypoint wpt, Document doc) {
		// TODO Auto-generated method stub
	}

	@Override
	public void writeTrackExtensionData(Node node, Track wpt, Document doc) {
		// TODO Auto-generated method stub
	}

	@Override
	public void writeRouteExtensionData(Node node, Route wpt, Document doc) {
		// TODO Auto-generated method stub
	}

}


text:
package jp.yokomark.lgtm.app.history.ui.helper.options;

import android.util.Log;

import jp.yokomark.lgtm.app.history.ui.ComposeHistoryActivity;
import jp.yokomark.lgtm.misc.ui.helper.OptionsMenuHandler;

/**
 * @author yokomakukeishin
 * @version 1.0.0
 * @since 1.0.0
 */
public class UnknownMenuHandler implements OptionsMenuHandler<ComposeHistoryActivity> {
    public static final String TAG = UnknownMenuHandler.class.getSimpleName();

    @Override
    public boolean handle(ComposeHistoryActivity activity) {
        Log.e(TAG, "unknown menu has been selected.");
        return false;
    }
}


text:
Browserify script for client-side navigation and pub-pkg-editor preview rendering (uses jQuery).

### Installation

- This module is included as a dependency of `pub-pkg-editor`
- The module simply exports a fully qualified path to `pub-preview.js`which can then can be served as a browserScript through `pub-config.js`. E.g

```js
{ path: require('pub-preview'),  route: '/pub/js' }
```

The script can be injected into any pub-server generated HTML with

```js
var $script = $('<script src="/pub/js/pub-preview.js"></script>');
$('body').append($script);
```

#### Note

- the script assumes a global instance of `pub-generator` in `window.generator`

- client-side navigation is performed by the [page](https://github.com/visionmedia/page.js) module which depends on history.pushstate support in the browser.

### How it works

- `pub-preview.js` loads the `page` module which takes over click events and manages browser history. Any internal link to another page will trigger a generator `nav` event.

- `jqueryview.js` listens for generator 'nav', 'loaded', and 'updatedText' events and emits 'update-view' when content in the DOM has been replaced with newly generated HTML. This allows the same mechanism to be used for offline navigation as well as source changes in an editor.

### html template guidelines

When content is modified an attempt is made to determine whether the edit affects the layout, the page or fragment container, or just the  html rendered from markdown

In order to maximize responsiveness, the editor relies on data attributes on html tags to replace just the affected HTML

- `data-render-layout` = name of layout template - wrapper auto-inserted by {{{renderLayout}}})
- `data-render-page` = name of page template - wrapper div auto-inserted by  {{{renderPage}}}
- `data-render-html` = _href of fragment or page - wrapper div auto-inserted by {{{html}}}


text:
<?xml version='1.0'?>
<root xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
       xsi:noNamespaceSchemaLocation="string.xsd" >
  <complexTest>
  <!-- value=sdflhksdgh;let vm'peoaivm'weiv' -->
    <comp_foo>sdflhksdgh;let vm'peoaivm'weiv'</comp_foo>
  </complexTest>

  <simpleTest>sdflhksdgh;let vm'peoaivm'weiv'</simpleTest>
</root>


text:
package com.motodb.view;

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

import com.motodb.controller.BikeManager;
import com.motodb.controller.BikeManagerImpl;
import com.motodb.controller.ChampionshipManager;
import com.motodb.controller.ChampionshipManagerImpl;
import com.motodb.controller.MemberManager;
import com.motodb.controller.MemberManagerImpl;
import com.motodb.controller.TeamManager;
import com.motodb.controller.TeamManagerImpl;
import com.motodb.model.Bike;
import com.motodb.model.Championship;
import com.motodb.model.Rider;
import com.motodb.model.Team;
import com.motodb.view.alert.AlertTypes;
import com.motodb.view.alert.AlertTypesImpl;
import com.motodb.view.util.RiderGridPane;
import com.motodb.view.util.BikeGridPane;
import com.motodb.view.util.PersistentButtonToggleGroup;

import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.fxml.FXML;
import javafx.scene.control.Button;
import javafx.scene.control.Toggle;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;

public class BikeControl extends ScreenControl {

    // Alert panel to manage exceptions
    private final AlertTypes alert = new AlertTypesImpl();

    // Controller
    private final ChampionshipManager championshipManager = new ChampionshipManagerImpl();
    private final BikeManager bikeManager = new BikeManagerImpl();
    private final TeamManager teamManager = new TeamManagerImpl();

    // ToggleGroup to have just one toggleButton selected at a time
    private final ToggleGroup yearsButtons = new PersistentButtonToggleGroup();
    private final ToggleGroup teamsButtons = new PersistentButtonToggleGroup();

    @FXML
    private HBox mainPane;
    @FXML
    private HBox years, teams, bikes;

    private List<BikeGridPane> list = new ArrayList<>();

    GridPane grid = new GridPane();

    public BikeControl() {
        // super();

        for (Championship c : championshipManager.getChampionships()) {
            ToggleButton button = new ToggleButton(Integer.toString(c.getYear()));
            button.setToggleGroup(yearsButtons);
            button.setUserData(c.getYear());
        }

        if (!yearsButtons.getToggles().isEmpty()) {
            yearsButtons.getToggles().get(0).setSelected(true);

            // Creating a button for each class of that year, and adding such
            // button to the group
            for (Team t : teamManager.getTeamsFromYear(Integer.parseInt(yearsButtons.getSelectedToggle().getUserData().toString()))) {
                ToggleButton button = new ToggleButton(t.getName());
                button.setToggleGroup(teamsButtons);
                button.setUserData(t.getName());
            }

        }
    }

    /**
     * Called after the fxml file has been loaded; this method initializes the
     * fxml control class.
     */
    public void initialize() {

        // Adding the buttons created in the constructor to the hBox, before the
        // button
        for (Toggle button : yearsButtons.getToggles()) {
            years.getChildren().add(yearsButtons.getToggles().indexOf(button), (ToggleButton) button);
        }
        for (Toggle button : teamsButtons.getToggles()) {
            button.setToggleGroup(teamsButtons);
            teams.getChildren().add(teamsButtons.getToggles().indexOf(button), (ToggleButton) button);
        }

        // Method which handles the selection of a year
        this.filter();
        if (!yearsButtons.getToggles().isEmpty()) {
            yearsButtons.getToggles().get(0).setSelected(true);
            if (!teamsButtons.getToggles().isEmpty()) {
                teamsButtons.getToggles().get(0).setSelected(true);
            }
        }

    }

    /**
     * Called when the user selects a toggle-button to filter classes so there
     * are only buttons for each class of that year
     */
    private void filter() {
        yearsButtons.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
            public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) {

                list.clear();
                mainPane.getChildren().clear();

                teamsButtons.getToggles().clear();
                teams.getChildren().clear();

                // THIS CODE IS COPIED FROM TOP, IT NEEDS TO BE REFACTORED
                for (Team t : teamManager.getTeamsFromYear(Integer.parseInt(yearsButtons.getSelectedToggle().getUserData().toString()))) {
                    ToggleButton button = new ToggleButton(t.getName());
                    button.setToggleGroup(teamsButtons);
                    button.setUserData(t.getName());
                }

                // THIS CODE IS COPIED FROM TOP, IT NEEDS TO BE REFACTORED
                for (Toggle button : teamsButtons.getToggles()) {
                    button.setToggleGroup(teamsButtons);
                    teams.getChildren().add(teamsButtons.getToggles().indexOf(button), (ToggleButton) button);
                }

                if (!teamsButtons.getToggles().isEmpty()) {
                    teamsButtons.getToggles().get(0).setSelected(true);
                }
            }
        });

        teamsButtons.selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
            public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) {
                mainPane.getChildren().clear();

                if (newValue != null) {
                    if (!bikeManager.getBikesFromTeamAndYear(teamsButtons.getSelectedToggle().getUserData().toString(), Integer.parseInt(yearsButtons.getSelectedToggle().getUserData().toString())).isEmpty()){

                        list.clear();
                        for (Bike bike : bikeManager.getBikesFromTeamAndYear(teamsButtons.getSelectedToggle().getUserData().toString(), Integer.parseInt(yearsButtons.getSelectedToggle().getUserData().toString()))) {
                            BikeGridPane riderPane = new BikeGridPane(bike);
                            list.add(riderPane);
                        }

                        grid = new GridPane();

                        int i = 0, riders = 0;

                        while (i < (int) Math.ceil(list.size() / (4.0)) || riders < list.size()) {
                            int j = 0;
                            while (j < 4 && riders < list.size()) {
                                grid.add(list.get(riders).getPane(), j, i);
                                riders++;
                                j++;
                            }
                            i++;
                        }
                        mainPane.getChildren().add(grid);

                    } else {
                        mainPane.getChildren().clear();
                    }
                }

            }
        });

    }
}