main.io.github.moonlightsuite.moonlight.offline.signal.Segment Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of moonlight-engine Show documentation
Show all versions of moonlight-engine Show documentation
MoonLight is a light-weight Java-tool for monitoring temporal, spatial and spatio-temporal properties of distributed complex systems, such as Cyber-Physical Systems and Collective Adaptive Systems.
The newest version!
/*
* MoonLight: a light-weight framework for runtime monitoring
* Copyright (C) 2018-2021
*
* See the NOTICE file distributed with this work for additional information
* regarding copyright ownership.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.github.moonlightsuite.moonlight.offline.signal;
import io.github.moonlightsuite.moonlight.core.signal.Sample;
/**
* @author loreti
*
*/
public class Segment implements Sample {
private double time;
private T value;
private Segment next;
private Segment previous;
private double end = Double.NaN;
public Segment( double time , T value ) {
this.time = time;
this.value = value;
this.previous = null;
}
private Segment(Segment previous, double time, T value) {
this.previous = previous;
this.time = time;
this.value = value;
this.end = time;
}
public Double getStart() {
return time;
}
public T getValue() {
return value;
}
public Segment getNext() {
return next;
}
public Segment getPrevious() {
return previous;
}
public void setNext( Segment next ) {
this.next = next;
}
public T getValueAt(double t) {
Segment selected = jump( t );
return (selected==null?null:selected.value);
}
public Segment jump(double t ) {
if (t Segment forwardTo(Segment segment, double t) {
Segment cursor = segment;
while (cursor != null) {
if (cursor.contains(t)) {
return cursor;
}
cursor = cursor.next;
}
return null;
}
public static Segment backwardTo(Segment segment, double t) {
Segment cursor = segment;
while (cursor != null) {
if (cursor.contains(t)) {
return cursor;
}
cursor = cursor.previous;
}
return null;
}
public boolean contains(double t) {
return (time==t)||((time<=t)&&((Double.isFinite(end)&&(t<=end))||(next!=null)&&(t double getTime(Segment s) {
return (s == null ? Double.NaN : s.getStart());
}
public Segment addAfter(double time, T value) {
if (this.time > time) {
throw new IllegalArgumentException("Trying to add time: " + time +
". Expected > " + this.time);
} else if (this.time == time) {
this.value = value;
return this;
} else {
if (!this.value.equals(value)) {
this.next = new Segment<>(this, time, value);
this.end = Double.NaN;
return this.next;
} else {
this.end = time;
this.next = null;
return this;
}
}
}
public Segment addBefore(double time, T value) {
if (this.time<=time) {
throw new IllegalArgumentException(); //TODO: Add error message!
}
if (!this.value.equals(value)) {
this.previous = new Segment<>(this, time, value);
this.previous.next = this;
return this.previous;
} else {
if (isAPoint()) {
this.end = this.time;
}
this.time = time;
return this;
}
}
public Double getEnd() {
return getSegmentEnd();
}
public double getSegmentEnd() {
if (next == null) {
if (Double.isNaN(this.end)) {
return this.time;
}
return this.end;
}
return next.getStart();
}
public double getPreviousTime() {
if (previous == null) {
return Double.NaN;
}
return previous.getStart();
}
@Override
public String toString() {
return (previous!=null?"<":"[")+time+":"+value+(next!=null?">":"]");
}
public void endAt(double end) {
if (end splitAt(double time) {
if (this.time>=time) {
throw new IllegalArgumentException();
}
this.time = time;
return this;
}
public boolean isTheEnd(double time) {
return (this.end == time);
}
public boolean doEndAt(double t) {
return (this.end==t);
}
public boolean isRightClosed() {
return !Double.isNaN(this.end);
}
public double nextTimeAfter(double time) {
if (this.next!=null) {
return next.getStart();
} else {
if (time