@peerbit/shared-log 9.0.6 → 9.0.7

package/src/role.ts

@@ -1,16 +1,23 @@
-/* import { field, variant, vec } from "@dao-xyz/borsh"; */
+/**
+ * @deprecated
+ * Code below is deprecated and will be removed in the future.
+ * Roles have been replaces with just replication segments.
+ */
+import { field, variant, vec } from "@dao-xyz/borsh";
+
+export const SEGMENT_COORDINATE_SCALE = 4294967295;
 
-/* export const overlaps = (x1: number, x2: number, y1: number, y2: number) => {
+export const overlaps = (x1: number, x2: number, y1: number, y2: number) => {
 	if (x1 <= y2 && y1 <= x2) {
 		return true;
 	}
 	return false;
-}; */
+};
 
-/* export abstract class Role {
-	abstract equals(other: Role): boolean; 
+export abstract class Role {
+	abstract equals(other: Role): boolean;
 }
- 
+
 export const NO_TYPE_VARIANT = new Uint8Array([0]);
 
 @variant(0)
@@ -29,83 +36,80 @@ export class Observer extends Role {
 	}
 }
 
-export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);*/
-
-export const SEGMENT_COORDINATE_SCALE = 4294967295;
-/* export class ReplicationSegment {
+export const REPLICATOR_TYPE_VARIANT = new Uint8Array([2]);
 
+export class RoleReplicationSegment {
 	@field({ type: "u64" })
 	timestamp: bigint;
 
 	@field({ type: "u32" })
-	start: number;
-
-	@field({ type: 'u32' })
-	end: number;
-
+	private factorNominator: number;
 
+	@field({ type: "u32" })
+	private offsetNominator: number;
 
 	constructor(properties: {
-		start: number;
-		end: number;
-		timestamp: bigint;
+		factor: number;
+		offset: number;
+		timestamp?: bigint;
 	}) {
-		const { start, end, timestamp } = properties;
+		const { factor, timestamp, offset } = properties;
+		if (factor > 1 || factor < 0) {
+			throw new Error("Expecting factor to be between 0 and 1, got: " + factor);
+		}
 
-		if (start > end) {
-			throw new Error("Range 'start' needs to be lower or equal to 'end'")
+		this.timestamp = timestamp ?? BigInt(+new Date());
+		this.factorNominator = Math.round(SEGMENT_COORDINATE_SCALE * factor);
+
+		if (offset > 1 || offset < 0) {
+			throw new Error("Expecting offset to be between 0 and 1, got: " + offset);
 		}
-		this.start = Math.round(start * SEGMENT_COORDINATE_SCALE);
-		this.end = Math.round(end * SEGMENT_COORDINATE_SCALE);
-		this.timestamp = timestamp
+		this.offsetNominator = Math.round(SEGMENT_COORDINATE_SCALE * offset);
 	}
 
+	get factor(): number {
+		return this.factorNominator / SEGMENT_COORDINATE_SCALE;
+	}
 
-
+	get offset(): number {
+		return this.offsetNominator / SEGMENT_COORDINATE_SCALE;
+	}
 }
- */
-
-/* abstract class Capacity { }
 
 @variant(2)
 export class Replicator extends Role {
+	@field({ type: vec(RoleReplicationSegment) })
+	segments: RoleReplicationSegment[];
 
-	@field({ type: vec(Capacity) })
-	capacity: Capacity[];
-
-	constructor(properties?: { capacity: Capacity[] }) {
+	constructor(properties: {
+		factor: number;
+		timestamp?: bigint;
+		offset: number;
+	}) {
 		super();
-		this.capacity = properties?.capacity || [];
-	} */
-
-/* constructor(properties: {
-	timestamp?: bigint;
-	factor: number;
-	offset: number;
-}) {
-	super();
-	let timestamp = properties.timestamp || BigInt(+new Date);
-	let ranges = getSegmentsFromOffsetAndRange(properties.offset, properties.factor);
-	this.segments = ranges.map(x => new ReplicationSegment({ start: x[0], end: x[1], timestamp }));
-}
-*/
-/* get factor(): number {
-	return this.segments[0]!.factor;
-}
+		const segment: RoleReplicationSegment = new RoleReplicationSegment(
+			properties,
+		);
+		this.segments = [segment];
+	}
 
-get offset(): number {
-	return this.segments[0]!.offset;
-}
+	get factor(): number {
+		return this.segments[0]!.factor;
+	}
 
-get timestamp(): bigint {
-	return this.segments[0]!.timestamp;
-} */
-
-/* equals(other: Role) {
-	return (
-		other instanceof Replicator &&
-		other.factor === this.factor &&
-		other.offset === this.offset
-	);
-} */
-/* } */
+	get offset(): number {
+		return this.segments[0]!.offset;
+	}
+
+	get timestamp(): bigint {
+		return this.segments[0]!.timestamp;
+	}
+
+	equals(other: Role) {
+		return (
+			other instanceof Replicator &&
+			other.factor === this.factor &&
+			other.offset === this.offset
+		);
+	}
+}