1247 lines
31 KiB
TypeScript
1247 lines
31 KiB
TypeScript
/**
|
|
* Copyright(c) Live2D Inc. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by the Live2D Open Software license
|
|
* that can be found at https://www.live2d.com/eula/live2d-open-software-license-agreement_en.html.
|
|
*/
|
|
|
|
import { Live2DCubismFramework as csmstring } from '../type/csmstring';
|
|
import { Live2DCubismFramework as csmmap } from '../type/csmmap';
|
|
import { Live2DCubismFramework as csmvector } from '../type/csmvector';
|
|
import { CubismLogInfo } from './cubismdebug';
|
|
import { strtod } from '../live2dcubismframework';
|
|
import csmVector = csmvector.csmVector;
|
|
import csmVector_iterator = csmvector.iterator;
|
|
import csmMap = csmmap.csmMap;
|
|
import csmMap_iterator = csmmap.iterator;
|
|
import csmString = csmstring.csmString;
|
|
|
|
export namespace Live2DCubismFramework {
|
|
// StaticInitializeNotForClientCall()で初期化する
|
|
const CSM_JSON_ERROR_TYPE_MISMATCH = 'Error: type mismatch';
|
|
const CSM_JSON_ERROR_INDEX_OF_BOUNDS = 'Error: index out of bounds';
|
|
|
|
/**
|
|
* パースしたJSONエレメントの要素の基底クラス。
|
|
*/
|
|
export abstract class Value {
|
|
/**
|
|
* コンストラクタ
|
|
*/
|
|
public constructor() {}
|
|
|
|
/**
|
|
* 要素を文字列型で返す(csmString型)
|
|
*/
|
|
public abstract getString(defaultValue?: string, indent?: string): string;
|
|
|
|
/**
|
|
* 要素を文字列型で返す(string)
|
|
*/
|
|
public getRawString(defaultValue?: string, indent?: string): string {
|
|
return this.getString(defaultValue, indent);
|
|
}
|
|
|
|
/**
|
|
* 要素を数値型で返す(number)
|
|
*/
|
|
public toInt(defaultValue = 0): number {
|
|
return defaultValue;
|
|
}
|
|
|
|
/**
|
|
* 要素を数値型で返す(number)
|
|
*/
|
|
public toFloat(defaultValue = 0): number {
|
|
return defaultValue;
|
|
}
|
|
|
|
/**
|
|
* 要素を真偽値で返す(boolean)
|
|
*/
|
|
public toBoolean(defaultValue = false): boolean {
|
|
return defaultValue;
|
|
}
|
|
|
|
/**
|
|
* サイズを返す
|
|
*/
|
|
public getSize(): number {
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* 要素を配列で返す(Value[])
|
|
*/
|
|
public getArray(defaultValue: Value[] = null): Value[] {
|
|
return defaultValue;
|
|
}
|
|
|
|
/**
|
|
* 要素をコンテナで返す(array)
|
|
*/
|
|
public getVector(defaultValue?: csmVector<Value>): csmVector<Value> {
|
|
return defaultValue;
|
|
}
|
|
|
|
/**
|
|
* 要素をマップで返す(csmMap<csmString, Value>)
|
|
*/
|
|
public getMap(defaultValue?: csmMap<string, Value>): csmMap<string, Value> {
|
|
return defaultValue;
|
|
}
|
|
|
|
/**
|
|
* 添字演算子[index]
|
|
*/
|
|
public getValueByIndex(index: number): Value {
|
|
return Value.errorValue.setErrorNotForClientCall(
|
|
CSM_JSON_ERROR_TYPE_MISMATCH
|
|
);
|
|
}
|
|
|
|
/**
|
|
* 添字演算子[string | csmString]
|
|
*/
|
|
public getValueByString(s: string | csmString): Value {
|
|
return Value.nullValue.setErrorNotForClientCall(
|
|
CSM_JSON_ERROR_TYPE_MISMATCH
|
|
);
|
|
}
|
|
|
|
/**
|
|
* マップのキー一覧をコンテナで返す
|
|
*
|
|
* @return マップのキーの一覧
|
|
*/
|
|
public getKeys(): csmVector<string> {
|
|
return Value.s_dummyKeys;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類がエラー値ならtrue
|
|
*/
|
|
public isError(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類がnullならtrue
|
|
*/
|
|
public isNull(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が真偽値ならtrue
|
|
*/
|
|
public isBool(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が数値型ならtrue
|
|
*/
|
|
public isFloat(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が文字列ならtrue
|
|
*/
|
|
public isString(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が配列ならtrue
|
|
*/
|
|
public isArray(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類がマップ型ならtrue
|
|
*/
|
|
public isMap(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 引数の値と等しければtrue
|
|
*/
|
|
public equals(value: csmString): boolean;
|
|
public equals(value: string): boolean;
|
|
public equals(value: number): boolean;
|
|
public equals(value: boolean): boolean;
|
|
public equals(value: any): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの値が静的ならtrue、静的なら解放しない
|
|
*/
|
|
public isStatic(): boolean {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueにエラー値をセットする
|
|
*/
|
|
public setErrorNotForClientCall(errorStr: string): Value {
|
|
return JsonError.errorValue;
|
|
}
|
|
|
|
/**
|
|
* 初期化用メソッド
|
|
*/
|
|
public static staticInitializeNotForClientCall(): void {
|
|
JsonBoolean.trueValue = new JsonBoolean(true);
|
|
JsonBoolean.falseValue = new JsonBoolean(false);
|
|
|
|
JsonError.errorValue = new JsonError('ERROR', true);
|
|
this.nullValue = new JsonNullvalue();
|
|
|
|
Value.s_dummyKeys = new csmVector<string>();
|
|
}
|
|
|
|
/**
|
|
* リリース用メソッド
|
|
*/
|
|
public static staticReleaseNotForClientCall(): void {
|
|
JsonBoolean.trueValue = null;
|
|
JsonBoolean.falseValue = null;
|
|
JsonError.errorValue = null;
|
|
Value.nullValue = null;
|
|
Value.s_dummyKeys = null;
|
|
|
|
JsonBoolean.trueValue = null;
|
|
JsonBoolean.falseValue = null;
|
|
JsonError.errorValue = null;
|
|
Value.nullValue = null;
|
|
Value.s_dummyKeys = null;
|
|
}
|
|
|
|
protected _stringBuffer: string; // 文字列バッファ
|
|
|
|
private static s_dummyKeys: csmVector<string>; // ダミーキー
|
|
|
|
public static errorValue: Value; // 一時的な返り値として返すエラー。 CubismFramework::Disposeするまではdeleteしない
|
|
public static nullValue: Value; // 一時的な返り値として返すNULL。 CubismFramework::Disposeするまではdeleteしない
|
|
}
|
|
|
|
/**
|
|
* Ascii文字のみ対応した最小限の軽量JSONパーサ。
|
|
* 仕様はJSONのサブセットとなる。
|
|
* 設定ファイル(model3.json)などのロード用
|
|
*
|
|
* [未対応項目]
|
|
* ・日本語などの非ASCII文字
|
|
* ・eによる指数表現
|
|
*/
|
|
export class CubismJson {
|
|
/**
|
|
* コンストラクタ
|
|
*/
|
|
public constructor(buffer?: ArrayBuffer, length?: number) {
|
|
this._error = null;
|
|
this._lineCount = 0;
|
|
this._root = null;
|
|
|
|
if (buffer != undefined) {
|
|
this.parseBytes(buffer, length);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* バイトデータから直接ロードしてパースする
|
|
*
|
|
* @param buffer バッファ
|
|
* @param size バッファサイズ
|
|
* @return CubismJsonクラスのインスタンス。失敗したらNULL
|
|
*/
|
|
public static create(buffer: ArrayBuffer, size: number) {
|
|
const json = new CubismJson();
|
|
const succeeded: boolean = json.parseBytes(buffer, size);
|
|
|
|
if (!succeeded) {
|
|
CubismJson.delete(json);
|
|
return null;
|
|
} else {
|
|
return json;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONオブジェクトの解放処理
|
|
*
|
|
* @param instance CubismJsonクラスのインスタンス
|
|
*/
|
|
public static delete(instance: CubismJson) {
|
|
instance = null;
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONのルート要素を返す
|
|
*/
|
|
public getRoot(): Value {
|
|
return this._root;
|
|
}
|
|
|
|
/**
|
|
* UnicodeのバイナリをStringに変換
|
|
*
|
|
* @param buffer 変換するバイナリデータ
|
|
* @return 変換後の文字列
|
|
*/
|
|
public arrayBufferToString(buffer: ArrayBuffer): string {
|
|
const uint8Array: Uint8Array = new Uint8Array(buffer);
|
|
let str = '';
|
|
|
|
for (let i = 0, len: number = uint8Array.length; i < len; ++i) {
|
|
str += '%' + this.pad(uint8Array[i].toString(16));
|
|
}
|
|
|
|
str = decodeURIComponent(str);
|
|
return str;
|
|
}
|
|
|
|
/**
|
|
* エンコード、パディング
|
|
*/
|
|
private pad(n: string): string {
|
|
return n.length < 2 ? '0' + n : n;
|
|
}
|
|
|
|
/**
|
|
* JSONのパースを実行する
|
|
* @param buffer パース対象のデータバイト
|
|
* @param size データバイトのサイズ
|
|
* return true : 成功
|
|
* return false: 失敗
|
|
*/
|
|
public parseBytes(buffer: ArrayBuffer, size: number): boolean {
|
|
const endPos: number[] = new Array(1); // 参照渡しにするため配列
|
|
const decodeBuffer: string = this.arrayBufferToString(buffer);
|
|
this._root = this.parseValue(decodeBuffer, size, 0, endPos);
|
|
|
|
if (this._error) {
|
|
let strbuf = '\0';
|
|
strbuf = 'Json parse error : @line ' + (this._lineCount + 1) + '\n';
|
|
this._root = new JsonString(strbuf);
|
|
|
|
CubismLogInfo('{0}', this._root.getRawString());
|
|
return false;
|
|
} else if (this._root == null) {
|
|
this._root = new JsonError(new csmString(this._error), false); // rootは解放されるのでエラーオブジェクトを別途作成する
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* パース時のエラー値を返す
|
|
*/
|
|
public getParseError(): string {
|
|
return this._error;
|
|
}
|
|
|
|
/**
|
|
* ルート要素の次の要素がファイルの終端だったらtrueを返す
|
|
*/
|
|
public checkEndOfFile(): boolean {
|
|
return this._root.getArray()[1].equals('EOF');
|
|
}
|
|
|
|
/**
|
|
* JSONエレメントからValue(float,String,Value*,Array,null,true,false)をパースする
|
|
* エレメントの書式に応じて内部でParseString(), ParseObject(), ParseArray()を呼ぶ
|
|
*
|
|
* @param buffer JSONエレメントのバッファ
|
|
* @param length パースする長さ
|
|
* @param begin パースを開始する位置
|
|
* @param outEndPos パース終了時の位置
|
|
* @return パースから取得したValueオブジェクト
|
|
*/
|
|
protected parseValue(
|
|
buffer: string,
|
|
length: number,
|
|
begin: number,
|
|
outEndPos: number[]
|
|
) {
|
|
if (this._error) return null;
|
|
|
|
let o: Value = null;
|
|
let i: number = begin;
|
|
let f: number;
|
|
|
|
for (; i < length; i++) {
|
|
const c: string = buffer[i];
|
|
switch (c) {
|
|
case '-':
|
|
case '.':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9': {
|
|
const afterString: string[] = new Array(1); // 参照渡しにするため
|
|
f = strtod(buffer.slice(i), afterString);
|
|
outEndPos[0] = buffer.indexOf(afterString[0]);
|
|
return new JsonFloat(f);
|
|
}
|
|
case '"':
|
|
return new JsonString(
|
|
this.parseString(buffer, length, i + 1, outEndPos)
|
|
); // \"の次の文字から
|
|
case '[':
|
|
o = this.parseArray(buffer, length, i + 1, outEndPos);
|
|
return o;
|
|
case '{':
|
|
o = this.parseObject(buffer, length, i + 1, outEndPos);
|
|
return o;
|
|
case 'n': // null以外にない
|
|
if (i + 3 < length) {
|
|
o = new JsonNullvalue(); // 解放できるようにする
|
|
outEndPos[0] = i + 4;
|
|
} else {
|
|
this._error = 'parse null';
|
|
}
|
|
return o;
|
|
case 't': // true以外にない
|
|
if (i + 3 < length) {
|
|
o = JsonBoolean.trueValue;
|
|
outEndPos[0] = i + 4;
|
|
} else {
|
|
this._error = 'parse true';
|
|
}
|
|
return o;
|
|
case 'f': // false以外にない
|
|
if (i + 4 < length) {
|
|
o = JsonBoolean.falseValue;
|
|
outEndPos[0] = i + 5;
|
|
} else {
|
|
this._error = "illegal ',' position";
|
|
}
|
|
return o;
|
|
case ',': // Array separator
|
|
this._error = "illegal ',' position";
|
|
return null;
|
|
case ']': // 不正な｝だがスキップする。配列の最後に不要な , があると思われる
|
|
outEndPos[0] = i; // 同じ文字を再処理
|
|
return null;
|
|
case '\n':
|
|
this._lineCount++;
|
|
case ' ':
|
|
case '\t':
|
|
case '\r':
|
|
default:
|
|
// スキップ
|
|
break;
|
|
}
|
|
}
|
|
|
|
this._error = 'illegal end of value';
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 次の「"」までの文字列をパースする。
|
|
*
|
|
* @param string -> パース対象の文字列
|
|
* @param length -> パースする長さ
|
|
* @param begin -> パースを開始する位置
|
|
* @param outEndPos -> パース終了時の位置
|
|
* @return パースした文F字列要素
|
|
*/
|
|
protected parseString(
|
|
string: string,
|
|
length: number,
|
|
begin: number,
|
|
outEndPos: number[]
|
|
): string {
|
|
if (this._error) return null;
|
|
|
|
let i = begin;
|
|
let c: string, c2: string;
|
|
const ret: csmString = new csmString('');
|
|
let bufStart: number = begin; // sbufに登録されていない文字の開始位置
|
|
|
|
for (; i < length; i++) {
|
|
c = string[i];
|
|
|
|
switch (c) {
|
|
case '"': {
|
|
// 終端の”、エスケープ文字は別に処理されるのでここに来ない
|
|
outEndPos[0] = i + 1; // ”の次の文字
|
|
ret.append(string.slice(bufStart), i - bufStart); // 前の文字までを登録する
|
|
return ret.s;
|
|
}
|
|
case '//': {
|
|
// エスケープの場合
|
|
i++; // ２文字をセットで扱う
|
|
|
|
if (i - 1 > bufStart) {
|
|
ret.append(string.slice(bufStart), i - bufStart); // 前の文字までを登録する
|
|
}
|
|
bufStart = i + 1; // エスケープ（２文字)の次の文字から
|
|
|
|
if (i < length) {
|
|
c2 = string[i];
|
|
|
|
switch (c2) {
|
|
case '\\':
|
|
ret.expansion(1, '\\');
|
|
break;
|
|
case '"':
|
|
ret.expansion(1, '"');
|
|
break;
|
|
case '/':
|
|
ret.expansion(1, '/');
|
|
break;
|
|
case 'b':
|
|
ret.expansion(1, '\b');
|
|
break;
|
|
case 'f':
|
|
ret.expansion(1, '\f');
|
|
break;
|
|
case 'n':
|
|
ret.expansion(1, '\n');
|
|
break;
|
|
case 'r':
|
|
ret.expansion(1, '\r');
|
|
break;
|
|
case 't':
|
|
ret.expansion(1, '\t');
|
|
break;
|
|
case 'u':
|
|
this._error = 'parse string/unicord escape not supported';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else {
|
|
this._error = 'parse string/escape error';
|
|
}
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
this._error = 'parse string/illegal end';
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* JSONのオブジェクトエレメントをパースしてValueオブジェクトを返す
|
|
*
|
|
* @param buffer JSONエレメントのバッファ
|
|
* @param length パースする長さ
|
|
* @param begin パースを開始する位置
|
|
* @param outEndPos パース終了時の位置
|
|
* @return パースから取得したValueオブジェクト
|
|
*/
|
|
protected parseObject(
|
|
buffer: string,
|
|
length: number,
|
|
begin: number,
|
|
outEndPos: number[]
|
|
): Value {
|
|
if (this._error) return null;
|
|
const ret: JsonMap = new JsonMap();
|
|
|
|
// Key: Value
|
|
let key = '';
|
|
let i: number = begin;
|
|
let c = '';
|
|
const localRetEndPos2: number[] = Array(1);
|
|
let ok = false;
|
|
|
|
// , が続く限りループ
|
|
for (; i < length; i++) {
|
|
FOR_LOOP: for (; i < length; i++) {
|
|
c = buffer[i];
|
|
|
|
switch (c) {
|
|
case '"':
|
|
key = this.parseString(buffer, length, i + 1, localRetEndPos2);
|
|
if (this._error) {
|
|
return null;
|
|
}
|
|
|
|
i = localRetEndPos2[0];
|
|
ok = true;
|
|
break FOR_LOOP; //-- loopから出る
|
|
case '}': // 閉じカッコ
|
|
outEndPos[0] = i + 1;
|
|
return ret; // 空
|
|
case ':':
|
|
this._error = "illegal ':' position";
|
|
break;
|
|
case '\n':
|
|
this._lineCount++;
|
|
default:
|
|
break; // スキップする文字
|
|
}
|
|
}
|
|
if (!ok) {
|
|
this._error = 'key not found';
|
|
return null;
|
|
}
|
|
|
|
ok = false;
|
|
|
|
// : をチェック
|
|
FOR_LOOP2: for (; i < length; i++) {
|
|
c = buffer[i];
|
|
|
|
switch (c) {
|
|
case ':':
|
|
ok = true;
|
|
i++;
|
|
break FOR_LOOP2;
|
|
case '}':
|
|
this._error = "illegal '}' position";
|
|
break;
|
|
case '\n':
|
|
this._lineCount++;
|
|
// case ' ': case '\t' : case '\r':
|
|
default:
|
|
break; // スキップする文字
|
|
}
|
|
}
|
|
|
|
if (!ok) {
|
|
this._error = "':' not found";
|
|
return null;
|
|
}
|
|
|
|
// 値をチェック
|
|
const value: Value = this.parseValue(
|
|
buffer,
|
|
length,
|
|
i,
|
|
localRetEndPos2
|
|
);
|
|
if (this._error) {
|
|
return null;
|
|
}
|
|
|
|
i = localRetEndPos2[0];
|
|
|
|
// ret.put(key, value);
|
|
ret.put(key, value);
|
|
|
|
FOR_LOOP3: for (; i < length; i++) {
|
|
c = buffer[i];
|
|
|
|
switch (c) {
|
|
case ',':
|
|
break FOR_LOOP3;
|
|
case '}':
|
|
outEndPos[0] = i + 1;
|
|
return ret; // 正常終了
|
|
case '\n':
|
|
this._lineCount++;
|
|
default:
|
|
break; // スキップ
|
|
}
|
|
}
|
|
}
|
|
|
|
this._error = 'illegal end of perseObject';
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 次の「"」までの文字列をパースする。
|
|
* @param buffer JSONエレメントのバッファ
|
|
* @param length パースする長さ
|
|
* @param begin パースを開始する位置
|
|
* @param outEndPos パース終了時の位置
|
|
* @return パースから取得したValueオブジェクト
|
|
*/
|
|
protected parseArray(
|
|
buffer: string,
|
|
length: number,
|
|
begin: number,
|
|
outEndPos: number[]
|
|
): Value {
|
|
if (this._error) return null;
|
|
let ret: JsonArray = new JsonArray();
|
|
|
|
// key : value
|
|
let i: number = begin;
|
|
let c: string;
|
|
const localRetEndpos2: number[] = new Array(1);
|
|
|
|
// , が続く限りループ
|
|
for (; i < length; i++) {
|
|
// : をチェック
|
|
const value: Value = this.parseValue(
|
|
buffer,
|
|
length,
|
|
i,
|
|
localRetEndpos2
|
|
);
|
|
|
|
if (this._error) {
|
|
return null;
|
|
}
|
|
i = localRetEndpos2[0];
|
|
|
|
if (value) {
|
|
ret.add(value);
|
|
}
|
|
|
|
// FOR_LOOP3:
|
|
// boolean breakflag = false;
|
|
FOR_LOOP: for (; i < length; i++) {
|
|
c = buffer[i];
|
|
|
|
switch (c) {
|
|
case ',':
|
|
// breakflag = true;
|
|
// break; // 次のKEY, VAlUEへ
|
|
break FOR_LOOP;
|
|
case ']':
|
|
outEndPos[0] = i + 1;
|
|
return ret; // 終了
|
|
case '\n':
|
|
++this._lineCount;
|
|
//case ' ': case '\t': case '\r':
|
|
default:
|
|
break; // スキップ
|
|
}
|
|
}
|
|
}
|
|
|
|
ret = void 0;
|
|
this._error = 'illegal end of parseObject';
|
|
return null;
|
|
}
|
|
|
|
_error: string; // パース時のエラー
|
|
_lineCount: number; // エラー報告に用いる行数カウント
|
|
_root: Value; // パースされたルート要素
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONの要素をfloat値として扱う
|
|
*/
|
|
export class JsonFloat extends Value {
|
|
/**
|
|
* コンストラクタ
|
|
*/
|
|
constructor(v: number) {
|
|
super();
|
|
|
|
this._value = v;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が数値型ならtrue
|
|
*/
|
|
public isFloat(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 要素を文字列で返す(csmString型)
|
|
*/
|
|
public getString(defaultValue: string, indent: string): string {
|
|
const strbuf = '\0';
|
|
this._value = parseFloat(strbuf);
|
|
this._stringBuffer = strbuf;
|
|
|
|
return this._stringBuffer;
|
|
}
|
|
|
|
/**
|
|
* 要素を数値型で返す(number)
|
|
*/
|
|
public toInt(defaultValue = 0): number {
|
|
return parseInt(this._value.toString());
|
|
}
|
|
|
|
/**
|
|
* 要素を数値型で返す(number)
|
|
*/
|
|
public toFloat(defaultValue = 0.0): number {
|
|
return this._value;
|
|
}
|
|
|
|
/**
|
|
* 引数の値と等しければtrue
|
|
*/
|
|
public equals(value: csmString): boolean;
|
|
public equals(value: string): boolean;
|
|
public equals(value: number): boolean;
|
|
public equals(value: boolean): boolean;
|
|
public equals(value: any): boolean {
|
|
if ('number' === typeof value) {
|
|
// int
|
|
if (Math.round(value)) {
|
|
return false;
|
|
}
|
|
// float
|
|
else {
|
|
return value == this._value;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private _value: number; // JSON要素の値
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONの要素を真偽値として扱う
|
|
*/
|
|
export class JsonBoolean extends Value {
|
|
/**
|
|
* Valueの種類が真偽値ならtrue
|
|
*/
|
|
public isBool(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 要素を真偽値で返す(boolean)
|
|
*/
|
|
public toBoolean(defaultValue = false): boolean {
|
|
return this._boolValue;
|
|
}
|
|
|
|
/**
|
|
* 要素を文字列で返す(csmString型)
|
|
*/
|
|
public getString(defaultValue: string, indent: string): string {
|
|
this._stringBuffer = this._boolValue ? 'true' : 'false';
|
|
|
|
return this._stringBuffer;
|
|
}
|
|
|
|
/**
|
|
* 引数の値と等しければtrue
|
|
*/
|
|
public equals(value: csmString): boolean;
|
|
public equals(value: string): boolean;
|
|
public equals(value: number): boolean;
|
|
public equals(value: boolean): boolean;
|
|
public equals(value: any): boolean {
|
|
if ('boolean' === typeof value) {
|
|
return value == this._boolValue;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Valueの値が静的ならtrue, 静的なら解放しない
|
|
*/
|
|
public isStatic(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 引数付きコンストラクタ
|
|
*/
|
|
public constructor(v: boolean) {
|
|
super();
|
|
|
|
this._boolValue = v;
|
|
}
|
|
|
|
static trueValue: JsonBoolean; // true
|
|
static falseValue: JsonBoolean; // false
|
|
|
|
private _boolValue: boolean; // JSON要素の値
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONの要素を文字列として扱う
|
|
*/
|
|
export class JsonString extends Value {
|
|
/**
|
|
* 引数付きコンストラクタ
|
|
*/
|
|
public constructor(s: string);
|
|
public constructor(s: csmString);
|
|
public constructor(s: any) {
|
|
super();
|
|
|
|
if ('string' === typeof s) {
|
|
this._stringBuffer = s;
|
|
}
|
|
|
|
if (s instanceof csmString) {
|
|
this._stringBuffer = s.s;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が文字列ならtrue
|
|
*/
|
|
public isString(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 要素を文字列で返す(csmString型)
|
|
*/
|
|
public getString(defaultValue: string, indent: string): string {
|
|
return this._stringBuffer;
|
|
}
|
|
|
|
/**
|
|
* 引数の値と等しければtrue
|
|
*/
|
|
public equals(value: csmString): boolean;
|
|
public equals(value: string): boolean;
|
|
public equals(value: number): boolean;
|
|
public equals(value: boolean): boolean;
|
|
public equals(value: any): boolean {
|
|
if ('string' === typeof value) {
|
|
return this._stringBuffer == value;
|
|
}
|
|
|
|
if (value instanceof csmString) {
|
|
return this._stringBuffer == value.s;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* JSONパース時のエラー結果。文字列型のようにふるまう
|
|
*/
|
|
export class JsonError extends JsonString {
|
|
/**
|
|
* Valueの値が静的ならtrue、静的なら解放しない
|
|
*/
|
|
public isStatic(): boolean {
|
|
return this._isStatic;
|
|
}
|
|
|
|
/**
|
|
* エラー情報をセットする
|
|
*/
|
|
public setErrorNotForClientCall(s: string): Value {
|
|
this._stringBuffer = s;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* 引数付きコンストラクタ
|
|
*/
|
|
public constructor(s: csmString | string, isStatic: boolean) {
|
|
if ('string' === typeof s) {
|
|
super(s);
|
|
} else {
|
|
super(s);
|
|
}
|
|
this._isStatic = isStatic;
|
|
}
|
|
|
|
/**
|
|
* Valueの種類がエラー値ならtrue
|
|
*/
|
|
public isError(): boolean {
|
|
return true;
|
|
}
|
|
|
|
protected _isStatic: boolean; // 静的なValueかどうか
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONの要素をNULL値として持つ
|
|
*/
|
|
export class JsonNullvalue extends Value {
|
|
/**
|
|
* Valueの種類がNULL値ならtrue
|
|
*/
|
|
public isNull(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 要素を文字列で返す(csmString型)
|
|
*/
|
|
public getString(defaultValue: string, indent: string): string {
|
|
return this._stringBuffer;
|
|
}
|
|
|
|
/**
|
|
* Valueの値が静的ならtrue, 静的なら解放しない
|
|
*/
|
|
public isStatic(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* コンストラクタ
|
|
*/
|
|
public constructor() {
|
|
super();
|
|
|
|
this._stringBuffer = 'NullValue';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONの要素を配列として持つ
|
|
*/
|
|
export class JsonArray extends Value {
|
|
/**
|
|
* コンストラクタ
|
|
*/
|
|
public constructor() {
|
|
super();
|
|
this._array = new csmVector<Value>();
|
|
}
|
|
|
|
/**
|
|
* デストラクタ相当の処理
|
|
*/
|
|
public release(): void {
|
|
for (
|
|
let ite: csmVector_iterator<Value> = this._array.begin();
|
|
ite.notEqual(this._array.end());
|
|
ite.preIncrement()
|
|
) {
|
|
let v: Value = ite.ptr();
|
|
|
|
if (v && !v.isStatic()) {
|
|
v = void 0;
|
|
v = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Valueの種類が配列ならtrue
|
|
*/
|
|
public isArray(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 添字演算子[index]
|
|
*/
|
|
public getValueByIndex(index: number): Value {
|
|
if (index < 0 || this._array.getSize() <= index) {
|
|
return Value.errorValue.setErrorNotForClientCall(
|
|
CSM_JSON_ERROR_INDEX_OF_BOUNDS
|
|
);
|
|
}
|
|
|
|
const v: Value = this._array.at(index);
|
|
|
|
if (v == null) {
|
|
return Value.nullValue;
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* 添字演算子[string | csmString]
|
|
*/
|
|
public getValueByString(s: string | csmString): Value {
|
|
return Value.errorValue.setErrorNotForClientCall(
|
|
CSM_JSON_ERROR_TYPE_MISMATCH
|
|
);
|
|
}
|
|
|
|
/**
|
|
* 要素を文字列で返す(csmString型)
|
|
*/
|
|
public getString(defaultValue: string, indent: string): string {
|
|
const stringBuffer: string = indent + '[\n';
|
|
|
|
for (
|
|
let ite: csmVector_iterator<Value> = this._array.begin();
|
|
ite.notEqual(this._array.end());
|
|
ite.increment()
|
|
) {
|
|
const v: Value = ite.ptr();
|
|
this._stringBuffer += indent + '' + v.getString(indent + ' ') + '\n';
|
|
}
|
|
|
|
this._stringBuffer = stringBuffer + indent + ']\n';
|
|
|
|
return this._stringBuffer;
|
|
}
|
|
|
|
/**
|
|
* 配列要素を追加する
|
|
* @param v 追加する要素
|
|
*/
|
|
public add(v: Value): void {
|
|
this._array.pushBack(v);
|
|
}
|
|
|
|
/**
|
|
* 要素をコンテナで返す(csmVector<Value>)
|
|
*/
|
|
public getVector(defaultValue: csmVector<Value> = null): csmVector<Value> {
|
|
return this._array;
|
|
}
|
|
|
|
/**
|
|
* 要素の数を返す
|
|
*/
|
|
public getSize(): number {
|
|
return this._array.getSize();
|
|
}
|
|
|
|
private _array: csmVector<Value>; // JSON要素の値
|
|
}
|
|
|
|
/**
|
|
* パースしたJSONの要素をマップとして持つ
|
|
*/
|
|
export class JsonMap extends Value {
|
|
/**
|
|
* コンストラクタ
|
|
*/
|
|
public constructor() {
|
|
super();
|
|
this._map = new csmMap<string, Value>();
|
|
}
|
|
|
|
/**
|
|
* デストラクタ相当の処理
|
|
*/
|
|
public release(): void {
|
|
const ite: csmMap_iterator<string, Value> = this._map.begin();
|
|
|
|
while (ite.notEqual(this._map.end())) {
|
|
let v: Value = ite.ptr().second;
|
|
|
|
if (v && !v.isStatic()) {
|
|
v = void 0;
|
|
v = null;
|
|
}
|
|
|
|
ite.preIncrement();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Valueの値がMap型ならtrue
|
|
*/
|
|
public isMap(): boolean {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 添字演算子[string | csmString]
|
|
*/
|
|
public getValueByString(s: string | csmString): Value {
|
|
if (s instanceof csmString) {
|
|
const ret: Value = this._map.getValue(s.s);
|
|
if (ret == null) {
|
|
return Value.nullValue;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
for (
|
|
let iter: csmMap_iterator<string, Value> = this._map.begin();
|
|
iter.notEqual(this._map.end());
|
|
iter.preIncrement()
|
|
) {
|
|
if (iter.ptr().first == s) {
|
|
if (iter.ptr().second == null) {
|
|
return Value.nullValue;
|
|
}
|
|
return iter.ptr().second;
|
|
}
|
|
}
|
|
|
|
return Value.nullValue;
|
|
}
|
|
|
|
/**
|
|
* 添字演算子[index]
|
|
*/
|
|
public getValueByIndex(index: number): Value {
|
|
return Value.errorValue.setErrorNotForClientCall(
|
|
CSM_JSON_ERROR_TYPE_MISMATCH
|
|
);
|
|
}
|
|
|
|
/**
|
|
* 要素を文字列で返す(csmString型)
|
|
*/
|
|
public getString(defaultValue: string, indent: string) {
|
|
this._stringBuffer = indent + '{\n';
|
|
|
|
const ite: csmMap_iterator<string, Value> = this._map.begin();
|
|
while (ite.notEqual(this._map.end())) {
|
|
const key = ite.ptr().first;
|
|
const v: Value = ite.ptr().second;
|
|
|
|
this._stringBuffer +=
|
|
indent + ' ' + key + ' : ' + v.getString(indent + ' ') + ' \n';
|
|
ite.preIncrement();
|
|
}
|
|
|
|
this._stringBuffer += indent + '}\n';
|
|
|
|
return this._stringBuffer;
|
|
}
|
|
|
|
/**
|
|
* 要素をMap型で返す
|
|
*/
|
|
public getMap(defaultValue?: csmMap<string, Value>): csmMap<string, Value> {
|
|
return this._map;
|
|
}
|
|
|
|
/**
|
|
* Mapに要素を追加する
|
|
*/
|
|
public put(key: string, v: Value): void {
|
|
this._map.setValue(key, v);
|
|
}
|
|
|
|
/**
|
|
* Mapからキーのリストを取得する
|
|
*/
|
|
public getKeys(): csmVector<string> {
|
|
if (!this._keys) {
|
|
this._keys = new csmVector<string>();
|
|
|
|
const ite: csmMap_iterator<string, Value> = this._map.begin();
|
|
|
|
while (ite.notEqual(this._map.end())) {
|
|
const key: string = ite.ptr().first;
|
|
this._keys.pushBack(key);
|
|
ite.preIncrement();
|
|
}
|
|
}
|
|
return this._keys;
|
|
}
|
|
|
|
/**
|
|
* Mapの要素数を取得する
|
|
*/
|
|
public getSize(): number {
|
|
return this._keys.getSize();
|
|
}
|
|
|
|
private _map: csmMap<string, Value>; // JSON要素の値
|
|
private _keys: csmVector<string>; // JSON要素の値
|
|
}
|
|
}
|