Merge branch 'bug5959' of github.com:SAP/sailing-analytics into bug5959

+ - name: Convert repo name to lowercase GHCR package

+ id: ghcr

+ env:

+ GITHUB_REPOSITORY: ${{ github.repository }}

+ run: |

+ # $GITHUB_REPOSITORY is in format owner/repo

+ OWNER=${GITHUB_REPOSITORY%%/*} # extract owner

+ REPO=${GITHUB_REPOSITORY##*/} # extract repo

+ OWNER_LOWER=$(echo "$OWNER" | tr '[:upper:]' '[:lower:]') # lowercase owner

+ REPO_LOWER=$(echo "$REPO" | tr '[:upper:]' '[:lower:]') # lowercase repo

+ PACKAGE="$OWNER_LOWER/$REPO_LOWER"

+ echo "PACKAGE=${PACKAGE}" >> $GITHUB_OUTPUT

+ RELEASE_TAR_GZ_FILENAME=$( configuration/github-download-release-assets.sh ${{ secrets.GITHUB_TOKEN }} ${{ env.RELEASE_PREFIX }} ${{ github.repository }} )

+ tags: ghcr.io/${{steps.ghcr.outputs.PACKAGE}}:${{ env.RELEASE }}${{ env.BRANCH == 'main' && github.event.inputs.release == '' && format(',ghcr.io/{0}:latest', steps.ghcr.outputs.PACKAGE) || env.BRANCH == 'docker-17' && github.event.inputs.release == '' && format(',ghcr.io/{0}:latest-17', steps.ghcr.outputs.PACKAGE) || env.BRANCH == 'docker-21' && github.event.inputs.release == '' && format(',ghcr.io/{0}:latest-21', steps.ghcr.outputs.PACKAGE) || env.BRANCH == 'docker-24' && github.event.inputs.release == '' && format(',ghcr.io/{0}:latest-24', steps.ghcr.outputs.PACKAGE) || '' }}

+name: Merge main branch into docker-24 after successful build

+on:

+ workflow_run:

+ workflows: [release]

+ types: [completed]

+ branches: [main]

+ workflow_dispatch: {}

+jobs:

+ merge-main-into-docker-24:

+ permissions:

+ contents: write

+ if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}

+ runs-on: ubuntu-latest

+ steps:

+ - name: Checkout

+ uses: actions/checkout@v4

+ with:

+ ref: docker-24

+ fetch-depth: 0 # fetch the whole thing to make sure the histories merge

+ - name: Merge main into docker-24

+ uses: devmasx/merge-branch@854d3ac71ed1e9deb668e0074781b81fdd6e771f # v1.4.0

+ env:

+ GH_TOKEN: ${{ secrets.REPO_TOKEN_FOR_MERGE_AND_PUSH }}

+ with:

+ type: now

+ from_branch: main

+ target_branch: docker-24

+ message: Auto-merging main into docker-24 after successful release build

+ github_token: ${{ secrets.REPO_TOKEN_FOR_MERGE_AND_PUSH }}

+ - 'README.md'

+ description: Empty means ubuntu-latest, usually 4 CPUs with little disk/memory, but if you have runners named ubuntu-latest-Xcpu, it can be 4, 8, 16, and 64 as well, using, e.g., ubuntu-latest-16cpu; default is ubuntu-latest

+ default: ''

+ actions: read

+ runs-on: ${{ github.event.inputs.runner_cpus != '' && format('ubuntu-latest-{0}cpu', github.event.inputs.runner_cpus) || 'ubuntu-latest' }}

+ - name: Free Disk Space (Ubuntu)

+ uses: jlumbroso/free-disk-space@v1.3.1

+ with:

+ # this might remove tools that are actually needed,

+ # if set to "true" but frees about 6 GB

+ tool-cache: false

+ # all of these default to true, but feel free to set to

+ # "false" if necessary for your workflow

+ android: false

+ dotnet: true

+ haskell: true

+ large-packages: true

+ docker-images: false

+ swap-storage: true

+ sudo dd if=/dev/zero of=/mnt/large-swapfile bs=1G count=30

+ - name: Create TMP space under /mnt/tmp

+ shell: bash

+ run: |

+ sudo mkdir /mnt/tmp

+ sudo chmod 777 /mnt/tmp

+ TMP: /mnt/tmp

+ AWS_S3_TEST_S3ACCESSID: ${{ secrets.AWS_S3_TEST_S3ACCESSID }}

+ AWS_S3_TEST_S3ACCESSKEY: ${{ secrets.AWS_S3_TEST_S3ACCESSKEY }}

+ GEONAMES_ORG_USERNAMES: ${{ secrets.GEONAMES_ORG_USERNAMES }}

+ GOOGLE_MAPS_AUTHENTICATION_PARAMS: ${{ secrets.GOOGLE_MAPS_AUTHENTICATION_PARAMS }}

+ APP_PARAMETERS: "-Daws.region=eu-west-1"

+ ./configuration/buildAndUpdateProduct.sh -x ${{ github.event.inputs.runner_cpus == '' && '4' || github.event.inputs.runner_cpus }} ${{ github.event.inputs.skip_tests == 'true' && '-t' || '' }} ${{ github.event.inputs.local_target_platform == 'true' && '-v' || '' }} build 2>&1

+ - name: show disk stats

+ if: always()

+ run: df -h

+ env:

+ HUDSON_JOB_USERNAME: ${{ secrets.HUDSON_JOB_USERNAME }}

+ HUDSON_JOB_PASSWORD: ${{ secrets.HUDSON_JOB_PASSWORD }}

+ HUDSON_JOB_TOKEN: ${{ secrets.HUDSON_JOB_TOKEN }}

+ if: ${{ always() && env.HUDSON_JOB_USERNAME != '' && env.HUDSON_JOB_PASSWORD != '' && env.HUDSON_JOB_TOKEN != '' }}

+ fastlane (2.228.0)

+ google-cloud-core (1.7.1)

+ google-cloud-errors (1.4.0)

+ public_suffix (5.1.1)

+ rexml (3.4.2)

+ 2.4.21

+ * [[Upgrading Operating System Across Landscape|wiki/info/landscape/operating-system-upgrade]]

+* [[Cloud Infrastructure Orchestration|wiki/projects/cloud-orchestrator]]

+The Sailing Analytics, formerly known as the "SAP Sailing Analytics," are a solution for portraying and analyzing sailing regattas, supporting training scenarios, and powering the vast archive at https://sapsailing.com. The solution consists of a cloud application with a web-based user interface, as well as three companion apps that integrate with the cloud application. This repository has the code for the cloud-based web application, and two of the three mobile apps (Buoy Pinger and Race Manager). The third companion app (Sail Insight) is found in [another repository](https://github.com/SAP/sailing-analytics-sail-insight).

+To use Java 24, use the ``docker-compose-24.yml`` file instead:

+ docker-compose -f docker-compose-24.yml up

+Builds usually run on [GitHub Actions](https://github.com/SAP/sailing-analytics/actions/workflows/release.yml) upon every push. A few repository secrets ensure that the build process has the permissions it needs. Pushes to the ``main``, ``docker-24`` and ``releases/*`` branches also publish a [release](https://github.com/SAP/sailing-analytics/releases) after a successful build.

+

+There are two options for building, detailed below; for both, you need to fulfill a few prerequisites.

+

+### Prerequisites

+

+If you have forked the repository and would like to run your own build, you will need the following prerequisites:

+

+#### Google Maps API Key

+

+Create or log on to your Google account and go to the [Google Cloud Console](https://console.cloud.google.com/apis/) and create an API key at least for the Maps JavaScript API. To later run the full product, while you're here, you can also create an API key for the YouTube Data API v3.

+

+#### AWS S3 Bucket for Upload Tests

+

+The build runs integration tests using the AWS API, requiring an access key with permission to upload to a bucket called ``sapsailing-automatic-upload-test``. Create that bucket in your AWS S3 environment. You can create an IAM user with CLI access and a permission policy that restricts write permissions to just that test bucket. You have to create the bucked in AWS region ``eu-west-1``. A permission policy for that user can look like this:

+

+```

+{

+ "Version": "2012-10-17",

+ "Statement": [

+ {

+ "Sid": "Stmt1422015883000",

+ "Effect": "Allow",

+ "Action": [

+ "s3:AbortMultipartUpload",

+ "s3:DeleteObject",

+ "s3:DeleteObjectVersion",

+ "s3:GetBucketAcl",

+ "s3:GetBucketCORS",

+ "s3:GetBucketLocation",

+ "s3:GetBucketLogging",

+ "s3:GetBucketNotification",

+ "s3:GetBucketPolicy",

+ "s3:GetBucketTagging",

+ "s3:GetBucketVersioning",

+ "s3:GetBucketWebsite",

+ "s3:GetLifecycleConfiguration",

+ "s3:GetObject",

+ "s3:GetObjectAcl",

+ "s3:GetObjectTorrent",

+ "s3:GetObjectVersion",

+ "s3:GetObjectVersionAcl",

+ "s3:GetObjectVersionTorrent",

+ "s3:ListAllMyBuckets",

+ "s3:ListBucket",

+ "s3:ListBucketMultipartUploads",

+ "s3:ListBucketVersions",

+ "s3:ListMultipartUploadParts",

+ "s3:PutBucketLogging",

+ "s3:PutBucketNotification",

+ "s3:PutBucketPolicy",

+ "s3:PutBucketTagging",

+ "s3:PutBucketVersioning",

+ "s3:PutBucketWebsite",

+ "s3:PutLifecycleConfiguration",

+ "s3:PutObject",

+ "s3:PutObjectAcl",

+ "s3:PutObjectVersionAcl",

+ "s3:RestoreObject"

+ ],

+ "Resource": [

+ "arn:aws:s3:::sapsailing-automatic-upload-test/*",

+ "arn:aws:s3:::sapsailing-automatic-upload-test"

+ ]

+ }

+ ]

+}

+```

+

+Create an access key for that user and note key ID and secret.

+

+#### Account(s) for geonames.org

+

+The build runs integration tests against [geonames.org](https://geonames.org). Use their login/sign-up form to create your user account and note its username.

+

+### Get the GitHub Actions build to work in your forked repository

+

+Assign the IDs and secrets from the prerequisites to repository secrets in your forked repository as follows:

+

+```

+AWS_S3_TEST_S3ACCESSID: {your-S3-test-bucket-upload-token-ID}

+AWS_S3_TEST_S3ACCESSKEY: {key-for-your-S3-token}

+GEONAMES_ORG_USERNAMES: {comma-separated-list-of-geonames.org-usernames}

+GOOGLE_MAPS_AUTHENTICATION_PARAMS: key={your-Google-Maps-API-key}

+```

+

+Then, manually trigger the ``release`` workflow with default options. You find the "Run workflow" drop-down in your forked repository under ``https://github.com/{your-github-user}/[your-repository-name}/actions/workflows/release.yml``.

+

+Release builds will trigger the ``create-docker-image`` workflow which will produce a Docker image of your release and publish it as a "ghcr" package in your repository. Note that package names are computed from the repository name by converting the latter to all lowercase characters. If you want to use your packages in the docker-compose configurations from the ``docker/`` folder, make sure to adjust the package name so it points to your own fork's package registry.

+

+If you want automatic validation of your changes to the ``main`` branch also for newer Java versions, you can use the ``merge-main-into-docker-24`` workflow. It requires another secret:

+

+```

+REPO_TOKEN_FOR_MERGE_AND_PUSH: {a-GitHub-token-enabled-for-push}

+```

+

+The workflow will launch automatically after a release has been performed for the ``main`` branch and will try to merge the latest ``main`` branch into ``docker-24`` and pushing the merge result if the merge was successful. This will then trigger a build for the ``docker-24`` branch which, if successul, will in turn produce a release and a docker image for use with Java 24.

+

+### Run a build locally

+

+This assumes you have completed the onboarding (see again [here](https://wiki.sapsailing.com/wiki/howto/onboarding)) successfully, including the Maven-specific parts such as having Maven installed (>= 3.9.x) and having a valid ``toolchains.xml`` file in your ~/.m2 folder. Furthermore, set and export the following environment variables:

+

+```

+export AWS_S3_TEST_S3ACCESSID={your-S3-test-bucket-upload-token-ID}

+export AWS_S3_TEST_S3ACCESSKEY={key-for-your-S3-token}

+export GEONAMES_ORG_USERNAMES={comma-separated-list-of-geonames.org-usernames}

+export GOOGLE_MAPS_AUTHENTICATION_PARAMS=key={your-Google-Maps-API-key}

+export JAVA8_HOME={location-of-your-JDK8}

+export JAVA_HOME={location-of-your-JDK17-or-newer}

+```

+

+To build, then invoke

+This will build the Android companion apps first, then the web application. If you lack a proper Android SDK set-up, consider using the ``-a`` option to skip building the Android apps. If the build was successful you can install the product locally by invoking

+You need to have Java 8 installed. Get one from, e.g., [here](https://tools.eu1.hana.ondemand.com/#cloud). Either ensure that this JVM's ``java`` executable in on the ``PATH`` or set ``JAVA_HOME`` appropriately.

+At [https://github.com/SAP/sailing-analytics/releases](https://github.com/SAP/sailing-analytics/releases) you find official product builds. To fetch and install one of them, make an empty directory, change into it and run the ``refreshInstance.sh`` command, e.g., like this:

+SPDX-PackageComment = "The code in this project may include calls to APIs (\"API Calls\") of\n SAP or third-party products or services developed outside of this project\n (\"External Products\").\n \"APIs\" means application programming interfaces, as well as their respective\n specifications and implementing code that allows software to communicate with\n other software.\n API Calls to External Products are not licensed under the open source license\n that governs this project. The use of such API Calls and related External\n Products are subject to applicable additional agreements with the relevant\n provider of the External Products. In no event shall the open source license\n that governs this project grant any rights in or to any External Products,or\n alter, expand or supersede any terms of the applicable additional agreements.\n If you have a valid license agreement with SAP for the use of a particular SAP\n External Product, then you may make use of any API Calls included in this\n project's code for that SAP External Product, subject to the terms of such\n license agreement. If you do not have a valid license agreement for the use of\n a particular SAP External Product, then you may only make use of any API Calls\n in this project for that SAP External Product for your internal, non-productive\n and non-commercial test and evaluation of such API Calls. Nothing herein grants\n you any rights to use or access any SAP External Product, or provide any third\n parties the right to use of access any SAP External Product, through API Calls."

+extra="${extra} -Dgwt.workers=${GWT_WORKERS} -Djava.io.tmpdir=$TMP -Dgwt.workDir=$TMP"

+ # /var/run is writable only for root, so we need to be able to sudo:

+ sudo bash -c "echo ${last_change_millis} >${LAST_CHANGE_FILE}"

+# Setup script for Amazon Linux 2023. Use 50g root partition.

+# May need to update macro definitions for the archive IP.

+RELEASE_TAR_GZ_FILE_NAME=$( `dirname "${0}"`/github-download-release-assets.sh "${BEARER_TOKEN}" "${RELEASE_NAME_PREFIX}" SAP/sailing-analytics )

+# ./github-download-release-assets.sh {BEARER_TOKEN} {release-name-prefix} {repository-name}

+# ./github-download-release-assets.sh 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 main- SAP/sailing-analytics

+GITHUB_REPOSITORY="${3}"

+RELEASES=$( curl -L -H 'Authorization: Bearer '${BEARER_TOKEN} https://api.github.com/repos/${GITHUB_REPOSITORY}/releases 2>/dev/null )

+ curl -o "${RELEASE_TAR_GZ_FILE_NAME}" -L -H 'Accept: application/octet-stream' -H 'Authorization: Bearer '${BEARER_TOKEN} 'https://api.github.com/repos/'${GITHUB_REPOSITORY}'/releases/assets/'${RELEASE_TAR_GZ_ASSET_ID}

+ curl -o release-notes.txt -L -H 'Accept: application/octet-stream' -H 'Authorization: Bearer '${BEARER_TOKEN} 'https://api.github.com/repos/'${GITHUB_REPOSITORY}'/releases/assets/'${RELEASE_NOTES_TXT_ASSET_ID}

+GITHUB_REPOSITORY="${3}"

+NEXT_PAGE="https://api.github.com/repos/${GITHUB_REPOSITORY}/actions/runs?created=${DATE_YESTERDAY/+/%2B}..${UNIX_DATE/+/%2B}&per_page=100"

+release_prefix="$1"

+GITHUB_REPOSITORY="$2"

+OWNER=${GITHUB_REPOSITORY%%/*}

+OWNER_LOWER=$(echo "$OWNER" | tr '[:upper:]' '[:lower:]')

+REPO=${GITHUB_REPOSITORY##*/}

+REPO_LOWER=$(echo "$REPO" | tr '[:upper:]' '[:lower:]')

+PACKAGE="$OWNER_LOWER/$REPO_LOWER"

+RELEASE_TAR_GZ_FILENAME=$( ${GITROOT}/configuration/github-download-release-assets.sh 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 "${release_prefix}" "${GITHUB_REPOSITORY}" )

+ docker buildx build --builder=container --platform=linux/amd64,linux/arm64 --build-arg RELEASE=${release} -t ghcr.io/${PACKAGE}:${release} --push .

+release_prefix="$1"

+GITHUB_REPOSITORY="$2"

+OWNER=${GITHUB_REPOSITORY%%/*}

+OWNER_LOWER=$(echo "$OWNER" | tr '[:upper:]' '[:lower:]')

+REPO=${GITHUB_REPOSITORY##*/}

+REPO_LOWER=$(echo "$REPO" | tr '[:upper:]' '[:lower:]')

+PACKAGE="$OWNER_LOWER/$REPO_LOWER"

+RELEASE_TAR_GZ_FILENAME=$( ${GITROOT}/configuration/github-download-release-assets.sh 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 "${release_prefix}" "${GITHUB_REPOSITORY}" )

+ docker build --build-arg RELEASE=${release} -t ghcr.io/${PACKAGE}:${release}-arm .

+ docker push ghcr.io/${PACKAGE}:${release}-arm

+ docker tag ghcr.io/${PACKAGE}:${release}-arm ghcr.io/${PACKAGE}:latest-arm

+ docker push ghcr.io/${PACKAGE}:latest-arm

+release_prefix="$1"

+GITHUB_REPOSITORY="$2"

+OWNER=${GITHUB_REPOSITORY%%/*}

+OWNER_LOWER=$(echo "$OWNER" | tr '[:upper:]' '[:lower:]')

+REPO=${GITHUB_REPOSITORY##*/}

+REPO_LOWER=$(echo "$REPO" | tr '[:upper:]' '[:lower:]')

+PACKAGE="$OWNER_LOWER/$REPO_LOWER"

+RELEASE_TAR_GZ_FILENAME=$( ${GITROOT}/configuration/github-download-release-assets.sh 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 "${release_prefix}" "${GITHUB_REPOSITORY}" )

+ docker build --build-arg RELEASE=${release} -t ghcr.io/${PACKAGE}:${release} -f Dockerfile_sapsailing_on_sapmachine11 .

+ docker push ghcr.io/${PACKAGE}:${release}

+ docker tag ghcr.io/${PACKAGE}:${release} ghcr.io/${PACKAGE}:latest-11

+ docker push ghcr.io/${PACKAGE}:latest-11

+release_prefix="$1"

+GITHUB_REPOSITORY="$2"

+OWNER=${GITHUB_REPOSITORY%%/*}

+OWNER_LOWER=$(echo "$OWNER" | tr '[:upper:]' '[:lower:]')

+REPO=${GITHUB_REPOSITORY##*/}

+REPO_LOWER=$(echo "$REPO" | tr '[:upper:]' '[:lower:]')

+PACKAGE="$OWNER_LOWER/$REPO_LOWER"

+RELEASE_TAR_GZ_FILENAME=$( ${GITROOT}/configuration/github-download-release-assets.sh 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 "${release_prefix}" "${GITHUB_REPOSITORY}" )

+ docker build --build-arg RELEASE=${release} -t ghcr.io/${PACKAGE}:${release} -f Dockerfile_sapsailing_on_sapmachine17 .

+ docker push ghcr.io/${PACKAGE}:${release}

+ docker tag ghcr.io/${PACKAGE}:${release} ghcr.io/${PACKAGE}:latest-17

+ docker push ghcr.io/${PACKAGE}:latest-17

+ com.sap.sailing.domain.leaderboard,

+ com.sap.sailing.domain.tracking,

+ com.sap.sailing.domain.tracking.impl,

+ com.sap.sailing.domain.shared.tracking,

+import com.sap.sailing.domain.shared.tracking.AddResult;

+import com.sap.sailing.domain.shared.tracking.LineDetails;

+import com.sap.sailing.domain.shared.tracking.LineDetails;

+import com.sap.sailing.domain.shared.tracking.LineDetails;

+import com.sap.sailing.domain.shared.tracking.impl.TimedComparator;

+import com.sap.sailing.domain.shared.tracking.LineDetails;

+import com.sap.sailing.domain.shared.tracking.Track;

+ BENETEAU_FIRST_36 ("Benetau First 36", true, 11.98, 3.80, BoatHullType.MONOHULL, true, "First 36"),

+ ELAN_E4("Elan E4", true, 10.6, 3.5, BoatHullType.MONOHULL, true, "Elan E4"),

+ final Iterable<Document> queryResult = (clientSessionOrNull == null ? messagesCollection.find(query)

+ : messagesCollection.find(clientSessionOrNull, query)).sort(Sorts.ascending(FieldNames.IGTIMI_MESSAGES_TIMESTAMP.name()));

+ * When combined with {@link IgtimiWindReceiver} (which is such a {@link BulkFixReceiver}),

+ * for a websocket connection.<p>

+ if (webSocketClient.getDeviceSerialNumbers().contains(deviceSerialNumber)) {

+ final User user = webSocketClient.getAuthenticatedUser();

+ final OwnershipAnnotation deviceOwnership = securityService.getOwnership(device.getIdentifier());

+ final AccessControlListAnnotation deviceAccessControlList = securityService.getAccessControlList(device.getIdentifier());

+ if (!Util.isEmpty(Util.filter(daws, daw->{

+ final OwnershipAnnotation dawOownership = securityService.getOwnership(daw.getIdentifier());

+ final AccessControlListAnnotation dawAccessControlList = securityService.getAccessControlList(daw.getIdentifier());

+ return PermissionChecker.isPermitted(

+ daw.getIdentifier().getPermission(DefaultActions.READ),

+ user, securityService.getAllUser(),

+ dawOownership==null?null:dawOownership.getAnnotation(),

+ dawAccessControlList==null?null:dawAccessControlList.getAnnotation());

+ }))

+ && PermissionChecker.isPermitted(

+ device.getIdentifier().getPermission(DefaultActions.READ),

+ deviceOwnership==null?null:deviceOwnership.getAnnotation(),

+ deviceAccessControlList==null?null:deviceAccessControlList.getAnnotation()) ) {

+ webSocketClient.sendBytesByFuture(ByteBuffer.wrap(messageAsBytes));

+ }

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.Track;

+ * Returns a wind fix produced out of an AWS/AWA and other fixes, as well as the fixes used for this (in case of

+ * interpolation between two fixes, the older one of the two is returned), including a {@link BatteryLevel} fix, if

+ * any was found, although this did technically not contribute to the production of the {@link Wind} object.

+ * improve precision of boat speed / course over SOG/COG measurements:

+ * earlier than the {@code timePoint} given. This in particular preserves at least one live fix which will "hide"

+ * older, e.g., buffered fixes that may be received when a WindBot device sends them out-of-order. For old, buffered

+ * fixes this may still mean that could be dropped prior to being converted into a {@link Wind} object with an older

+ * time stamp, but usually---and particularly with buffered data from previous days---this shouldn't be a problem.

+ * Also, old data can still be imported at a later point in time.

+ trackToCleanUp.removeAllUpToExcluding(fix);

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.AddResult;

+import com.sap.sailing.domain.shared.tracking.impl.TrackingConnectorInfoImpl;

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.impl.TimedComparator;

+ com.sap.sailing.domain.shared.tracking,

+ com.sap.sailing.domain.shared.tracking.impl,

+ com.sap.sailing.domain.statistics.impl

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.impl.PartialNavigableSetView;

+import com.sap.sailing.domain.shared.tracking.impl.TrackImpl;

+import com.sap.sailing.domain.shared.tracking.impl.TimedComparator;

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.impl.TimeRangeCache;

+ com.sap.sailing.domain.shared.tracking.Track.Adder<T> adder, TimeRangeCache<T> cache,

+ com.sap.sailing.domain.shared.tracking.Track.TimeRangeValueCalculator<T> valueCalculator) {

+import com.sap.sailing.domain.shared.tracking.Track;

+import com.sap.sailing.domain.shared.tracking.impl.TrackImpl;

+import com.sap.sailing.domain.shared.tracking.TrackingConnectorInfo;

+import com.sap.sailing.domain.shared.tracking.TrackingConnectorInfo;

+package com.sap.sailing.domain.shared.tracking;

+

+import javax.swing.plaf.basic.BasicSliderUI.TrackListener;

+

+/**

+ * The result of trying to add a fix to a {@link Track}. Used when notifying {@link TrackListener}s.

+ * This allows listeners, in particular, to distinguish between the add and replace scenario.

+ *

+ * @author Axel Uhl (D043530)

+ *

+ */

+public enum AddResult {

+ NOT_ADDED, ADDED, REPLACED;

+}

+package com.sap.sailing.domain.shared.tracking;

+

+/**

+ * A predicate for a fix, for use in

+ * {@link Track#getInterpolatedValue(com.sap.sse.common.TimePoint, com.sap.sse.common.Util.Function)}, used, e.g., to

+ * provide a rule for when a fix shall be accepted during the search for surrounding fixes.

+ *

+ * @author Axel Uhl (d043530)

+ *

+ * @param <FixType>

+ */

+public interface FixAcceptancePredicate<FixType> {

+ boolean isAcceptFix(FixType fix);

+}

+package com.sap.sailing.domain.shared.tracking;

+

+import com.sap.sailing.domain.base.Mark;

+import com.sap.sailing.domain.base.Waypoint;

+import com.sap.sailing.domain.common.NauticalSide;

+import com.sap.sailing.domain.common.Position;

+import com.sap.sse.common.Bearing;

+import com.sap.sse.common.Distance;

+import com.sap.sse.common.TimePoint;

+

+/**

+ * For a line such as a start or a finish line, tells the line's length at a given time, which side is

+ * {@link NauticalSide#PORT port} and which is {@link NauticalSide#STARBOARD starboard} when approaching the line,

+ * and---if wind information is available---its angle to a true wind direction and the advantageous side in approaching

+ * direction as well as how much the advantageous side is ahead. The wind-dependent information

+ * will all be <code>null</code> if no wind data is available.

+ *

+ * @author Axel Uhl (d043530)

+ *

+ */

+public interface LineDetails {

+ TimePoint getTimePoint();

+

+ Waypoint getWaypoint();

+

+ Distance getLength();

+

+ Bearing getAngleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind();

+

+ NauticalSide getAdvantageousSideWhileApproachingLine();

+

+ Mark getStarboardMarkWhileApproachingLine();

+

+ Mark getPortMarkWhileApproachingLine();

+

+ Distance getAdvantage();

+

+ Position getPortMarkPosition();

+

+ Position getStarboardMarkPosition();

+

+ default Mark getAdvantageousMark() {

+ return getAdvantageousSideWhileApproachingLine() == NauticalSide.PORT ? getPortMarkWhileApproachingLine() : getStarboardMarkWhileApproachingLine();

+ }

+

+ default Position getAdvantageousMarkPosition() {

+ return getAdvantageousSideWhileApproachingLine() == NauticalSide.PORT ? getPortMarkPosition() : getStarboardMarkPosition();

+ }

+

+ default Bearing getBearingFromStarboardToPortWhenApproachingLine() {

+ return getStarboardMarkPosition().getBearingGreatCircle(getPortMarkPosition());

+ }

+

+ default Bearing getBearingFromPortToStarboardWhenApproachingLine() {

+ return getPortMarkPosition().getBearingGreatCircle(getStarboardMarkPosition());

+ }

+}

+package com.sap.sailing.domain.shared.tracking;

+

+import com.sap.sse.common.Timed;

+

+/**

+ * {@link Track} specialization, which is mapped to a specific type of items.

+ *

+ * @param <ItemType>

+ * the type of item this track is mapped to

+ * @param <FixType>

+ * the type of fix that is contained in this track

+ */

+public interface MappedTrack<ItemType, FixType extends Timed> extends Track<FixType> {

+

+ /**

+ * @return the item this track is mapped to.

+ */

+ ItemType getTrackedItem();

+

+}

+package com.sap.sailing.domain.shared.tracking;

+

+import java.io.Serializable;

+import java.util.Iterator;

+import java.util.concurrent.locks.ReadWriteLock;

+import java.util.function.Function;

+

+import com.sap.sailing.domain.common.tracking.GPSFixMoving;

+import com.sap.sailing.domain.shared.tracking.impl.TimeRangeCache;

+import com.sap.sse.common.Duration;

+import com.sap.sse.common.TimePoint;

+import com.sap.sse.common.Timed;

+import com.sap.sse.common.scalablevalue.ScalableValue;

+

+/**

+ * A track records {@link Timed} items for an object of type <code>ItemType</code>. It allows clients to ask for a value

+ * close to a given {@link TimePoint}. The track manages a time-based set of raw fixes. An implementation may have an

+ * understanding of how to eliminate outliers. For example, if a track implementation knows it's tracking boats, it may

+ * consider fixes that the boat cannot possibly have reached due to its speed and direction change limitations as

+ * outliers. The set of fixes with outliers filtered out can be obtained using {@link #getFixes} whereas

+ * {@link #getRawFixes()} returns the unfiltered, raw fixes. If an implementation has no idea what an outlier is,

+ * both methods will return the same fix sequence.<p>

+ *

+ * With tracks, concurrency is an important issue. Threads may want to modify a track while other threads may want to

+ * read from it. Several methods such as {@link #getLastFixAtOrBefore(TimePoint)} return a single fix and can manage

+ * concurrency internally. However, those methods returning a collection of fixes, such as {@link #getFixes()} or an

+ * iterator over a collection of fixes, such as {@link #getFixesIterator(TimePoint, boolean)}, need special treatment.

+ * Until we internalize such iterations (see bug 824, http://bugzilla.sapsailing.com/bugzilla/show_bug.cgi?id=824),

+ * callers need to manage a read lock which is part of a {@link ReadWriteLock} managed by this track. Callers do so

+ * by calling {@link #lockForRead} and {@link #unlockAfterRead}.

+ *

+ * @author Axel Uhl (d043530)

+ */

+public interface Track<FixType extends Timed> extends Serializable {

+ /**

+ * An adding function to be used together with {@link Track#getValueSum(TimePoint, TimePoint, Object, Adder, TimeRangeCache, TimeRangeValueCalculator)}.

+ *

+ * @author Axel Uhl (D043530)

+ *

+ * @param <T>

+ */

+ static interface Adder<T> {

+ /**

+ * Adds two elements of type {@code T}. Neither argument must be {@code null}.

+ */

+ T add(T t1, T t2);

+ }

+

+ static interface TimeRangeValueCalculator<T> {

+ /**

+ * Calculates a value for fixes across a time range. When the method is called,

+ * a read lock will previously have been {@link Track#lockForRead obtained} before,

+ * so an implementing class does not need to worry about acquiring the lock.

+ */

+ T calculate(TimePoint from, TimePoint to);

+ }

+

+ /**

+ * Locks this track for reading by the calling thread. If the thread already holds the lock for this track,

+ * the hold count will be incremented. Make sure to call {@link #unlockAfterRead()} in a <code>finally</code>

+ * block to release the lock under all possible circumstances. Failure to do so will inevitably lead to

+ * deadlocks!

+ */

+ void lockForRead();

+

+ /**

+ * Decrements the hold count for this track's read lock for the calling thread. If it goes to zero, the lock will be

+ * released and other readers or a writer can obtain the lock. Make sure to call this method in a

+ * <code>finally</code> block for each {@link #lockForRead()} invocation.

+ */

+ void unlockAfterRead();

+

+ /**

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ *

+ * @return the smoothened fixes

+ */

+ Iterable<FixType> getFixes();

+

+ /**

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ *

+ * @return The smoothened fixes between from and to.

+ */

+ Iterable<FixType> getFixes(TimePoint from, boolean fromInclusive, TimePoint to, boolean toInclusive);

+

+ /**

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ */

+ Iterable<FixType> getRawFixes();

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getLastFixAtOrBefore(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getLastFixBefore(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getLastRawFixAtOrBefore(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getFirstFixAtOrAfter(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getFirstRawFixAtOrAfter(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getLastRawFixBefore(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getFirstRawFixAfter(TimePoint timePoint);

+

+ /**

+ * Returns <code>null</code> if no such fix exists.

+ */

+ FixType getFirstFixAfter(TimePoint timePoint);

+

+ /**

+ * The first fix in this track or <code>null</code> if the track is empty. The fix returned may

+ * be an outlier that is not returned by calls operating on the smoothened version of the track.

+ */

+ FixType getFirstRawFix();

+

+ /**

+ * The last fix in this track or <code>null</code> if the track is empty. The fix returned may

+ * be an outlier that is not returned by calls operating on the smoothened version of the track.

+ */

+ FixType getLastRawFix();

+

+ /**

+ * Interpolates an aspect of the fixes in this track for a given {@code timePoint}. If {@code timePoint} matches

+ * exactly a fix in this track, that fix is used. If this track is empty, {@code null} is returned. If the

+ * {@code timePoint} is after the last fix of this track, the last fix is used; if before the first fix, the first

+ * fix is used.

+ * <p>

+ *

+ * The fix(es) are converted to {@link ScalableValue}s using the {@code converter} which gives callers a choice

+ * which aspect of the fixes to project and interpolate. If more than one value results because two fixes (one

+ * before, one after) are used, linear interpolation based on the fixes' time points takes place.

+ * <p>

+ *

+ * Example: for a track of {@link GPSFixMoving} fixes the course over ground shall be determined for a given time

+ * point. The call would look like this:

+ * {@code getInterpolatedValue(timePoint, f->new ScalableBearing(f.getSpeed().getBearing()))}

+ *

+ * @return the projected interpolated value, typed by what the {@link ScalableValue#divide(double)} method returns.

+ */

+ <InternalType, ValueType> ValueType getInterpolatedValue(TimePoint timePoint,

+ Function<FixType, ScalableValue<InternalType, ValueType>> converter);

+

+ /**

+ * Returns an iterator starting at the first fix after <code>startingAt</code> (or "at or after" in case

+ * <code>inclusive</code> is <code>true</code>). The fixes returned by the iterator exclude outliers (see

+ * also {@link #getFixes()} and returns the remaining fixes without any smoothening or dampening applied.

+ *

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ */

+ Iterator<FixType> getFixesIterator(TimePoint startingAt, boolean inclusive);

+

+ /**

+ * Returns an iterator starting at the first fix after <code>startingAt</code> (or "at or after" in case

+ * <code>inclusive</code> is <code>true</code>) and that ends at the <code>endingAt</code> time point or just before

+ * in case <code>endingAtIncluive</code> is false. The fixes returned by the iterator are the smoothened fixes (see

+ * also {@link #getFixes()}, without any smoothening or dampening applied.

+ *

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an

+ * exception will be thrown in case the caller has failed to do so.

+ *

+ * @param startingAt

+ * if <code>null</code>, starts with the first fix available

+ * @param endingAt

+ * if <code>null</code>., ends with the last fix available

+ */

+ Iterator<FixType> getFixesIterator(TimePoint startingAt, boolean startingAtInclusive, TimePoint endingAt, boolean endingAtInclusive);

+

+ /**

+ * Returns an iterator starting at the first raw fix after <code>startingAt</code> (or "at or after" in case

+ * <code>inclusive</code> is <code>true</code>). The fixes returned by the iterator are the raw fixes (see also

+ * {@link #getRawFixes()}, without any smoothening or dampening applied.

+ *

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ */

+ Iterator<FixType> getRawFixesIterator(TimePoint startingAt, boolean inclusive);

+

+ /**

+ * Returns an iterator starting at the first raw fix after <code>startingAt</code> (or "at or after" in case

+ * <code>startingAtInclusive</code> is <code>true</code>) and ending at the <code>endingAt</code> time point or just before

+ * in case <code>endingAtIncluive</code> is false. The fixes returned by the iterator are the raw fixes (see also

+ * {@link #getRawFixes()}, without any smoothening or dampening applied.

+ *

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ */

+ Iterator<FixType> getRawFixesIterator(TimePoint startingAt, boolean startingAtInclusive, TimePoint endingAt, boolean endingAtInclusive);

+

+ /**

+ * Returns a descending iterator starting at the first fix before <code>startingAt</code> (or "at or before" in case

+ * <code>inclusive</code> is <code>true</code>). The fixes returned by the iterator are the smoothened fixes (see

+ * also {@link #getFixes()}, without any smoothening or dampening applied.

+ *

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ */

+ Iterator<FixType> getFixesDescendingIterator(TimePoint startingAt, boolean inclusive);

+

+ /**

+ * Returns a descending iterator starting at the first raw fix before <code>startingAt</code> (or "at or before" in case

+ * <code>inclusive</code> is <code>true</code>). The fixes returned by the iterator are the raw fixes (see also

+ * {@link #getRawFixes()}, without any smoothening or dampening applied.

+ *

+ * Callers must have called {@link #lockForRead()} before calling this method. This will be checked, and an exception

+ * will be thrown in case the caller has failed to do so.

+ */

+ Iterator<FixType> getRawFixesDescendingIterator(TimePoint startingAt, boolean inclusive);

+

+ /**

+ * @return the average duration between two fixes (outliers removed) in this track or <code>null</code> if there is not

+ * more than one fix in the track

+ */

+ Duration getAverageIntervalBetweenFixes();

+

+ /**

+ * @return the average duration between two fixes (outliers <em>not</em> removed) in this track or <code>null</code> if there is not

+ * more than one raw fix in the track

+ */

+ Duration getAverageIntervalBetweenRawFixes();

+

+ <T> T getValueSum(TimePoint from, TimePoint to, T nullElement, Adder<T> adder, TimeRangeCache<T> cache, TimeRangeValueCalculator<T> valueCalculator);

+

+ /**

+ * @return the number of raw fixes contained in the Track.

+ */

+ int size();

+

+ /**

+ * Tells whether the collection of {@link #getRawFixes() raw fixes} (no outliers removed) is empty

+ */

+ boolean isEmpty();

+

+}

+

+package com.sap.sailing.domain.shared.tracking;

+

+import java.io.Serializable;

+

+/**

+ * Identifies the tracking connector that was used to create a TrackedRace.

+ * Further the Connector can provide a webUrl, that leads to an event web page.

+ */

+public interface TrackingConnectorInfo extends Serializable {

+

+ /**

+ * gets the name associated with the tracking technology used for the Race

+ */

+ String getTrackingConnectorName();

+

+ /**

+ * gets a {@link String} representation of the default web-URL associated with the tracking technology used for the Race.

+ * may be {@code null} if there is none provided in the adapter.

+ */

+ String getTrackingConnectorDefaultUrl();

+

+ /**

+ * gets a {@link String} representation of the web-URL associated with the Event.

+ * may be {@code null} if the API of the respective Tracking-Service does not provide a URL.

+ */

+ String getWebUrl();

+}

+package com.sap.sailing.domain.shared.tracking.impl;

+

+import com.sap.sailing.domain.base.Mark;

+import com.sap.sailing.domain.base.Waypoint;

+import com.sap.sailing.domain.common.NauticalSide;

+import com.sap.sailing.domain.common.Position;

+import com.sap.sailing.domain.shared.tracking.LineDetails;

+import com.sap.sse.common.Bearing;

+import com.sap.sse.common.Distance;

+import com.sap.sse.common.TimePoint;

+

+public class LineDetailsImpl implements LineDetails {

+ private final TimePoint timePoint;

+ private final Waypoint waypoint;

+ private final Distance length;

+ private final Bearing angleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind;

+ private final NauticalSide advantageousSidewhileApproachingLine;

+ private final Distance advantage;

+ private final Mark portMarkWhileApproachingLine;

+ private final Mark starboardMarkWhileApproachingLine;

+ private final Position portMarkPosition;

+ private final Position starboardMarkPosition;

+

+ public LineDetailsImpl(TimePoint timePoint, Waypoint waypoint, Distance length,

+ Bearing angleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind, NauticalSide advantageousSideWhileApproachingLine,

+ Distance advantage, Mark portMarkWhileApproachingLine, Mark starboardMarkWhileApproachingLine,

+ Position portMarkPosition, Position starboardMarkPosition) {

+ super();

+ this.timePoint = timePoint;

+ this.waypoint = waypoint;

+ this.length = length;

+ this.angleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind = angleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind;

+ this.advantageousSidewhileApproachingLine = advantageousSideWhileApproachingLine;

+ this.advantage = advantage;

+ this.portMarkWhileApproachingLine = portMarkWhileApproachingLine;

+ this.starboardMarkWhileApproachingLine = starboardMarkWhileApproachingLine;

+ this.portMarkPosition = portMarkPosition;

+ this.starboardMarkPosition = starboardMarkPosition;

+ }

+

+ @Override

+ public TimePoint getTimePoint() {

+ return timePoint;

+ }

+

+ @Override

+ public Waypoint getWaypoint() {

+ return waypoint;

+ }

+

+ @Override

+ public Distance getLength() {

+ return length;

+ }

+

+ @Override

+ public Bearing getAngleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind() {

+ return angleDifferenceFromPortToStarboardWhenApproachingLineToTrueWind;

+ }

+

+ @Override

+ public NauticalSide getAdvantageousSideWhileApproachingLine() {

+ return advantageousSidewhileApproachingLine;

+ }

+

+ @Override

+ public Distance getAdvantage() {

+ return advantage;

+ }

+

+ @Override

+ public Mark getStarboardMarkWhileApproachingLine() {

+ return starboardMarkWhileApproachingLine;

+ }

+

+ @Override

+ public Mark getPortMarkWhileApproachingLine() {