4078143969

Build Type

push

github

Committed by Christopher Caldwell

Commit Message

bump version

Run Details

3593 of 8015 branches covered (44.83%)

Branch coverage included in aggregate %.

15102 of 20471 relevant lines covered (73.77%)

1564.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.97

/lib/features/user/featureRow.ts

import { FeatureTable } from './featureTable';
import { UserRow } from '../../user/userRow';
import { FeatureColumn } from './featureColumn';
import { GeoPackageGeometryData } from '../../geom/geoPackageGeometryData';
import { Geometry, GeometryEnvelope, GeometryType } from '@ngageoint/simple-features-js';
import { FeatureColumns } from './featureColumns';
import { GeoPackageException } from '../../geoPackageException';
import { ContentValues } from '../../user/contentValues';

/**
 * Feature Row containing the values from a single result set row
 */
export class FeatureRow extends UserRow<FeatureColumn, FeatureTable> {
  /**
   * Constructor
   * @param table feature table
   * @param columns columns
   * @param columnTypes column types
   * @param values values
   */
  constructor(table: FeatureTable, columns: FeatureColumns, columnTypes: number[], values: any[]);

  /**
   * Constructor to create an empty row
   * @param table
   */
  public constructor(table: FeatureTable);

  /**
   * Copy Constructor
   * @param featureRow feature row to copy
   */
  public constructor(featureRow: FeatureRow);

  /**
   * Constructor
   * @param args
   */
  public constructor(...args) {
    if (args.length === 1) {
      super(args[0]);
    } else if (args.length === 4) {
      super(args[0], args[1], args[2], args[3]);
    }
  }

  /**
   * @inheritDoc
   */
  public getColumns(): FeatureColumns {
    return super.getColumns() as FeatureColumns;
  }

  /**
   * Handles geometry columns
   */
  public setValueWithIndex(index: number, value: any): void {
    if (index == this.getGeometryColumnIndex() && (value instanceof Buffer || value instanceof Uint8Array)) {
      const buffer = Buffer.from(value);
      value = GeoPackageGeometryData.createWithBuffer(buffer);
    }
    super.setValueWithIndex(index, value);
  }

  /**
   * Handles geometry columns
   */
  public setValue(columnName: string, value: any): void {
    if (
      columnName.toLowerCase() === this.getGeometryColumnName().toLowerCase() &&
      (value instanceof Buffer || value instanceof Uint8Array)
    ) {
      const buffer = Buffer.from(value);
      value = GeoPackageGeometryData.createWithBuffer(buffer);
    }
    super.setValue(columnName, value);
  }

  /**
   * Handles geometry columns
   */
  protected copyValue(column: FeatureColumn, value: any): any {
    let copyValue = null;

    if (column.isGeometry() && value instanceof GeoPackageGeometryData) {
      const geometryData = value as GeoPackageGeometryData;
      try {
        const buffer = geometryData.toBuffer();
        copyValue = GeoPackageGeometryData.createWithBuffer(Buffer.from(buffer));
      } catch (e) {
        throw new GeoPackageException('Failed to copy Geometry Data bytes. column: ' + column.getName());
      }
    } else {
      copyValue = super.copyValue(column, value);
    }

    return copyValue;
  }

  /**
   * Handles geometry columns
   */
  protected columnToContentValue(contentValues: ContentValues, column: FeatureColumn, value: any): void {
    if (column.isGeometry()) {
      const columnName = column.getName();

      if (value instanceof GeoPackageGeometryData) {
        const geometryData = value as GeoPackageGeometryData;
        try {
          contentValues.put(columnName, geometryData.toBuffer());
        } catch (e) {
          throw new GeoPackageException('Failed to write Geometry Data bytes. column: ' + columnName);
        }
      } else if (value instanceof Buffer || value instanceof Uint8Array) {
        contentValues.put(columnName, value);
      } else {
        throw new GeoPackageException(
          'Unsupported update geometry column value type. column: ' + columnName + ', value type: ' + typeof value,
        );
      }
    } else {
      super.columnToContentValue(contentValues, column, value);
    }
  }

  /**
   * Get the geometry column index
   * @return geometry column index
   */
  public getGeometryColumnIndex(): number {
    return this.getColumns().getGeometryIndex();
  }

  /**
   * Get the geometry feature column
   * @return geometry feature column
   */
  public getGeometryColumn(): FeatureColumn {
    return this.getColumns().getGeometryColumn();
  }

  /**
   * Get the geometry column name
   * @return geometry column name
   */
  public getGeometryColumnName(): string {
    return this.getColumns().getGeometryColumnName();
  }

  /**
   * Get the geometry
   * @return geometry data
   */
  public getGeometry(): GeoPackageGeometryData {
    let geometryData: GeoPackageGeometryData = null;
    const value = this.getValueWithIndex(this.getGeometryColumnIndex());
    if (value != null) {
      geometryData = value as GeoPackageGeometryData;
    }
    return geometryData;
  }

  /**
   * Set the geometry data
   * @param geometryData geometry data
   */
  public setGeometry(geometryData: GeoPackageGeometryData): void {
    this.setValueWithIndex(this.getGeometryColumnIndex(), geometryData);
  }

  /**
   * Get the simple features geometry value
   * @return geometry
   */
  public getGeometryValue(): Geometry {
    const data = this.getGeometry();
    let geometry = null;
    if (data != null) {
      geometry = data.getGeometry();
    }
    return geometry;
  }

  /**
   * Get the simple features geometry type
   * @return geometry type
   */
  public getGeometryType(): GeometryType {
    const geometry = this.getGeometryValue();
    let geometryType = null;
    if (geometry != null) {
      geometryType = geometry.geometryType;
    }
    return geometryType;
  }

  /**
   * Get the geometry envelope
   * @return geometry envelope
   */
  public getGeometryEnvelope(): GeometryEnvelope {
    const data = this.getGeometry();
    let envelope = null;
    if (data != null) {
      envelope = data.getOrBuildEnvelope();
    }
    return envelope;
  }

  /**
   * Copy the row
   * @return row copy
   */
  public copy(): FeatureRow {
    return new FeatureRow(this);
  }
}

1	import { FeatureTable } from './featureTable';
2	import { UserRow } from '../../user/userRow';	1✔
3	import { FeatureColumn } from './featureColumn';
4	import { GeoPackageGeometryData } from '../../geom/geoPackageGeometryData';	1✔
5	import { Geometry, GeometryEnvelope, GeometryType } from '@ngageoint/simple-features-js';
6	import { FeatureColumns } from './featureColumns';
7	import { GeoPackageException } from '../../geoPackageException';	1✔
8	import { ContentValues } from '../../user/contentValues';
9
10	/**
11	* Feature Row containing the values from a single result set row
12	*/
13	export class FeatureRow extends UserRow<FeatureColumn, FeatureTable> {	1✔
14	/**
15	* Constructor
16	* @param table feature table
17	* @param columns columns
18	* @param columnTypes column types
19	* @param values values
20	*/
21	constructor(table: FeatureTable, columns: FeatureColumns, columnTypes: number[], values: any[]);
22
23	/**
24	* Constructor to create an empty row
25	* @param table
26	*/
27	public constructor(table: FeatureTable);
28
29	/**
30	* Copy Constructor
31	* @param featureRow feature row to copy
32	*/
33	public constructor(featureRow: FeatureRow);
34
35	/**
36	* Constructor
37	* @param args
38	*/
39	public constructor(...args) {	28,776✔
40	if (args.length === 1) {	4,947✔
41	super(args[0]);	302✔
42	} else if (args.length === 4) {	4,645!
43	super(args[0], args[1], args[2], args[3]);	4,645✔
44	}
45	}
46
47	/**
48	* @inheritDoc
49	*/
50	public getColumns(): FeatureColumns {	1✔
51	return super.getColumns() as FeatureColumns;	9,821✔
52	}
53
54	/**
55	* Handles geometry columns
56	*/
57	public setValueWithIndex(index: number, value: any): void {	1✔
58	if (index == this.getGeometryColumnIndex() && (value instanceof Buffer \|\| value instanceof Uint8Array)) {	1,135!
59	const buffer = Buffer.from(value);	×
60	value = GeoPackageGeometryData.createWithBuffer(buffer);	×
61	}
62	super.setValueWithIndex(index, value);	1,135✔
63	}
64
65	/**
66	* Handles geometry columns
67	*/
68	public setValue(columnName: string, value: any): void {	1✔
69	if (	847!
70	columnName.toLowerCase() === this.getGeometryColumnName().toLowerCase() &&	847!
71	(value instanceof Buffer \|\| value instanceof Uint8Array)
72	) {
73	const buffer = Buffer.from(value);	×
74	value = GeoPackageGeometryData.createWithBuffer(buffer);	×
75	}
76	super.setValue(columnName, value);	847✔
77	}
78
79	/**
80	* Handles geometry columns
81	*/
82	protected copyValue(column: FeatureColumn, value: any): any {	1✔
83	let copyValue = null;	×
84
85	if (column.isGeometry() && value instanceof GeoPackageGeometryData) {	×
86	const geometryData = value as GeoPackageGeometryData;	×
87	try {	×
88	const buffer = geometryData.toBuffer();	×
89	copyValue = GeoPackageGeometryData.createWithBuffer(Buffer.from(buffer));	×
90	} catch (e) {
91	throw new GeoPackageException('Failed to copy Geometry Data bytes. column: ' + column.getName());	×
92	}
93	} else {
94	copyValue = super.copyValue(column, value);	×
95	}
96
97	return copyValue;	×
98	}
99
100	/**
101	* Handles geometry columns
102	*/
103	protected columnToContentValue(contentValues: ContentValues, column: FeatureColumn, value: any): void {	1✔
104	if (column.isGeometry()) {	1,286✔
105	const columnName = column.getName();	289✔
106
107	if (value instanceof GeoPackageGeometryData) {	289!
108	const geometryData = value as GeoPackageGeometryData;	289✔
109	try {	289✔
110	contentValues.put(columnName, geometryData.toBuffer());	289✔
111	} catch (e) {
112	throw new GeoPackageException('Failed to write Geometry Data bytes. column: ' + columnName);	×
113	}
114	} else if (value instanceof Buffer \|\| value instanceof Uint8Array) {	×
115	contentValues.put(columnName, value);	×
116	} else {
117	throw new GeoPackageException(	×
118	'Unsupported update geometry column value type. column: ' + columnName + ', value type: ' + typeof value,
119	);
120	}
121	} else {
122	super.columnToContentValue(contentValues, column, value);	997✔
123	}
124	}
125
126	/**
127	* Get the geometry column index
128	* @return geometry column index
129	*/
130	public getGeometryColumnIndex(): number {	1✔
131	return this.getColumns().getGeometryIndex();	6,018✔
132	}
133
134	/**
135	* Get the geometry feature column
136	* @return geometry feature column
137	*/
138	public getGeometryColumn(): FeatureColumn {	1✔
139	return this.getColumns().getGeometryColumn();	×
140	}
141
142	/**
143	* Get the geometry column name
144	* @return geometry column name
145	*/
146	public getGeometryColumnName(): string {	1✔
147	return this.getColumns().getGeometryColumnName();	3,228✔
148	}
149
150	/**
151	* Get the geometry
152	* @return geometry data
153	*/
154	public getGeometry(): GeoPackageGeometryData {	1✔
155	let geometryData: GeoPackageGeometryData = null;	4,595✔
156	const value = this.getValueWithIndex(this.getGeometryColumnIndex());	4,595✔
157	if (value != null) {	4,595✔
158	geometryData = value as GeoPackageGeometryData;	4,561✔
159	}
160	return geometryData;	4,595✔
161	}
162
163	/**
164	* Set the geometry data
165	* @param geometryData geometry data
166	*/
167	public setGeometry(geometryData: GeoPackageGeometryData): void {	1✔
168	this.setValueWithIndex(this.getGeometryColumnIndex(), geometryData);	288✔
169	}
170
171	/**
172	* Get the simple features geometry value
173	* @return geometry
174	*/
175	public getGeometryValue(): Geometry {	1✔
176	const data = this.getGeometry();	23✔
177	let geometry = null;	23✔
178	if (data != null) {	23!
179	geometry = data.getGeometry();	23✔
180	}
181	return geometry;	23✔
182	}
183
184	/**
185	* Get the simple features geometry type
186	* @return geometry type
187	*/
188	public getGeometryType(): GeometryType {	1✔
189	const geometry = this.getGeometryValue();	23✔
190	let geometryType = null;	23✔
191	if (geometry != null) {	23!
192	geometryType = geometry.geometryType;	23✔
193	}
194	return geometryType;	23✔
195	}
196
197	/**
198	* Get the geometry envelope
199	* @return geometry envelope
200	*/
201	public getGeometryEnvelope(): GeometryEnvelope {	1✔
202	const data = this.getGeometry();	168✔
203	let envelope = null;	168✔
204	if (data != null) {	168!
205	envelope = data.getOrBuildEnvelope();	168✔
206	}
207	return envelope;	168✔
208	}
209
210	/**
211	* Copy the row
212	* @return row copy
213	*/
214	public copy(): FeatureRow {	1✔
215	return new FeatureRow(this);	×
216	}
217	}	1✔

ngageoint / geopackage-js / 4078143969

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous