From: woojin Date: Wed, 11 Dec 2013 11:56:35 +0000 (+0900) Subject: [Title] take emulator snapshot using emulator ECS server X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=01c0e3d79f546b471090844deacdbbe65f4bb9e4;p=sdk%2Ftools%2Fdynamic-analyzer.git [Title] take emulator snapshot using emulator ECS server [Desc.] get snapshot via emulator ECS server when available [Issue] --- diff --git a/org.tizen.dynamicanalyzer/.classpath b/org.tizen.dynamicanalyzer/.classpath index 98ee040..e954630 100644 --- a/org.tizen.dynamicanalyzer/.classpath +++ b/org.tizen.dynamicanalyzer/.classpath @@ -9,5 +9,7 @@ + + diff --git a/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF b/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF index 137150e..8a36043 100644 --- a/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF +++ b/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF @@ -16,7 +16,9 @@ Bundle-ClassPath: ., lib/org.eclipse.cdt.debug.edc_2.0.0.201109151658.jar, lib/org.eclipse.cdt.dsf_2.2.0.201109151620.jar, lib/org.eclipse.nebula.widgets.grid_1.0.0.jar, - lib/hsqldb.jar + lib/hsqldb.jar, + lib/json-simple-1.1.1.jar, + lib/protobuf.jar Export-Package: org.tizen.dynamicanalyzer.common, org.tizen.dynamicanalyzer.communicator, org.tizen.dynamicanalyzer.error, diff --git a/org.tizen.dynamicanalyzer/build.properties b/org.tizen.dynamicanalyzer/build.properties index 72085fc..648b644 100644 --- a/org.tizen.dynamicanalyzer/build.properties +++ b/org.tizen.dynamicanalyzer/build.properties @@ -6,12 +6,13 @@ bin.includes = .,\ META-INF/,\ theme/,\ plugin.properties,\ - lib/,\ build.properties,\ Link/,\ .settings/,\ .project,\ .classpath,\ lib/org.eclipse.nebula.widgets.grid_1.0.0.jar,\ - lib/hsqldb.jar + lib/hsqldb.jar,\ + lib/json-simple-1.1.1.jar,\ + lib/protobuf.jar diff --git a/org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar b/org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar new file mode 100644 index 0000000..66347a6 Binary files /dev/null and b/org.tizen.dynamicanalyzer/lib/json-simple-1.1.1.jar differ diff --git a/org.tizen.dynamicanalyzer/lib/protobuf.jar b/org.tizen.dynamicanalyzer/lib/protobuf.jar new file mode 100644 index 0000000..be6164f Binary files /dev/null and b/org.tizen.dynamicanalyzer/lib/protobuf.jar differ diff --git a/org.tizen.dynamicanalyzer/src/msg/ecs.proto b/org.tizen.dynamicanalyzer/src/msg/ecs.proto new file mode 100644 index 0000000..697acd9 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/msg/ecs.proto @@ -0,0 +1,130 @@ +import "ecs_ids.proto"; + +package ECS; + +option java_package = "org.tizen.dynamicanalyzer.ui.info.snapshot.ecs"; + +// ======= Messages ======= + +message CheckVersionReq { + required string version_str = 1; +} + +message CheckVersionAns { + required int32 errcode = 1; + required string version_str = 2; +} + +message KeepAliveReq { + optional string time_str = 1; +} + +message KeepAliveAns { + optional string time_str = 1; +} + +message InjectorReq { + required string category = 1; + required int32 length = 2; + required int32 group = 3; + required int32 action = 4; + optional bytes data = 5; +} + +message InjectorAns { + required int32 errcode = 1; + optional string errstr = 2; + required string category = 3; +} + +message InjectorNtf { + required string category = 1; + required int32 length = 2; + required int32 group = 3; + required int32 action = 4; + optional bytes data = 5; +} + +message DeviceReq { + required string category = 1; + required int32 length = 2; + required int32 group = 3; + required int32 action = 4; + optional bytes data = 5; +} + +message DeviceAns { + required int32 errcode = 1; + optional string errstr = 2; + required string category = 3; + required int32 length = 4; + required int32 group = 5; + required int32 action = 6; + optional bytes data = 7; +} + +message DeviceNtf { + required string category = 1; + required int32 length = 2; + required int32 group = 3; + required int32 action = 4; + optional bytes data = 5; +} + +message MonitorReq { + required string command = 1; +} + +message MonitorAns { + required int32 errcode = 1; + optional string errmsg = 2; + required string command = 3; + optional bytes data = 4; +} + +message MonitorNtf { + required string command = 1; + optional bytes data = 2; +} + +// ======= Extensions messages ======= + +message NfcReq { + required string category = 1; + optional bytes data = 2; +} + +message NfcNtf { + required string category = 1; + optional bytes data = 2; +} + +// ======= Main master message ======= + +message Master { + required Master_Type type = 1; + + optional CheckVersionReq checkversion_req = 2; + optional CheckVersionAns checkversion_ans = 3; + + optional KeepAliveReq keepalive_req = 4; + optional KeepAliveAns keepalive_ans = 5; + + optional InjectorReq injector_req = 6; + optional InjectorAns injector_ans = 7; + optional InjectorNtf injector_ntf = 8; + + optional DeviceReq device_req = 9; + optional DeviceAns device_ans = 10; + optional DeviceNtf device_ntf = 11; + + optional MonitorReq monitor_req = 12; + optional MonitorAns monitor_ans = 13; + optional MonitorNtf monitor_ntf = 14; + + // Extensions 101 to 150; + optional NfcReq nfc_req = 101; + optional NfcNtf nfc_ntf = 102; +} + + diff --git a/org.tizen.dynamicanalyzer/src/msg/ecs_ids.proto b/org.tizen.dynamicanalyzer/src/msg/ecs_ids.proto new file mode 100644 index 0000000..dc981fb --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/msg/ecs_ids.proto @@ -0,0 +1,22 @@ +package ECS; + +option java_package = "org.tizen.dynamicanalyzer.ui.info.snapshot.ecs"; + +enum Master_Type { + CHECKVERSION_REQ = 2; + CHECKVERSION_ANS = 3; + KEEPALIVE_REQ = 4; + KEEPALIVE_ANS = 5; + INJECTOR_REQ = 6; + INJECTOR_ANS = 7; + INJECTOR_NTF = 8; + DEVICE_REQ = 9; + DEVICE_ANS = 10; + DEVICE_NTF = 11; + MONITOR_REQ = 12; + MONITOR_ANS = 13; + MONITOR_NTF = 14; + + NFC_REQ = 101; + NFC_NTF = 102; +} diff --git a/org.tizen.dynamicanalyzer/src/msg/gen.sh b/org.tizen.dynamicanalyzer/src/msg/gen.sh new file mode 100644 index 0000000..21cbf98 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/msg/gen.sh @@ -0,0 +1,4 @@ +#!/bin/sh + + +protoc -I=. --java_out=../ ecs.proto diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/DeviceInfo.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/DeviceInfo.java index 4d14d27..94f4a9b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/DeviceInfo.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/model/DeviceInfo.java @@ -31,6 +31,7 @@ import java.util.HashMap; import java.util.List; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.CommonConstants; import org.tizen.dynamicanalyzer.common.HostResult; import org.tizen.dynamicanalyzer.communicator.BaseCommunicator; import org.tizen.dynamicanalyzer.communicator.Communicator22; @@ -39,6 +40,7 @@ import org.tizen.dynamicanalyzer.project.AppInfo; import org.tizen.dynamicanalyzer.project.PackageInfo; import org.tizen.dynamicanalyzer.swap.channel.control.TargetInfo; import org.tizen.dynamicanalyzer.swap.communicator.Communicator30; +import org.tizen.dynamicanalyzer.ui.info.snapshot.EmulatorSnapshot; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.sdblib.IDevice; @@ -59,6 +61,8 @@ public class DeviceInfo { private int remotePort = -1; private Socket controlSock = null; private Socket dataSock = null; + + public EmulatorSnapshot emulatorSnapshot = null; public DeviceInfo(IDevice device) { this.device = device; @@ -182,4 +186,14 @@ public class DeviceInfo { public PackageInfo getSelectedPackage(String pkgId) { return pkgInfoHash.get(pkgId); } + + public boolean isEmulator() { + if (device != null) { + if (device.getSerialNumber() + .contains(CommonConstants.EMULATOR)) { + return true; + } + } + return false; + } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java index e9bbf50..27b5b92 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java @@ -76,6 +76,8 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogDataUtils; import org.tizen.dynamicanalyzer.swap.platform.BinarySettingData; import org.tizen.dynamicanalyzer.swap.platform.BinarySettingManager; import org.tizen.dynamicanalyzer.ui.file.FileChartManager; +import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketClient; +import org.tizen.dynamicanalyzer.ui.info.snapshot.EmulatorSnapshot; import org.tizen.dynamicanalyzer.ui.network.NetworkChartManager; import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; import org.tizen.dynamicanalyzer.ui.thread.ThreadChartManager; @@ -93,6 +95,14 @@ public class Communicator30 extends BaseCommunicator { @Override public HostResult init(DeviceInfo devInfo) { + // connect ecs server + if(devInfo.isEmulator()) { + if(!SocketClient.getInstance().connect()) { + System.out.println("[warn] Connect to ecs server is failed"); + } + devInfo.emulatorSnapshot = new EmulatorSnapshot(); + } + // daemon start Process ps = CommunicatorUtils.execCommand(devInfo.getIDevice(), AnalyzerShellCommands.DACOMMAND_RUN_MANAGER); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java index 3da9d82..6f3c07a 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/SWAPLogParser.java @@ -44,11 +44,13 @@ import org.tizen.dynamicanalyzer.swap.model.data.ProfileData; import org.tizen.dynamicanalyzer.swap.model.data.ReplayData; import org.tizen.dynamicanalyzer.swap.model.data.ScreenShotData; import org.tizen.dynamicanalyzer.swap.model.data.SystemData; +import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketClient; import org.tizen.dynamicanalyzer.ui.page.BaseView; import org.tizen.dynamicanalyzer.ui.summary.profiling.FunctionUsageProfiler; import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; import org.tizen.dynamicanalyzer.utils.ImageUtil; +import org.tizen.dynamicanalyzer.utils.ImageUtilSWT; import org.tizen.sdblib.service.SyncResult; public class SWAPLogParser implements Runnable { @@ -222,11 +224,27 @@ public class SWAPLogParser implements Runnable { pushLog(log, logPack); } else { if (log instanceof ScreenShotData) { - String remoteImgPath = ((ScreenShotData) log) - .getImageFilePath(); + boolean bECS = false; + String remoteImgPath; + if(DACommunicator.isTargetEmulator() + && SocketClient.getInstance().isConnected()) { + DACommunicator.getSelectedDevice().emulatorSnapshot.send(); + remoteImgPath = DACommunicator.getSelectedDevice() + .emulatorSnapshot.getFilePath(); + bECS = true; + } else { + remoteImgPath = ((ScreenShotData) log) + .getImageFilePath(); + } + int rotate = ((ScreenShotData) log).getOrientation(); // TODO : fix - processImage(remoteImgPath, rotate); + if(bECS) { + processImagefromECS(remoteImgPath, rotate); + } else { + processImage(remoteImgPath, rotate); + } + ImageInfo imgInfo = new ImageInfo(); imgInfo.setSeq(Integer.toString(log.getSeq())); imgInfo.setTime(Long.toString(log.getTime())); @@ -308,6 +326,55 @@ public class SWAPLogParser implements Runnable { } + private void processImagefromECS(final String path, final int angle) { + final String fileName = getImageName(path); + + if (angle != 0) { + System.out.println("[ image rotate : " + angle + " ]"); + } + + new Thread(null, new Runnable() { + int count = 0; + + @Override + public void run() { + while (true && count < 5) { + File file = new File(path); + if (file.exists()) { + /* image resizing */ + String smallImagePath = AnalyzerManager.getProject() + .getSavePath() + + File.separator + + AnalyzerConstants.IMAGE_FOLDER_NAME + + File.separator + + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME + + File.separator + fileName; + ImageUtilSWT.transform(path, path, DEFAULT_IMG_WIDTH, + DEFAULT_IMG_HEIGHT, angle); + if (angle == 90 || angle == 270) { + ImageUtilSWT.resize(path, smallImagePath, + SMALL_IMG_HEIGHT, SMALL_IMG_WIDTH); + } else { + ImageUtilSWT.resize(path, smallImagePath, + SMALL_IMG_WIDTH, SMALL_IMG_HEIGHT); + } + + break; + } else { + System.out.println("Failed to get '" + path + "' file"); //$NON-NLS-1$ //$NON-NLS-2$ + try { + Thread.sleep(1000); + count++; + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + } + }, AnalyzerConstants.MESSAGE_INTERNAL_IMAGE_THREAD).start(); + + } + private String getImageName(String fullPath) { String name = null; name = fullPath diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EmulatorSnapshot.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EmulatorSnapshot.java new file mode 100644 index 0000000..47e3ba0 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EmulatorSnapshot.java @@ -0,0 +1,83 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.io.File; + +import org.json.simple.JSONObject; +import org.tizen.dynamicanalyzer.common.AnalyzerConstants; +import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.utils.JsonUtil; + +public class EmulatorSnapshot implements ILsn { + + private final String SNAPSHOT = "Snapshot"; + private int filecount = 0; + + public EmulatorSnapshot() { + EventMgr.getInstance().AddLsnSet(SNAPSHOT); + EventMgr.getInstance().AddLsn(SNAPSHOT, this); + } + + @Override + public void OnEventProc(String eventname, JSONObject jsParam) { + String message = jsParam.get(SocketConstants.MESSAGE_RETURN).toString(); + System.out.println("[info] " + message); + } + + @Override + public void OnEventProcPB(String eventname, + com.google.protobuf.GeneratedMessage param) { + } + + public String getFilePath() { + String filepath, filename; + filename = "snapshot" + filecount; + filepath = AnalyzerManager.getProject().getSavePath() + + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME + + File.separator + filename; + + return filepath; + } + + private String createSnapshotMsg() { + filecount++; + String msg = JsonUtil.encodeString(JsonUtil.CMD_EXECUTE, + JsonUtil.CMD_SCREENDUMP, JsonUtil.CMD_ARGS, + JsonUtil.encodeObject(JsonUtil.ARG_FILENAME, getFilePath()), + SNAPSHOT); + return msg; + } + + public void send() { + MessageSender.getInstance().sendMonitorReq(createSnapshotMsg()); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EventMgr.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EventMgr.java new file mode 100644 index 0000000..fa49456 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/EventMgr.java @@ -0,0 +1,104 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.json.simple.JSONObject; + +public class EventMgr { + + private ListenMap> m_lsns = new ListenMap>(); + + private static EventMgr _inst; + + public static EventMgr getInstance() { + if (null == _inst) { + _inst = new EventMgr(); + } + return _inst; + } + + public void AddLsnSet(String name) { + if (m_lsns.Find(name) != null) { + return; + } + ListenSet lsn = new ListenSet(); + m_lsns.add(name, lsn); + } + + public void RemoveLsnSet(String name) { + m_lsns.remove(name); + } + + public void AddLsn(String name, ILsn lsn) { + ListenSet set = m_lsns.Find(name); + if (set == null) + return; + + set.add(lsn); + } + + public void RemoveLsn(String name, ILsn lsn) { + ListenSet set = m_lsns.Find(name); + if (set == null) + return; + + set.remove(lsn); + } + + public void Invoke(String name, JSONObject param) + { + ListenSet set = m_lsns.Find(name); + if (set == null) + return; + + for (int i = 0; i < set.size(); i++) { + ILsn lsn = (ILsn) set.get(i); + if (lsn == null) + continue; + lsn.OnEventProc(name, param); + } + } + + + public void InvokePB(String name, com.google.protobuf.GeneratedMessage param) + { + ListenSet set = m_lsns.Find(name); + if (set == null) + return; + + for (int i = 0; i < set.size(); i++) { + ILsn lsn = (ILsn) set.get(i); + if (lsn == null) + continue; + lsn.OnEventProcPB(name, param); + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ILsn.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ILsn.java new file mode 100644 index 0000000..3708eea --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ILsn.java @@ -0,0 +1,39 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.json.simple.JSONObject; + +public interface ILsn { + + void OnEventProc(String eventname, JSONObject jsParam); + void OnEventProcPB(String eventname, com.google.protobuf.GeneratedMessage param); +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMessage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMessage.java new file mode 100644 index 0000000..9e0f8bf --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMessage.java @@ -0,0 +1,39 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.json.simple.JSONObject; + +public interface IMessage { + + void receiveMessage(JSONObject obj); + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMsgProc.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMsgProc.java new file mode 100644 index 0000000..36a7131 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/IMsgProc.java @@ -0,0 +1,40 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; + +public interface IMsgProc { + + //void Proc(JSONObject jsResult, JSONObject jsData); + void Proc(Master msg); + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenMap.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenMap.java new file mode 100644 index 0000000..ad9f615 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenMap.java @@ -0,0 +1,56 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.util.Map; +import java.util.HashMap; + + +public class ListenMap { + + private Map listeners = new HashMap(); + + public void add(String name, T lsn) + { + listeners.put(name, lsn); + } + + public void remove(String name) + { + listeners.remove(name); + } + + public T Find(String name) + { + T t = listeners.get(name); + return t; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenSet.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenSet.java new file mode 100644 index 0000000..a81fb10 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ListenSet.java @@ -0,0 +1,61 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.util.ArrayList; +import java.util.List; + + +public class ListenSet // implements ILsn +{ + private List listeners = new ArrayList(); + + public void add(T lsn) + { + listeners.add(lsn); + } + + public void remove(T lsn) + { + listeners.remove(lsn); + } + + public int size() + { + return listeners.size(); + } + + public T get(int index) + { + return listeners.get(index); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageQueue.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageQueue.java new file mode 100644 index 0000000..907ac47 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageQueue.java @@ -0,0 +1,78 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.util.LinkedList; + +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; + +public class MessageQueue { + + private LinkedList m_msgQueue = new LinkedList(); + private static MessageQueue m_inst; + + public static MessageQueue getInstance() { + if (null == m_inst) { + m_inst = new MessageQueue(); + } + return m_inst; + } + + + public void QueueMsg(Master msg) + { + m_msgQueue.add(msg); + this.notifyAll(); + } + + public boolean isEmpty() + { + return m_msgQueue.isEmpty(); + } + + public Master Poll() + { + return m_msgQueue.poll(); + } + + /* + public void Wait() + { + try { + m_msgQueue.wait(); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + }*/ + + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageSender.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageSender.java new file mode 100644 index 0000000..c5e2f0b --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MessageSender.java @@ -0,0 +1,99 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.io.IOException; + +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type; + +public class MessageSender { + + private static MessageSender m_inst; + + public static MessageSender getInstance() { + if (null == m_inst) { + m_inst = new MessageSender(); + } + return m_inst; + } + + private boolean sendMaster(Master master) { + int serialize_size = master.getSerializedSize(); + + try { + SocketClient.getInstance().getOutputStream() + .writeInt(serialize_size); + master.writeTo(SocketClient.getInstance().getOutputStream()); + SocketClient.getInstance().getOutputStream().flush(); + } catch (IOException e) { + System.out.println("[warn] " + e.getMessage()); + return false; + } + return true; + } + + public boolean sendMonitorReq(String data) { + + Master.Builder masterBuilder = Master.newBuilder(); + + masterBuilder.setType(Master_Type.MONITOR_REQ); + + MonitorReq.Builder monitorBuilder = MonitorReq.newBuilder(); + + monitorBuilder.setCommand(data); + + masterBuilder.setMonitorReq(monitorBuilder); + + Master master = masterBuilder.build(); + + return sendMaster(master); + } + + public void sendKeepAliveAns() { + Master.Builder masterBuilder = Master.newBuilder(); + + masterBuilder.setType(Master_Type.KEEPALIVE_ANS); + + KeepAliveAns.Builder kaBuilder = KeepAliveAns.newBuilder(); + + kaBuilder.setTimeStr("self"); + + masterBuilder.setKeepaliveAns(kaBuilder); + + Master master = masterBuilder.build(); + + sendMaster(master); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgMgr.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgMgr.java new file mode 100644 index 0000000..ca76cd1 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgMgr.java @@ -0,0 +1,132 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.util.HashMap; +import java.util.Map; + +import org.json.simple.JSONObject; +import org.tizen.dynamicanalyzer.utils.JsonUtil; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type; + +public class MsgMgr { + + private Map _msg_map = new HashMap(); + + private String contents = null; + + MsgMgr() { + AddMsgProc(Master_Type.MONITOR_NTF, new MsgProc_MonitorNtf()); + AddMsgProc(Master_Type.KEEPALIVE_REQ, new MsgProc_KeepAliveReq()); + } + + private static MsgMgr _inst; + + public static MsgMgr getInstance() { + if (null == _inst) { + _inst = new MsgMgr(); + } + return _inst; + } + + public void AddMsgProc(Master_Type type, IMsgProc proc) { + _msg_map.put(type, proc); + } + + public IMsgProc FindMsgProc(Master_Type type) { + IMsgProc proc = _msg_map.get(type); + if (proc == null) + return null; + return proc; + } + + void ProcBufMsg(Master msg) { + Master_Type subtype = msg.getType(); + + IMsgProc proc = FindMsgProc(subtype); + + if (proc == null) { + System.out.println("[info] invalid message type - " + subtype.toString()); + return; + } + + if (msg.getType() == Master_Type.MONITOR_NTF) { + String message = msg.getMonitorNtf().getCommand(); + if (contents == null) { + contents = new String(message); + } else { + contents = contents.substring(0, contents.length() - 7); + contents += message; + } + + if (!messageComplete(contents)) { + return; + } else { + int lastBrace = contents.lastIndexOf("}"); + contents = contents.substring(0, lastBrace + 1); + JSONObject obj = JsonUtil.decodeObject(contents); + if (obj == null) { + return; + } + + EventMgr.getInstance().Invoke( + (String) obj.get(SocketConstants.MESSAGE_TYPE), obj); + contents = null; + } + } else { + proc.Proc(msg); + } + + } + + private boolean messageComplete(String msg) { + int braceCount = 0; + char value; + + for (int i = 0; i < msg.length(); i++) { + value = msg.charAt(i); + if (value == 123) { // { (123), } (125) + braceCount++; + } else if (value == 125) { + if (braceCount > 0) { + braceCount--; + } + } + } + + if (braceCount == 0) { + return true; + } + + return false; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_KeepAliveReq.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_KeepAliveReq.java new file mode 100644 index 0000000..9bd0085 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_KeepAliveReq.java @@ -0,0 +1,46 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; + +public class MsgProc_KeepAliveReq implements IMsgProc { + + @Override + public void Proc(Master msg) { + + if (!msg.hasKeepaliveReq()) + return; + + MessageSender.getInstance().sendKeepAliveAns(); + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_MonitorNtf.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_MonitorNtf.java new file mode 100644 index 0000000..9dd13cf --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/MsgProc_MonitorNtf.java @@ -0,0 +1,52 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf; + +public class MsgProc_MonitorNtf implements IMsgProc { + + @Override + public void Proc(Master msg) { + + if (!msg.hasMonitorNtf()) + return; + + MonitorNtf ntf = msg.getMonitorNtf(); + + String cat = ntf.getCommand(); + + EventMgr.getInstance().InvokePB(cat, ntf); + + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketClient.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketClient.java new file mode 100644 index 0000000..9fcf899 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketClient.java @@ -0,0 +1,203 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.io.BufferedReader; +import java.io.Closeable; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.Socket; +import java.net.SocketException; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +public class SocketClient { + + private static SocketClient client; + + private Socket socket; + private String ip = SocketConstants.DefaultIp; + private int port = SocketConstants.DefaultPort; + + // private BufferedOutputStream output; + private DataOutputStream output; + private DataInputStream input; + + public DataOutputStream getOutputStream() { + return output; + } + + public DataInputStream getInputStream() { + return input; + } + + private LinkedList receiveQueue = new LinkedList(); + private List listeners = new ArrayList(); + + private boolean running = false; + + public static SocketClient getInstance() { + if (null == client) { + client = new SocketClient(); + } + return client; + } + + public boolean connect() { + return connect(port); + } + + public boolean connect(int port) { + + try { + socket = new Socket(ip, port); + System.out.println("[info] socket created." + "ip: " + ip + ", port: " + port); + + socket.setReuseAddress(true); + + output = new DataOutputStream(socket.getOutputStream()); + input = new DataInputStream(socket.getInputStream()); + + running = true; + + new Thread(null, new SocketReceive(), + SocketConstants.SOCKET_RECEIVE_THREAD).start(); + + new Thread(null, new SocketMessage(), + SocketConstants.SOCKET_MESSAGE_THREAD).start(); + + } catch (SocketException e) { + System.out.println("[warn] " + e.getMessage()); + return false; + } catch (IOException e) { + System.out.println("[warn] " + e.getMessage()); + return false; + } + + return true; + } + + public boolean tryClose(final Object... closeables) { + if (null == closeables) { + return false; + } + + for (Object obj : closeables) { + if (null == obj) { + continue; + } + try { + if (obj instanceof Closeable) { + ((Closeable) obj).close(); + } else if (obj instanceof BufferedReader) { + ((BufferedReader) obj).close(); + } else if (obj instanceof Socket) { + ((Socket) obj).close(); + } + } catch (final IOException e) { + System.out.println("[warn] " + e.getMessage()); + return false; + } + } + + return true; + } + + public boolean disconnect() { + boolean result = false; + running = false; + + if (null != receiveQueue) { + synchronized (receiveQueue) { + receiveQueue.notifyAll(); + } + } + + result = tryClose(socket); + + return result; + } + + public int getPort() { + return port; + } + + public void setPort(int port) { + this.port = port; + } + + public boolean isConnected() { + if (null == socket) { + return false; + } + return socket.isConnected(); + } + + public Socket getSocket() { + return socket; + } + + public String getIp() { + return ip; + } + + public void setIp(String ip) { + this.ip = ip; + } + + public InputStream getSockInputStream() throws IOException { + return socket.getInputStream(); + } + + public boolean isRunning() { + return running; + } + + public void setRunning(boolean run) { + running = run; + } + + public LinkedList getReceiveQueue() { + return receiveQueue; + } + + public void addListener(IMessage iMessage) { + listeners.add(iMessage); + } + + public List getListener() { + return listeners; + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketConstants.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketConstants.java new file mode 100644 index 0000000..bf7d194 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketConstants.java @@ -0,0 +1,57 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +public class SocketConstants { + public static String DefaultIp = "localhost"; + public static int DefaultPort = 27000; + + public final static int MAX_BUFFER = 4096; + + public final static int MAX_SEND_QUEUE_SIZE = 100000; + public final static int MAX_RECEIVE_QUEUE_SIZE = 100000; + + public final static String MESSAGE_TYPE = "type"; + public final static String MESSAGE_SELF = "self"; + public final static String MESSAGE_DATA = "data"; + public final static String MESSAGE_HEADER = "header"; + public final static String MESSAGE_ACTION = "action"; + public final static String MESSAGE_GROUP = "group"; + public final static String MESSAGE_RETURN = "return"; + public final static String MESSAGE_IJDATA = "ijdata"; + + public final static String SOCKET_RECEIVE_THREAD = "Socket Receive Thread"; + public final static String SOCKET_MESSAGE_THREAD = "Socket Message Thread"; + + public static String RECEIVE_SHARPS = "##"; + public static String RECEIVE_OPEN_BRACE = "{"; + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketMessage.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketMessage.java new file mode 100644 index 0000000..9cff781 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketMessage.java @@ -0,0 +1,86 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import org.eclipse.swt.widgets.Display; +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; + +public class SocketMessage implements Runnable { + +// private List list = new ArrayList(); + + @Override + public void run() { + SocketClient client = SocketClient.getInstance(); + MessageQueue msgQueue = MessageQueue.getInstance(); + + + while (true) { + synchronized (msgQueue) { + if (msgQueue.isEmpty()) { + try { + msgQueue.wait(); + } catch (InterruptedException e) { + System.out.println("[severe] " + e.getMessage()); + } + } + while (true) + { + Master msg = msgQueue.Poll(); + if (msg != null) + { + processMsg(msg); + } + else + { + break; + } + } + + if (!client.isRunning()) { + break; + } + } + } + } + + + private void processMsg(final Master msg) { + + Display.getDefault().asyncExec(new Runnable() { + @Override + public void run() { + System.out.println("[info] processMsg"); + MsgMgr.getInstance().ProcBufMsg(msg); + } + }); + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketReceive.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketReceive.java new file mode 100644 index 0000000..04f9c9a --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/SocketReceive.java @@ -0,0 +1,98 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.ui.info.snapshot; + +import java.io.BufferedReader; +import java.io.DataInputStream; +import java.io.EOFException; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.ByteBuffer; + +import org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master; + +import com.google.protobuf.CodedInputStream; + +public class SocketReceive implements Runnable { + @Override + public void run() { + SocketClient client = SocketClient.getInstance(); + System.out.println("[info] Socket Receive runs."); + + DataInputStream in = client.getInputStream(); + int size = 0; + try { + while ((size = in.readInt()) > 0) { + if (client.getSocket().isClosed() || !client.isRunning()) { + System.out.println("closed || not running."); + break; + } + + read_data(size, in); + + } + } catch (final EOFException e) { + client.disconnect(); + } catch (IOException e) { + client.disconnect(); + } + } + + private void read_data(int size, DataInputStream in) throws IOException { + CodedInputStream codedIn = null; + int available = in.available(); + + if (size <= available) { // case: protobuf message + byte[] buff = new byte[size]; + int read = in.read(buff); + if (read > size) { + return; + } + codedIn = CodedInputStream.newInstance(buff); + } else { // case: string message + BufferedReader reader = new BufferedReader( + new InputStreamReader(in)); + byte[] bSize = ByteBuffer.allocate(4).putInt(size).array(); + String message = new String(bSize, 0, 4) + reader.readLine(); + System.out.println("message len: " + message.length() + + ", message:" + message); + // TODO: handle string message + } + + if (codedIn != null) { + Master msg = Master.parseFrom(codedIn); + synchronized (MessageQueue.getInstance()) { + MessageQueue.getInstance().QueueMsg(msg); + } + } + } + +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/Ecs.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/Ecs.java new file mode 100644 index 0000000..77ad643 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/Ecs.java @@ -0,0 +1,13848 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: ecs.proto + +package org.tizen.dynamicanalyzer.ui.info.snapshot.ecs; + +public final class Ecs { + private Ecs() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + public interface CheckVersionReqOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string version_str = 1; + /** + * required string version_str = 1; + */ + boolean hasVersionStr(); + /** + * required string version_str = 1; + */ + java.lang.String getVersionStr(); + /** + * required string version_str = 1; + */ + com.google.protobuf.ByteString + getVersionStrBytes(); + } + /** + * Protobuf type {@code ECS.CheckVersionReq} + */ + public static final class CheckVersionReq extends + com.google.protobuf.GeneratedMessage + implements CheckVersionReqOrBuilder { + // Use CheckVersionReq.newBuilder() to construct. + private CheckVersionReq(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private CheckVersionReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final CheckVersionReq defaultInstance; + public static CheckVersionReq getDefaultInstance() { + return defaultInstance; + } + + public CheckVersionReq getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CheckVersionReq( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + versionStr_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public CheckVersionReq parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CheckVersionReq(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string version_str = 1; + public static final int VERSION_STR_FIELD_NUMBER = 1; + private java.lang.Object versionStr_; + /** + * required string version_str = 1; + */ + public boolean hasVersionStr() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string version_str = 1; + */ + public java.lang.String getVersionStr() { + java.lang.Object ref = versionStr_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + versionStr_ = s; + } + return s; + } + } + /** + * required string version_str = 1; + */ + public com.google.protobuf.ByteString + getVersionStrBytes() { + java.lang.Object ref = versionStr_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + versionStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + versionStr_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasVersionStr()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getVersionStrBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getVersionStrBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.CheckVersionReq} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + versionStr_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionReq_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.versionStr_ = versionStr_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance()) return this; + if (other.hasVersionStr()) { + bitField0_ |= 0x00000001; + versionStr_ = other.versionStr_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasVersionStr()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string version_str = 1; + private java.lang.Object versionStr_ = ""; + /** + * required string version_str = 1; + */ + public boolean hasVersionStr() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string version_str = 1; + */ + public java.lang.String getVersionStr() { + java.lang.Object ref = versionStr_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + versionStr_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string version_str = 1; + */ + public com.google.protobuf.ByteString + getVersionStrBytes() { + java.lang.Object ref = versionStr_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + versionStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string version_str = 1; + */ + public Builder setVersionStr( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + versionStr_ = value; + onChanged(); + return this; + } + /** + * required string version_str = 1; + */ + public Builder clearVersionStr() { + bitField0_ = (bitField0_ & ~0x00000001); + versionStr_ = getDefaultInstance().getVersionStr(); + onChanged(); + return this; + } + /** + * required string version_str = 1; + */ + public Builder setVersionStrBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + versionStr_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.CheckVersionReq) + } + + static { + defaultInstance = new CheckVersionReq(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.CheckVersionReq) + } + + public interface CheckVersionAnsOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required int32 errcode = 1; + /** + * required int32 errcode = 1; + */ + boolean hasErrcode(); + /** + * required int32 errcode = 1; + */ + int getErrcode(); + + // required string version_str = 2; + /** + * required string version_str = 2; + */ + boolean hasVersionStr(); + /** + * required string version_str = 2; + */ + java.lang.String getVersionStr(); + /** + * required string version_str = 2; + */ + com.google.protobuf.ByteString + getVersionStrBytes(); + } + /** + * Protobuf type {@code ECS.CheckVersionAns} + */ + public static final class CheckVersionAns extends + com.google.protobuf.GeneratedMessage + implements CheckVersionAnsOrBuilder { + // Use CheckVersionAns.newBuilder() to construct. + private CheckVersionAns(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private CheckVersionAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final CheckVersionAns defaultInstance; + public static CheckVersionAns getDefaultInstance() { + return defaultInstance; + } + + public CheckVersionAns getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CheckVersionAns( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + errcode_ = input.readInt32(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + versionStr_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public CheckVersionAns parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CheckVersionAns(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required int32 errcode = 1; + public static final int ERRCODE_FIELD_NUMBER = 1; + private int errcode_; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + + // required string version_str = 2; + public static final int VERSION_STR_FIELD_NUMBER = 2; + private java.lang.Object versionStr_; + /** + * required string version_str = 2; + */ + public boolean hasVersionStr() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string version_str = 2; + */ + public java.lang.String getVersionStr() { + java.lang.Object ref = versionStr_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + versionStr_ = s; + } + return s; + } + } + /** + * required string version_str = 2; + */ + public com.google.protobuf.ByteString + getVersionStrBytes() { + java.lang.Object ref = versionStr_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + versionStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + errcode_ = 0; + versionStr_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasErrcode()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasVersionStr()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getVersionStrBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getVersionStrBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.CheckVersionAns} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + errcode_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + versionStr_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_CheckVersionAns_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.errcode_ = errcode_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.versionStr_ = versionStr_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance()) return this; + if (other.hasErrcode()) { + setErrcode(other.getErrcode()); + } + if (other.hasVersionStr()) { + bitField0_ |= 0x00000002; + versionStr_ = other.versionStr_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasErrcode()) { + + return false; + } + if (!hasVersionStr()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required int32 errcode = 1; + private int errcode_ ; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + /** + * required int32 errcode = 1; + */ + public Builder setErrcode(int value) { + bitField0_ |= 0x00000001; + errcode_ = value; + onChanged(); + return this; + } + /** + * required int32 errcode = 1; + */ + public Builder clearErrcode() { + bitField0_ = (bitField0_ & ~0x00000001); + errcode_ = 0; + onChanged(); + return this; + } + + // required string version_str = 2; + private java.lang.Object versionStr_ = ""; + /** + * required string version_str = 2; + */ + public boolean hasVersionStr() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string version_str = 2; + */ + public java.lang.String getVersionStr() { + java.lang.Object ref = versionStr_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + versionStr_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string version_str = 2; + */ + public com.google.protobuf.ByteString + getVersionStrBytes() { + java.lang.Object ref = versionStr_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + versionStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string version_str = 2; + */ + public Builder setVersionStr( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + versionStr_ = value; + onChanged(); + return this; + } + /** + * required string version_str = 2; + */ + public Builder clearVersionStr() { + bitField0_ = (bitField0_ & ~0x00000002); + versionStr_ = getDefaultInstance().getVersionStr(); + onChanged(); + return this; + } + /** + * required string version_str = 2; + */ + public Builder setVersionStrBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + versionStr_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.CheckVersionAns) + } + + static { + defaultInstance = new CheckVersionAns(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.CheckVersionAns) + } + + public interface KeepAliveReqOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional string time_str = 1; + /** + * optional string time_str = 1; + */ + boolean hasTimeStr(); + /** + * optional string time_str = 1; + */ + java.lang.String getTimeStr(); + /** + * optional string time_str = 1; + */ + com.google.protobuf.ByteString + getTimeStrBytes(); + } + /** + * Protobuf type {@code ECS.KeepAliveReq} + */ + public static final class KeepAliveReq extends + com.google.protobuf.GeneratedMessage + implements KeepAliveReqOrBuilder { + // Use KeepAliveReq.newBuilder() to construct. + private KeepAliveReq(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private KeepAliveReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final KeepAliveReq defaultInstance; + public static KeepAliveReq getDefaultInstance() { + return defaultInstance; + } + + public KeepAliveReq getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private KeepAliveReq( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + timeStr_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public KeepAliveReq parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new KeepAliveReq(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional string time_str = 1; + public static final int TIME_STR_FIELD_NUMBER = 1; + private java.lang.Object timeStr_; + /** + * optional string time_str = 1; + */ + public boolean hasTimeStr() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional string time_str = 1; + */ + public java.lang.String getTimeStr() { + java.lang.Object ref = timeStr_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + timeStr_ = s; + } + return s; + } + } + /** + * optional string time_str = 1; + */ + public com.google.protobuf.ByteString + getTimeStrBytes() { + java.lang.Object ref = timeStr_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + timeStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + timeStr_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getTimeStrBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getTimeStrBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.KeepAliveReq} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + timeStr_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveReq_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.timeStr_ = timeStr_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance()) return this; + if (other.hasTimeStr()) { + bitField0_ |= 0x00000001; + timeStr_ = other.timeStr_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional string time_str = 1; + private java.lang.Object timeStr_ = ""; + /** + * optional string time_str = 1; + */ + public boolean hasTimeStr() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional string time_str = 1; + */ + public java.lang.String getTimeStr() { + java.lang.Object ref = timeStr_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + timeStr_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string time_str = 1; + */ + public com.google.protobuf.ByteString + getTimeStrBytes() { + java.lang.Object ref = timeStr_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + timeStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string time_str = 1; + */ + public Builder setTimeStr( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + timeStr_ = value; + onChanged(); + return this; + } + /** + * optional string time_str = 1; + */ + public Builder clearTimeStr() { + bitField0_ = (bitField0_ & ~0x00000001); + timeStr_ = getDefaultInstance().getTimeStr(); + onChanged(); + return this; + } + /** + * optional string time_str = 1; + */ + public Builder setTimeStrBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + timeStr_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.KeepAliveReq) + } + + static { + defaultInstance = new KeepAliveReq(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.KeepAliveReq) + } + + public interface KeepAliveAnsOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // optional string time_str = 1; + /** + * optional string time_str = 1; + */ + boolean hasTimeStr(); + /** + * optional string time_str = 1; + */ + java.lang.String getTimeStr(); + /** + * optional string time_str = 1; + */ + com.google.protobuf.ByteString + getTimeStrBytes(); + } + /** + * Protobuf type {@code ECS.KeepAliveAns} + */ + public static final class KeepAliveAns extends + com.google.protobuf.GeneratedMessage + implements KeepAliveAnsOrBuilder { + // Use KeepAliveAns.newBuilder() to construct. + private KeepAliveAns(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private KeepAliveAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final KeepAliveAns defaultInstance; + public static KeepAliveAns getDefaultInstance() { + return defaultInstance; + } + + public KeepAliveAns getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private KeepAliveAns( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + timeStr_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public KeepAliveAns parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new KeepAliveAns(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional string time_str = 1; + public static final int TIME_STR_FIELD_NUMBER = 1; + private java.lang.Object timeStr_; + /** + * optional string time_str = 1; + */ + public boolean hasTimeStr() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional string time_str = 1; + */ + public java.lang.String getTimeStr() { + java.lang.Object ref = timeStr_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + timeStr_ = s; + } + return s; + } + } + /** + * optional string time_str = 1; + */ + public com.google.protobuf.ByteString + getTimeStrBytes() { + java.lang.Object ref = timeStr_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + timeStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + timeStr_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getTimeStrBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getTimeStrBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.KeepAliveAns} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + timeStr_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_KeepAliveAns_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.timeStr_ = timeStr_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance()) return this; + if (other.hasTimeStr()) { + bitField0_ |= 0x00000001; + timeStr_ = other.timeStr_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional string time_str = 1; + private java.lang.Object timeStr_ = ""; + /** + * optional string time_str = 1; + */ + public boolean hasTimeStr() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional string time_str = 1; + */ + public java.lang.String getTimeStr() { + java.lang.Object ref = timeStr_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + timeStr_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string time_str = 1; + */ + public com.google.protobuf.ByteString + getTimeStrBytes() { + java.lang.Object ref = timeStr_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + timeStr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string time_str = 1; + */ + public Builder setTimeStr( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + timeStr_ = value; + onChanged(); + return this; + } + /** + * optional string time_str = 1; + */ + public Builder clearTimeStr() { + bitField0_ = (bitField0_ & ~0x00000001); + timeStr_ = getDefaultInstance().getTimeStr(); + onChanged(); + return this; + } + /** + * optional string time_str = 1; + */ + public Builder setTimeStrBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + timeStr_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.KeepAliveAns) + } + + static { + defaultInstance = new KeepAliveAns(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.KeepAliveAns) + } + + public interface InjectorReqOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string category = 1; + /** + * required string category = 1; + */ + boolean hasCategory(); + /** + * required string category = 1; + */ + java.lang.String getCategory(); + /** + * required string category = 1; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // required int32 length = 2; + /** + * required int32 length = 2; + */ + boolean hasLength(); + /** + * required int32 length = 2; + */ + int getLength(); + + // required int32 group = 3; + /** + * required int32 group = 3; + */ + boolean hasGroup(); + /** + * required int32 group = 3; + */ + int getGroup(); + + // required int32 action = 4; + /** + * required int32 action = 4; + */ + boolean hasAction(); + /** + * required int32 action = 4; + */ + int getAction(); + + // optional bytes data = 5; + /** + * optional bytes data = 5; + */ + boolean hasData(); + /** + * optional bytes data = 5; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.InjectorReq} + */ + public static final class InjectorReq extends + com.google.protobuf.GeneratedMessage + implements InjectorReqOrBuilder { + // Use InjectorReq.newBuilder() to construct. + private InjectorReq(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private InjectorReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final InjectorReq defaultInstance; + public static InjectorReq getDefaultInstance() { + return defaultInstance; + } + + public InjectorReq getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private InjectorReq( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + category_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + length_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + group_ = input.readInt32(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + action_ = input.readInt32(); + break; + } + case 42: { + bitField0_ |= 0x00000010; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public InjectorReq parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new InjectorReq(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string category = 1; + public static final int CATEGORY_FIELD_NUMBER = 1; + private java.lang.Object category_; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int32 length = 2; + public static final int LENGTH_FIELD_NUMBER = 2; + private int length_; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + + // required int32 group = 3; + public static final int GROUP_FIELD_NUMBER = 3; + private int group_; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + + // required int32 action = 4; + public static final int ACTION_FIELD_NUMBER = 4; + private int action_; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + + // optional bytes data = 5; + public static final int DATA_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + category_ = ""; + length_ = 0; + group_ = 0; + action_ = 0; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLength()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasGroup()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAction()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBytes(5, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.InjectorReq} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + length_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + group_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + action_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorReq_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.length_ = length_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.group_ = group_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.action_ = action_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance()) return this; + if (other.hasCategory()) { + bitField0_ |= 0x00000001; + category_ = other.category_; + onChanged(); + } + if (other.hasLength()) { + setLength(other.getLength()); + } + if (other.hasGroup()) { + setGroup(other.getGroup()); + } + if (other.hasAction()) { + setAction(other.getAction()); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCategory()) { + + return false; + } + if (!hasLength()) { + + return false; + } + if (!hasGroup()) { + + return false; + } + if (!hasAction()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string category = 1; + private java.lang.Object category_ = ""; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 1; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000001); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + + // required int32 length = 2; + private int length_ ; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + /** + * required int32 length = 2; + */ + public Builder setLength(int value) { + bitField0_ |= 0x00000002; + length_ = value; + onChanged(); + return this; + } + /** + * required int32 length = 2; + */ + public Builder clearLength() { + bitField0_ = (bitField0_ & ~0x00000002); + length_ = 0; + onChanged(); + return this; + } + + // required int32 group = 3; + private int group_ ; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + /** + * required int32 group = 3; + */ + public Builder setGroup(int value) { + bitField0_ |= 0x00000004; + group_ = value; + onChanged(); + return this; + } + /** + * required int32 group = 3; + */ + public Builder clearGroup() { + bitField0_ = (bitField0_ & ~0x00000004); + group_ = 0; + onChanged(); + return this; + } + + // required int32 action = 4; + private int action_ ; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + /** + * required int32 action = 4; + */ + public Builder setAction(int value) { + bitField0_ |= 0x00000008; + action_ = value; + onChanged(); + return this; + } + /** + * required int32 action = 4; + */ + public Builder clearAction() { + bitField0_ = (bitField0_ & ~0x00000008); + action_ = 0; + onChanged(); + return this; + } + + // optional bytes data = 5; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 5; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 5; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000010); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.InjectorReq) + } + + static { + defaultInstance = new InjectorReq(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.InjectorReq) + } + + public interface InjectorAnsOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required int32 errcode = 1; + /** + * required int32 errcode = 1; + */ + boolean hasErrcode(); + /** + * required int32 errcode = 1; + */ + int getErrcode(); + + // optional string errstr = 2; + /** + * optional string errstr = 2; + */ + boolean hasErrstr(); + /** + * optional string errstr = 2; + */ + java.lang.String getErrstr(); + /** + * optional string errstr = 2; + */ + com.google.protobuf.ByteString + getErrstrBytes(); + + // required string category = 3; + /** + * required string category = 3; + */ + boolean hasCategory(); + /** + * required string category = 3; + */ + java.lang.String getCategory(); + /** + * required string category = 3; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + } + /** + * Protobuf type {@code ECS.InjectorAns} + */ + public static final class InjectorAns extends + com.google.protobuf.GeneratedMessage + implements InjectorAnsOrBuilder { + // Use InjectorAns.newBuilder() to construct. + private InjectorAns(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private InjectorAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final InjectorAns defaultInstance; + public static InjectorAns getDefaultInstance() { + return defaultInstance; + } + + public InjectorAns getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private InjectorAns( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + errcode_ = input.readInt32(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + errstr_ = input.readBytes(); + break; + } + case 26: { + bitField0_ |= 0x00000004; + category_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public InjectorAns parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new InjectorAns(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required int32 errcode = 1; + public static final int ERRCODE_FIELD_NUMBER = 1; + private int errcode_; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + + // optional string errstr = 2; + public static final int ERRSTR_FIELD_NUMBER = 2; + private java.lang.Object errstr_; + /** + * optional string errstr = 2; + */ + public boolean hasErrstr() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string errstr = 2; + */ + public java.lang.String getErrstr() { + java.lang.Object ref = errstr_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + errstr_ = s; + } + return s; + } + } + /** + * optional string errstr = 2; + */ + public com.google.protobuf.ByteString + getErrstrBytes() { + java.lang.Object ref = errstr_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + errstr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required string category = 3; + public static final int CATEGORY_FIELD_NUMBER = 3; + private java.lang.Object category_; + /** + * required string category = 3; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string category = 3; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 3; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + errcode_ = 0; + errstr_ = ""; + category_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasErrcode()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getErrstrBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBytes(3, getCategoryBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getErrstrBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, getCategoryBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.InjectorAns} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + errcode_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + errstr_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorAns_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.errcode_ = errcode_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.errstr_ = errstr_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.category_ = category_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance()) return this; + if (other.hasErrcode()) { + setErrcode(other.getErrcode()); + } + if (other.hasErrstr()) { + bitField0_ |= 0x00000002; + errstr_ = other.errstr_; + onChanged(); + } + if (other.hasCategory()) { + bitField0_ |= 0x00000004; + category_ = other.category_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasErrcode()) { + + return false; + } + if (!hasCategory()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required int32 errcode = 1; + private int errcode_ ; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + /** + * required int32 errcode = 1; + */ + public Builder setErrcode(int value) { + bitField0_ |= 0x00000001; + errcode_ = value; + onChanged(); + return this; + } + /** + * required int32 errcode = 1; + */ + public Builder clearErrcode() { + bitField0_ = (bitField0_ & ~0x00000001); + errcode_ = 0; + onChanged(); + return this; + } + + // optional string errstr = 2; + private java.lang.Object errstr_ = ""; + /** + * optional string errstr = 2; + */ + public boolean hasErrstr() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string errstr = 2; + */ + public java.lang.String getErrstr() { + java.lang.Object ref = errstr_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + errstr_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string errstr = 2; + */ + public com.google.protobuf.ByteString + getErrstrBytes() { + java.lang.Object ref = errstr_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + errstr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string errstr = 2; + */ + public Builder setErrstr( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + errstr_ = value; + onChanged(); + return this; + } + /** + * optional string errstr = 2; + */ + public Builder clearErrstr() { + bitField0_ = (bitField0_ & ~0x00000002); + errstr_ = getDefaultInstance().getErrstr(); + onChanged(); + return this; + } + /** + * optional string errstr = 2; + */ + public Builder setErrstrBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + errstr_ = value; + onChanged(); + return this; + } + + // required string category = 3; + private java.lang.Object category_ = ""; + /** + * required string category = 3; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string category = 3; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 3; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 3; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 3; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000004); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 3; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + category_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.InjectorAns) + } + + static { + defaultInstance = new InjectorAns(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.InjectorAns) + } + + public interface InjectorNtfOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string category = 1; + /** + * required string category = 1; + */ + boolean hasCategory(); + /** + * required string category = 1; + */ + java.lang.String getCategory(); + /** + * required string category = 1; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // required int32 length = 2; + /** + * required int32 length = 2; + */ + boolean hasLength(); + /** + * required int32 length = 2; + */ + int getLength(); + + // required int32 group = 3; + /** + * required int32 group = 3; + */ + boolean hasGroup(); + /** + * required int32 group = 3; + */ + int getGroup(); + + // required int32 action = 4; + /** + * required int32 action = 4; + */ + boolean hasAction(); + /** + * required int32 action = 4; + */ + int getAction(); + + // optional bytes data = 5; + /** + * optional bytes data = 5; + */ + boolean hasData(); + /** + * optional bytes data = 5; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.InjectorNtf} + */ + public static final class InjectorNtf extends + com.google.protobuf.GeneratedMessage + implements InjectorNtfOrBuilder { + // Use InjectorNtf.newBuilder() to construct. + private InjectorNtf(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private InjectorNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final InjectorNtf defaultInstance; + public static InjectorNtf getDefaultInstance() { + return defaultInstance; + } + + public InjectorNtf getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private InjectorNtf( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + category_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + length_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + group_ = input.readInt32(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + action_ = input.readInt32(); + break; + } + case 42: { + bitField0_ |= 0x00000010; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public InjectorNtf parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new InjectorNtf(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string category = 1; + public static final int CATEGORY_FIELD_NUMBER = 1; + private java.lang.Object category_; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int32 length = 2; + public static final int LENGTH_FIELD_NUMBER = 2; + private int length_; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + + // required int32 group = 3; + public static final int GROUP_FIELD_NUMBER = 3; + private int group_; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + + // required int32 action = 4; + public static final int ACTION_FIELD_NUMBER = 4; + private int action_; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + + // optional bytes data = 5; + public static final int DATA_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + category_ = ""; + length_ = 0; + group_ = 0; + action_ = 0; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLength()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasGroup()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAction()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBytes(5, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.InjectorNtf} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + length_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + group_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + action_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_InjectorNtf_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.length_ = length_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.group_ = group_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.action_ = action_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance()) return this; + if (other.hasCategory()) { + bitField0_ |= 0x00000001; + category_ = other.category_; + onChanged(); + } + if (other.hasLength()) { + setLength(other.getLength()); + } + if (other.hasGroup()) { + setGroup(other.getGroup()); + } + if (other.hasAction()) { + setAction(other.getAction()); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCategory()) { + + return false; + } + if (!hasLength()) { + + return false; + } + if (!hasGroup()) { + + return false; + } + if (!hasAction()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string category = 1; + private java.lang.Object category_ = ""; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 1; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000001); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + + // required int32 length = 2; + private int length_ ; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + /** + * required int32 length = 2; + */ + public Builder setLength(int value) { + bitField0_ |= 0x00000002; + length_ = value; + onChanged(); + return this; + } + /** + * required int32 length = 2; + */ + public Builder clearLength() { + bitField0_ = (bitField0_ & ~0x00000002); + length_ = 0; + onChanged(); + return this; + } + + // required int32 group = 3; + private int group_ ; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + /** + * required int32 group = 3; + */ + public Builder setGroup(int value) { + bitField0_ |= 0x00000004; + group_ = value; + onChanged(); + return this; + } + /** + * required int32 group = 3; + */ + public Builder clearGroup() { + bitField0_ = (bitField0_ & ~0x00000004); + group_ = 0; + onChanged(); + return this; + } + + // required int32 action = 4; + private int action_ ; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + /** + * required int32 action = 4; + */ + public Builder setAction(int value) { + bitField0_ |= 0x00000008; + action_ = value; + onChanged(); + return this; + } + /** + * required int32 action = 4; + */ + public Builder clearAction() { + bitField0_ = (bitField0_ & ~0x00000008); + action_ = 0; + onChanged(); + return this; + } + + // optional bytes data = 5; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 5; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 5; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000010); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.InjectorNtf) + } + + static { + defaultInstance = new InjectorNtf(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.InjectorNtf) + } + + public interface DeviceReqOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string category = 1; + /** + * required string category = 1; + */ + boolean hasCategory(); + /** + * required string category = 1; + */ + java.lang.String getCategory(); + /** + * required string category = 1; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // required int32 length = 2; + /** + * required int32 length = 2; + */ + boolean hasLength(); + /** + * required int32 length = 2; + */ + int getLength(); + + // required int32 group = 3; + /** + * required int32 group = 3; + */ + boolean hasGroup(); + /** + * required int32 group = 3; + */ + int getGroup(); + + // required int32 action = 4; + /** + * required int32 action = 4; + */ + boolean hasAction(); + /** + * required int32 action = 4; + */ + int getAction(); + + // optional bytes data = 5; + /** + * optional bytes data = 5; + */ + boolean hasData(); + /** + * optional bytes data = 5; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.DeviceReq} + */ + public static final class DeviceReq extends + com.google.protobuf.GeneratedMessage + implements DeviceReqOrBuilder { + // Use DeviceReq.newBuilder() to construct. + private DeviceReq(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private DeviceReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final DeviceReq defaultInstance; + public static DeviceReq getDefaultInstance() { + return defaultInstance; + } + + public DeviceReq getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private DeviceReq( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + category_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + length_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + group_ = input.readInt32(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + action_ = input.readInt32(); + break; + } + case 42: { + bitField0_ |= 0x00000010; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public DeviceReq parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new DeviceReq(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string category = 1; + public static final int CATEGORY_FIELD_NUMBER = 1; + private java.lang.Object category_; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int32 length = 2; + public static final int LENGTH_FIELD_NUMBER = 2; + private int length_; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + + // required int32 group = 3; + public static final int GROUP_FIELD_NUMBER = 3; + private int group_; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + + // required int32 action = 4; + public static final int ACTION_FIELD_NUMBER = 4; + private int action_; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + + // optional bytes data = 5; + public static final int DATA_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + category_ = ""; + length_ = 0; + group_ = 0; + action_ = 0; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLength()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasGroup()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAction()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBytes(5, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.DeviceReq} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + length_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + group_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + action_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceReq_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.length_ = length_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.group_ = group_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.action_ = action_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance()) return this; + if (other.hasCategory()) { + bitField0_ |= 0x00000001; + category_ = other.category_; + onChanged(); + } + if (other.hasLength()) { + setLength(other.getLength()); + } + if (other.hasGroup()) { + setGroup(other.getGroup()); + } + if (other.hasAction()) { + setAction(other.getAction()); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCategory()) { + + return false; + } + if (!hasLength()) { + + return false; + } + if (!hasGroup()) { + + return false; + } + if (!hasAction()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string category = 1; + private java.lang.Object category_ = ""; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 1; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000001); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + + // required int32 length = 2; + private int length_ ; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + /** + * required int32 length = 2; + */ + public Builder setLength(int value) { + bitField0_ |= 0x00000002; + length_ = value; + onChanged(); + return this; + } + /** + * required int32 length = 2; + */ + public Builder clearLength() { + bitField0_ = (bitField0_ & ~0x00000002); + length_ = 0; + onChanged(); + return this; + } + + // required int32 group = 3; + private int group_ ; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + /** + * required int32 group = 3; + */ + public Builder setGroup(int value) { + bitField0_ |= 0x00000004; + group_ = value; + onChanged(); + return this; + } + /** + * required int32 group = 3; + */ + public Builder clearGroup() { + bitField0_ = (bitField0_ & ~0x00000004); + group_ = 0; + onChanged(); + return this; + } + + // required int32 action = 4; + private int action_ ; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + /** + * required int32 action = 4; + */ + public Builder setAction(int value) { + bitField0_ |= 0x00000008; + action_ = value; + onChanged(); + return this; + } + /** + * required int32 action = 4; + */ + public Builder clearAction() { + bitField0_ = (bitField0_ & ~0x00000008); + action_ = 0; + onChanged(); + return this; + } + + // optional bytes data = 5; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 5; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 5; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000010); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.DeviceReq) + } + + static { + defaultInstance = new DeviceReq(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.DeviceReq) + } + + public interface DeviceAnsOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required int32 errcode = 1; + /** + * required int32 errcode = 1; + */ + boolean hasErrcode(); + /** + * required int32 errcode = 1; + */ + int getErrcode(); + + // optional string errstr = 2; + /** + * optional string errstr = 2; + */ + boolean hasErrstr(); + /** + * optional string errstr = 2; + */ + java.lang.String getErrstr(); + /** + * optional string errstr = 2; + */ + com.google.protobuf.ByteString + getErrstrBytes(); + + // required string category = 3; + /** + * required string category = 3; + */ + boolean hasCategory(); + /** + * required string category = 3; + */ + java.lang.String getCategory(); + /** + * required string category = 3; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // required int32 length = 4; + /** + * required int32 length = 4; + */ + boolean hasLength(); + /** + * required int32 length = 4; + */ + int getLength(); + + // required int32 group = 5; + /** + * required int32 group = 5; + */ + boolean hasGroup(); + /** + * required int32 group = 5; + */ + int getGroup(); + + // required int32 action = 6; + /** + * required int32 action = 6; + */ + boolean hasAction(); + /** + * required int32 action = 6; + */ + int getAction(); + + // optional bytes data = 7; + /** + * optional bytes data = 7; + */ + boolean hasData(); + /** + * optional bytes data = 7; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.DeviceAns} + */ + public static final class DeviceAns extends + com.google.protobuf.GeneratedMessage + implements DeviceAnsOrBuilder { + // Use DeviceAns.newBuilder() to construct. + private DeviceAns(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private DeviceAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final DeviceAns defaultInstance; + public static DeviceAns getDefaultInstance() { + return defaultInstance; + } + + public DeviceAns getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private DeviceAns( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + errcode_ = input.readInt32(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + errstr_ = input.readBytes(); + break; + } + case 26: { + bitField0_ |= 0x00000004; + category_ = input.readBytes(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + length_ = input.readInt32(); + break; + } + case 40: { + bitField0_ |= 0x00000010; + group_ = input.readInt32(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + action_ = input.readInt32(); + break; + } + case 58: { + bitField0_ |= 0x00000040; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public DeviceAns parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new DeviceAns(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required int32 errcode = 1; + public static final int ERRCODE_FIELD_NUMBER = 1; + private int errcode_; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + + // optional string errstr = 2; + public static final int ERRSTR_FIELD_NUMBER = 2; + private java.lang.Object errstr_; + /** + * optional string errstr = 2; + */ + public boolean hasErrstr() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string errstr = 2; + */ + public java.lang.String getErrstr() { + java.lang.Object ref = errstr_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + errstr_ = s; + } + return s; + } + } + /** + * optional string errstr = 2; + */ + public com.google.protobuf.ByteString + getErrstrBytes() { + java.lang.Object ref = errstr_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + errstr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required string category = 3; + public static final int CATEGORY_FIELD_NUMBER = 3; + private java.lang.Object category_; + /** + * required string category = 3; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string category = 3; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 3; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int32 length = 4; + public static final int LENGTH_FIELD_NUMBER = 4; + private int length_; + /** + * required int32 length = 4; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 length = 4; + */ + public int getLength() { + return length_; + } + + // required int32 group = 5; + public static final int GROUP_FIELD_NUMBER = 5; + private int group_; + /** + * required int32 group = 5; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required int32 group = 5; + */ + public int getGroup() { + return group_; + } + + // required int32 action = 6; + public static final int ACTION_FIELD_NUMBER = 6; + private int action_; + /** + * required int32 action = 6; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required int32 action = 6; + */ + public int getAction() { + return action_; + } + + // optional bytes data = 7; + public static final int DATA_FIELD_NUMBER = 7; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 7; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional bytes data = 7; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + errcode_ = 0; + errstr_ = ""; + category_ = ""; + length_ = 0; + group_ = 0; + action_ = 0; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasErrcode()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLength()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasGroup()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAction()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getErrstrBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBytes(3, getCategoryBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, length_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeInt32(5, group_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeInt32(6, action_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeBytes(7, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getErrstrBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, getCategoryBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, length_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(5, group_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(6, action_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(7, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.DeviceAns} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + errcode_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + errstr_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + length_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + group_ = 0; + bitField0_ = (bitField0_ & ~0x00000010); + action_ = 0; + bitField0_ = (bitField0_ & ~0x00000020); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceAns_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.errcode_ = errcode_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.errstr_ = errstr_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.length_ = length_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.group_ = group_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + result.action_ = action_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance()) return this; + if (other.hasErrcode()) { + setErrcode(other.getErrcode()); + } + if (other.hasErrstr()) { + bitField0_ |= 0x00000002; + errstr_ = other.errstr_; + onChanged(); + } + if (other.hasCategory()) { + bitField0_ |= 0x00000004; + category_ = other.category_; + onChanged(); + } + if (other.hasLength()) { + setLength(other.getLength()); + } + if (other.hasGroup()) { + setGroup(other.getGroup()); + } + if (other.hasAction()) { + setAction(other.getAction()); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasErrcode()) { + + return false; + } + if (!hasCategory()) { + + return false; + } + if (!hasLength()) { + + return false; + } + if (!hasGroup()) { + + return false; + } + if (!hasAction()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required int32 errcode = 1; + private int errcode_ ; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + /** + * required int32 errcode = 1; + */ + public Builder setErrcode(int value) { + bitField0_ |= 0x00000001; + errcode_ = value; + onChanged(); + return this; + } + /** + * required int32 errcode = 1; + */ + public Builder clearErrcode() { + bitField0_ = (bitField0_ & ~0x00000001); + errcode_ = 0; + onChanged(); + return this; + } + + // optional string errstr = 2; + private java.lang.Object errstr_ = ""; + /** + * optional string errstr = 2; + */ + public boolean hasErrstr() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string errstr = 2; + */ + public java.lang.String getErrstr() { + java.lang.Object ref = errstr_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + errstr_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string errstr = 2; + */ + public com.google.protobuf.ByteString + getErrstrBytes() { + java.lang.Object ref = errstr_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + errstr_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string errstr = 2; + */ + public Builder setErrstr( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + errstr_ = value; + onChanged(); + return this; + } + /** + * optional string errstr = 2; + */ + public Builder clearErrstr() { + bitField0_ = (bitField0_ & ~0x00000002); + errstr_ = getDefaultInstance().getErrstr(); + onChanged(); + return this; + } + /** + * optional string errstr = 2; + */ + public Builder setErrstrBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + errstr_ = value; + onChanged(); + return this; + } + + // required string category = 3; + private java.lang.Object category_ = ""; + /** + * required string category = 3; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string category = 3; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 3; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 3; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 3; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000004); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 3; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + category_ = value; + onChanged(); + return this; + } + + // required int32 length = 4; + private int length_ ; + /** + * required int32 length = 4; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 length = 4; + */ + public int getLength() { + return length_; + } + /** + * required int32 length = 4; + */ + public Builder setLength(int value) { + bitField0_ |= 0x00000008; + length_ = value; + onChanged(); + return this; + } + /** + * required int32 length = 4; + */ + public Builder clearLength() { + bitField0_ = (bitField0_ & ~0x00000008); + length_ = 0; + onChanged(); + return this; + } + + // required int32 group = 5; + private int group_ ; + /** + * required int32 group = 5; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required int32 group = 5; + */ + public int getGroup() { + return group_; + } + /** + * required int32 group = 5; + */ + public Builder setGroup(int value) { + bitField0_ |= 0x00000010; + group_ = value; + onChanged(); + return this; + } + /** + * required int32 group = 5; + */ + public Builder clearGroup() { + bitField0_ = (bitField0_ & ~0x00000010); + group_ = 0; + onChanged(); + return this; + } + + // required int32 action = 6; + private int action_ ; + /** + * required int32 action = 6; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * required int32 action = 6; + */ + public int getAction() { + return action_; + } + /** + * required int32 action = 6; + */ + public Builder setAction(int value) { + bitField0_ |= 0x00000020; + action_ = value; + onChanged(); + return this; + } + /** + * required int32 action = 6; + */ + public Builder clearAction() { + bitField0_ = (bitField0_ & ~0x00000020); + action_ = 0; + onChanged(); + return this; + } + + // optional bytes data = 7; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 7; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional bytes data = 7; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 7; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000040; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 7; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000040); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.DeviceAns) + } + + static { + defaultInstance = new DeviceAns(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.DeviceAns) + } + + public interface DeviceNtfOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string category = 1; + /** + * required string category = 1; + */ + boolean hasCategory(); + /** + * required string category = 1; + */ + java.lang.String getCategory(); + /** + * required string category = 1; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // required int32 length = 2; + /** + * required int32 length = 2; + */ + boolean hasLength(); + /** + * required int32 length = 2; + */ + int getLength(); + + // required int32 group = 3; + /** + * required int32 group = 3; + */ + boolean hasGroup(); + /** + * required int32 group = 3; + */ + int getGroup(); + + // required int32 action = 4; + /** + * required int32 action = 4; + */ + boolean hasAction(); + /** + * required int32 action = 4; + */ + int getAction(); + + // optional bytes data = 5; + /** + * optional bytes data = 5; + */ + boolean hasData(); + /** + * optional bytes data = 5; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.DeviceNtf} + */ + public static final class DeviceNtf extends + com.google.protobuf.GeneratedMessage + implements DeviceNtfOrBuilder { + // Use DeviceNtf.newBuilder() to construct. + private DeviceNtf(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private DeviceNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final DeviceNtf defaultInstance; + public static DeviceNtf getDefaultInstance() { + return defaultInstance; + } + + public DeviceNtf getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private DeviceNtf( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + category_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + length_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + group_ = input.readInt32(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + action_ = input.readInt32(); + break; + } + case 42: { + bitField0_ |= 0x00000010; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public DeviceNtf parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new DeviceNtf(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string category = 1; + public static final int CATEGORY_FIELD_NUMBER = 1; + private java.lang.Object category_; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required int32 length = 2; + public static final int LENGTH_FIELD_NUMBER = 2; + private int length_; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + + // required int32 group = 3; + public static final int GROUP_FIELD_NUMBER = 3; + private int group_; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + + // required int32 action = 4; + public static final int ACTION_FIELD_NUMBER = 4; + private int action_; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + + // optional bytes data = 5; + public static final int DATA_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + category_ = ""; + length_ = 0; + group_ = 0; + action_ = 0; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLength()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasGroup()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasAction()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeBytes(5, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, length_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, group_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(4, action_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.DeviceNtf} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + length_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + group_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + action_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_DeviceNtf_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.length_ = length_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.group_ = group_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.action_ = action_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance()) return this; + if (other.hasCategory()) { + bitField0_ |= 0x00000001; + category_ = other.category_; + onChanged(); + } + if (other.hasLength()) { + setLength(other.getLength()); + } + if (other.hasGroup()) { + setGroup(other.getGroup()); + } + if (other.hasAction()) { + setAction(other.getAction()); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCategory()) { + + return false; + } + if (!hasLength()) { + + return false; + } + if (!hasGroup()) { + + return false; + } + if (!hasAction()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string category = 1; + private java.lang.Object category_ = ""; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 1; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000001); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + + // required int32 length = 2; + private int length_ ; + /** + * required int32 length = 2; + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required int32 length = 2; + */ + public int getLength() { + return length_; + } + /** + * required int32 length = 2; + */ + public Builder setLength(int value) { + bitField0_ |= 0x00000002; + length_ = value; + onChanged(); + return this; + } + /** + * required int32 length = 2; + */ + public Builder clearLength() { + bitField0_ = (bitField0_ & ~0x00000002); + length_ = 0; + onChanged(); + return this; + } + + // required int32 group = 3; + private int group_ ; + /** + * required int32 group = 3; + */ + public boolean hasGroup() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required int32 group = 3; + */ + public int getGroup() { + return group_; + } + /** + * required int32 group = 3; + */ + public Builder setGroup(int value) { + bitField0_ |= 0x00000004; + group_ = value; + onChanged(); + return this; + } + /** + * required int32 group = 3; + */ + public Builder clearGroup() { + bitField0_ = (bitField0_ & ~0x00000004); + group_ = 0; + onChanged(); + return this; + } + + // required int32 action = 4; + private int action_ ; + /** + * required int32 action = 4; + */ + public boolean hasAction() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 action = 4; + */ + public int getAction() { + return action_; + } + /** + * required int32 action = 4; + */ + public Builder setAction(int value) { + bitField0_ |= 0x00000008; + action_ = value; + onChanged(); + return this; + } + /** + * required int32 action = 4; + */ + public Builder clearAction() { + bitField0_ = (bitField0_ & ~0x00000008); + action_ = 0; + onChanged(); + return this; + } + + // optional bytes data = 5; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 5; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional bytes data = 5; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 5; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 5; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000010); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.DeviceNtf) + } + + static { + defaultInstance = new DeviceNtf(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.DeviceNtf) + } + + public interface MonitorReqOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string command = 1; + /** + * required string command = 1; + */ + boolean hasCommand(); + /** + * required string command = 1; + */ + java.lang.String getCommand(); + /** + * required string command = 1; + */ + com.google.protobuf.ByteString + getCommandBytes(); + } + /** + * Protobuf type {@code ECS.MonitorReq} + */ + public static final class MonitorReq extends + com.google.protobuf.GeneratedMessage + implements MonitorReqOrBuilder { + // Use MonitorReq.newBuilder() to construct. + private MonitorReq(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private MonitorReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final MonitorReq defaultInstance; + public static MonitorReq getDefaultInstance() { + return defaultInstance; + } + + public MonitorReq getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private MonitorReq( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + command_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public MonitorReq parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new MonitorReq(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string command = 1; + public static final int COMMAND_FIELD_NUMBER = 1; + private java.lang.Object command_; + /** + * required string command = 1; + */ + public boolean hasCommand() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string command = 1; + */ + public java.lang.String getCommand() { + java.lang.Object ref = command_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + command_ = s; + } + return s; + } + } + /** + * required string command = 1; + */ + public com.google.protobuf.ByteString + getCommandBytes() { + java.lang.Object ref = command_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + command_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private void initFields() { + command_ = ""; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCommand()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCommandBytes()); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCommandBytes()); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.MonitorReq} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + command_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorReq_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.command_ = command_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance()) return this; + if (other.hasCommand()) { + bitField0_ |= 0x00000001; + command_ = other.command_; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCommand()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string command = 1; + private java.lang.Object command_ = ""; + /** + * required string command = 1; + */ + public boolean hasCommand() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string command = 1; + */ + public java.lang.String getCommand() { + java.lang.Object ref = command_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + command_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string command = 1; + */ + public com.google.protobuf.ByteString + getCommandBytes() { + java.lang.Object ref = command_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + command_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string command = 1; + */ + public Builder setCommand( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + command_ = value; + onChanged(); + return this; + } + /** + * required string command = 1; + */ + public Builder clearCommand() { + bitField0_ = (bitField0_ & ~0x00000001); + command_ = getDefaultInstance().getCommand(); + onChanged(); + return this; + } + /** + * required string command = 1; + */ + public Builder setCommandBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + command_ = value; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.MonitorReq) + } + + static { + defaultInstance = new MonitorReq(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.MonitorReq) + } + + public interface MonitorAnsOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required int32 errcode = 1; + /** + * required int32 errcode = 1; + */ + boolean hasErrcode(); + /** + * required int32 errcode = 1; + */ + int getErrcode(); + + // optional string errmsg = 2; + /** + * optional string errmsg = 2; + */ + boolean hasErrmsg(); + /** + * optional string errmsg = 2; + */ + java.lang.String getErrmsg(); + /** + * optional string errmsg = 2; + */ + com.google.protobuf.ByteString + getErrmsgBytes(); + + // required string command = 3; + /** + * required string command = 3; + */ + boolean hasCommand(); + /** + * required string command = 3; + */ + java.lang.String getCommand(); + /** + * required string command = 3; + */ + com.google.protobuf.ByteString + getCommandBytes(); + + // optional bytes data = 4; + /** + * optional bytes data = 4; + */ + boolean hasData(); + /** + * optional bytes data = 4; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.MonitorAns} + */ + public static final class MonitorAns extends + com.google.protobuf.GeneratedMessage + implements MonitorAnsOrBuilder { + // Use MonitorAns.newBuilder() to construct. + private MonitorAns(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private MonitorAns(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final MonitorAns defaultInstance; + public static MonitorAns getDefaultInstance() { + return defaultInstance; + } + + public MonitorAns getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private MonitorAns( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + errcode_ = input.readInt32(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + errmsg_ = input.readBytes(); + break; + } + case 26: { + bitField0_ |= 0x00000004; + command_ = input.readBytes(); + break; + } + case 34: { + bitField0_ |= 0x00000008; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public MonitorAns parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new MonitorAns(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required int32 errcode = 1; + public static final int ERRCODE_FIELD_NUMBER = 1; + private int errcode_; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + + // optional string errmsg = 2; + public static final int ERRMSG_FIELD_NUMBER = 2; + private java.lang.Object errmsg_; + /** + * optional string errmsg = 2; + */ + public boolean hasErrmsg() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string errmsg = 2; + */ + public java.lang.String getErrmsg() { + java.lang.Object ref = errmsg_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + errmsg_ = s; + } + return s; + } + } + /** + * optional string errmsg = 2; + */ + public com.google.protobuf.ByteString + getErrmsgBytes() { + java.lang.Object ref = errmsg_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + errmsg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // required string command = 3; + public static final int COMMAND_FIELD_NUMBER = 3; + private java.lang.Object command_; + /** + * required string command = 3; + */ + public boolean hasCommand() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string command = 3; + */ + public java.lang.String getCommand() { + java.lang.Object ref = command_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + command_ = s; + } + return s; + } + } + /** + * required string command = 3; + */ + public com.google.protobuf.ByteString + getCommandBytes() { + java.lang.Object ref = command_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + command_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional bytes data = 4; + public static final int DATA_FIELD_NUMBER = 4; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 4; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional bytes data = 4; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + errcode_ = 0; + errmsg_ = ""; + command_ = ""; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasErrcode()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasCommand()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getErrmsgBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBytes(3, getCommandBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeBytes(4, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, errcode_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, getErrmsgBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, getCommandBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(4, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.MonitorAns} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + errcode_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + errmsg_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + command_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorAns_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.errcode_ = errcode_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.errmsg_ = errmsg_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.command_ = command_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance()) return this; + if (other.hasErrcode()) { + setErrcode(other.getErrcode()); + } + if (other.hasErrmsg()) { + bitField0_ |= 0x00000002; + errmsg_ = other.errmsg_; + onChanged(); + } + if (other.hasCommand()) { + bitField0_ |= 0x00000004; + command_ = other.command_; + onChanged(); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasErrcode()) { + + return false; + } + if (!hasCommand()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required int32 errcode = 1; + private int errcode_ ; + /** + * required int32 errcode = 1; + */ + public boolean hasErrcode() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required int32 errcode = 1; + */ + public int getErrcode() { + return errcode_; + } + /** + * required int32 errcode = 1; + */ + public Builder setErrcode(int value) { + bitField0_ |= 0x00000001; + errcode_ = value; + onChanged(); + return this; + } + /** + * required int32 errcode = 1; + */ + public Builder clearErrcode() { + bitField0_ = (bitField0_ & ~0x00000001); + errcode_ = 0; + onChanged(); + return this; + } + + // optional string errmsg = 2; + private java.lang.Object errmsg_ = ""; + /** + * optional string errmsg = 2; + */ + public boolean hasErrmsg() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string errmsg = 2; + */ + public java.lang.String getErrmsg() { + java.lang.Object ref = errmsg_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + errmsg_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string errmsg = 2; + */ + public com.google.protobuf.ByteString + getErrmsgBytes() { + java.lang.Object ref = errmsg_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + errmsg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string errmsg = 2; + */ + public Builder setErrmsg( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + errmsg_ = value; + onChanged(); + return this; + } + /** + * optional string errmsg = 2; + */ + public Builder clearErrmsg() { + bitField0_ = (bitField0_ & ~0x00000002); + errmsg_ = getDefaultInstance().getErrmsg(); + onChanged(); + return this; + } + /** + * optional string errmsg = 2; + */ + public Builder setErrmsgBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + errmsg_ = value; + onChanged(); + return this; + } + + // required string command = 3; + private java.lang.Object command_ = ""; + /** + * required string command = 3; + */ + public boolean hasCommand() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string command = 3; + */ + public java.lang.String getCommand() { + java.lang.Object ref = command_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + command_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string command = 3; + */ + public com.google.protobuf.ByteString + getCommandBytes() { + java.lang.Object ref = command_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + command_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string command = 3; + */ + public Builder setCommand( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + command_ = value; + onChanged(); + return this; + } + /** + * required string command = 3; + */ + public Builder clearCommand() { + bitField0_ = (bitField0_ & ~0x00000004); + command_ = getDefaultInstance().getCommand(); + onChanged(); + return this; + } + /** + * required string command = 3; + */ + public Builder setCommandBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + command_ = value; + onChanged(); + return this; + } + + // optional bytes data = 4; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 4; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional bytes data = 4; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 4; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 4; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000008); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.MonitorAns) + } + + static { + defaultInstance = new MonitorAns(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.MonitorAns) + } + + public interface MonitorNtfOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string command = 1; + /** + * required string command = 1; + */ + boolean hasCommand(); + /** + * required string command = 1; + */ + java.lang.String getCommand(); + /** + * required string command = 1; + */ + com.google.protobuf.ByteString + getCommandBytes(); + + // optional bytes data = 2; + /** + * optional bytes data = 2; + */ + boolean hasData(); + /** + * optional bytes data = 2; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.MonitorNtf} + */ + public static final class MonitorNtf extends + com.google.protobuf.GeneratedMessage + implements MonitorNtfOrBuilder { + // Use MonitorNtf.newBuilder() to construct. + private MonitorNtf(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private MonitorNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final MonitorNtf defaultInstance; + public static MonitorNtf getDefaultInstance() { + return defaultInstance; + } + + public MonitorNtf getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private MonitorNtf( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + command_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public MonitorNtf parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new MonitorNtf(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string command = 1; + public static final int COMMAND_FIELD_NUMBER = 1; + private java.lang.Object command_; + /** + * required string command = 1; + */ + public boolean hasCommand() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string command = 1; + */ + public java.lang.String getCommand() { + java.lang.Object ref = command_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + command_ = s; + } + return s; + } + } + /** + * required string command = 1; + */ + public com.google.protobuf.ByteString + getCommandBytes() { + java.lang.Object ref = command_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + command_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional bytes data = 2; + public static final int DATA_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 2; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes data = 2; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + command_ = ""; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCommand()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCommandBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCommandBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.MonitorNtf} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + command_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_MonitorNtf_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.command_ = command_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance()) return this; + if (other.hasCommand()) { + bitField0_ |= 0x00000001; + command_ = other.command_; + onChanged(); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCommand()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string command = 1; + private java.lang.Object command_ = ""; + /** + * required string command = 1; + */ + public boolean hasCommand() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string command = 1; + */ + public java.lang.String getCommand() { + java.lang.Object ref = command_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + command_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string command = 1; + */ + public com.google.protobuf.ByteString + getCommandBytes() { + java.lang.Object ref = command_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + command_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string command = 1; + */ + public Builder setCommand( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + command_ = value; + onChanged(); + return this; + } + /** + * required string command = 1; + */ + public Builder clearCommand() { + bitField0_ = (bitField0_ & ~0x00000001); + command_ = getDefaultInstance().getCommand(); + onChanged(); + return this; + } + /** + * required string command = 1; + */ + public Builder setCommandBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + command_ = value; + onChanged(); + return this; + } + + // optional bytes data = 2; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 2; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes data = 2; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 2; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 2; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000002); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.MonitorNtf) + } + + static { + defaultInstance = new MonitorNtf(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.MonitorNtf) + } + + public interface NfcReqOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string category = 1; + /** + * required string category = 1; + */ + boolean hasCategory(); + /** + * required string category = 1; + */ + java.lang.String getCategory(); + /** + * required string category = 1; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // optional bytes data = 2; + /** + * optional bytes data = 2; + */ + boolean hasData(); + /** + * optional bytes data = 2; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.NfcReq} + */ + public static final class NfcReq extends + com.google.protobuf.GeneratedMessage + implements NfcReqOrBuilder { + // Use NfcReq.newBuilder() to construct. + private NfcReq(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private NfcReq(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final NfcReq defaultInstance; + public static NfcReq getDefaultInstance() { + return defaultInstance; + } + + public NfcReq getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private NfcReq( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + category_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public NfcReq parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new NfcReq(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string category = 1; + public static final int CATEGORY_FIELD_NUMBER = 1; + private java.lang.Object category_; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional bytes data = 2; + public static final int DATA_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 2; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes data = 2; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + category_ = ""; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.NfcReq} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcReq_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance()) return this; + if (other.hasCategory()) { + bitField0_ |= 0x00000001; + category_ = other.category_; + onChanged(); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCategory()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string category = 1; + private java.lang.Object category_ = ""; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 1; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000001); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + + // optional bytes data = 2; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 2; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes data = 2; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 2; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 2; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000002); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.NfcReq) + } + + static { + defaultInstance = new NfcReq(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.NfcReq) + } + + public interface NfcNtfOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required string category = 1; + /** + * required string category = 1; + */ + boolean hasCategory(); + /** + * required string category = 1; + */ + java.lang.String getCategory(); + /** + * required string category = 1; + */ + com.google.protobuf.ByteString + getCategoryBytes(); + + // optional bytes data = 2; + /** + * optional bytes data = 2; + */ + boolean hasData(); + /** + * optional bytes data = 2; + */ + com.google.protobuf.ByteString getData(); + } + /** + * Protobuf type {@code ECS.NfcNtf} + */ + public static final class NfcNtf extends + com.google.protobuf.GeneratedMessage + implements NfcNtfOrBuilder { + // Use NfcNtf.newBuilder() to construct. + private NfcNtf(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private NfcNtf(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final NfcNtf defaultInstance; + public static NfcNtf getDefaultInstance() { + return defaultInstance; + } + + public NfcNtf getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private NfcNtf( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + category_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + data_ = input.readBytes(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public NfcNtf parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new NfcNtf(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string category = 1; + public static final int CATEGORY_FIELD_NUMBER = 1; + private java.lang.Object category_; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + category_ = s; + } + return s; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + // optional bytes data = 2; + public static final int DATA_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString data_; + /** + * optional bytes data = 2; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes data = 2; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + + private void initFields() { + category_ = ""; + data_ = com.google.protobuf.ByteString.EMPTY; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasCategory()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, data_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, getCategoryBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, data_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.NfcNtf} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + category_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + data_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_NfcNtf_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.category_ = category_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.data_ = data_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance()) return this; + if (other.hasCategory()) { + bitField0_ |= 0x00000001; + category_ = other.category_; + onChanged(); + } + if (other.hasData()) { + setData(other.getData()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasCategory()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string category = 1; + private java.lang.Object category_ = ""; + /** + * required string category = 1; + */ + public boolean hasCategory() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string category = 1; + */ + public java.lang.String getCategory() { + java.lang.Object ref = category_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((com.google.protobuf.ByteString) ref) + .toStringUtf8(); + category_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string category = 1; + */ + public com.google.protobuf.ByteString + getCategoryBytes() { + java.lang.Object ref = category_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + category_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string category = 1; + */ + public Builder setCategory( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder clearCategory() { + bitField0_ = (bitField0_ & ~0x00000001); + category_ = getDefaultInstance().getCategory(); + onChanged(); + return this; + } + /** + * required string category = 1; + */ + public Builder setCategoryBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + category_ = value; + onChanged(); + return this; + } + + // optional bytes data = 2; + private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes data = 2; + */ + public boolean hasData() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional bytes data = 2; + */ + public com.google.protobuf.ByteString getData() { + return data_; + } + /** + * optional bytes data = 2; + */ + public Builder setData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + data_ = value; + onChanged(); + return this; + } + /** + * optional bytes data = 2; + */ + public Builder clearData() { + bitField0_ = (bitField0_ & ~0x00000002); + data_ = getDefaultInstance().getData(); + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ECS.NfcNtf) + } + + static { + defaultInstance = new NfcNtf(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.NfcNtf) + } + + public interface MasterOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required .ECS.Master_Type type = 1; + /** + * required .ECS.Master_Type type = 1; + */ + boolean hasType(); + /** + * required .ECS.Master_Type type = 1; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type getType(); + + // optional .ECS.CheckVersionReq checkversion_req = 2; + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + boolean hasCheckversionReq(); + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getCheckversionReq(); + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder getCheckversionReqOrBuilder(); + + // optional .ECS.CheckVersionAns checkversion_ans = 3; + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + boolean hasCheckversionAns(); + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getCheckversionAns(); + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder getCheckversionAnsOrBuilder(); + + // optional .ECS.KeepAliveReq keepalive_req = 4; + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + boolean hasKeepaliveReq(); + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getKeepaliveReq(); + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder getKeepaliveReqOrBuilder(); + + // optional .ECS.KeepAliveAns keepalive_ans = 5; + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + boolean hasKeepaliveAns(); + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getKeepaliveAns(); + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder getKeepaliveAnsOrBuilder(); + + // optional .ECS.InjectorReq injector_req = 6; + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + boolean hasInjectorReq(); + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getInjectorReq(); + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder getInjectorReqOrBuilder(); + + // optional .ECS.InjectorAns injector_ans = 7; + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + boolean hasInjectorAns(); + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getInjectorAns(); + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder getInjectorAnsOrBuilder(); + + // optional .ECS.InjectorNtf injector_ntf = 8; + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + boolean hasInjectorNtf(); + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getInjectorNtf(); + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder getInjectorNtfOrBuilder(); + + // optional .ECS.DeviceReq device_req = 9; + /** + * optional .ECS.DeviceReq device_req = 9; + */ + boolean hasDeviceReq(); + /** + * optional .ECS.DeviceReq device_req = 9; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDeviceReq(); + /** + * optional .ECS.DeviceReq device_req = 9; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder getDeviceReqOrBuilder(); + + // optional .ECS.DeviceAns device_ans = 10; + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + boolean hasDeviceAns(); + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDeviceAns(); + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder getDeviceAnsOrBuilder(); + + // optional .ECS.DeviceNtf device_ntf = 11; + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + boolean hasDeviceNtf(); + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDeviceNtf(); + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder getDeviceNtfOrBuilder(); + + // optional .ECS.MonitorReq monitor_req = 12; + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + boolean hasMonitorReq(); + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getMonitorReq(); + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder getMonitorReqOrBuilder(); + + // optional .ECS.MonitorAns monitor_ans = 13; + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + boolean hasMonitorAns(); + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getMonitorAns(); + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder getMonitorAnsOrBuilder(); + + // optional .ECS.MonitorNtf monitor_ntf = 14; + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + boolean hasMonitorNtf(); + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getMonitorNtf(); + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder getMonitorNtfOrBuilder(); + + // optional .ECS.NfcReq nfc_req = 101; + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+     * Extensions 101 to 150;
+     *
+ */ + boolean hasNfcReq(); + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+     * Extensions 101 to 150;
+     *
+ */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getNfcReq(); + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+     * Extensions 101 to 150;
+     *
+ */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder getNfcReqOrBuilder(); + + // optional .ECS.NfcNtf nfc_ntf = 102; + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + boolean hasNfcNtf(); + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getNfcNtf(); + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder getNfcNtfOrBuilder(); + } + /** + * Protobuf type {@code ECS.Master} + */ + public static final class Master extends + com.google.protobuf.GeneratedMessage + implements MasterOrBuilder { + // Use Master.newBuilder() to construct. + private Master(com.google.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Master(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final Master defaultInstance; + public static Master getDefaultInstance() { + return defaultInstance; + } + + public Master getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Master( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type value = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = value; + } + break; + } + case 18: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = checkversionReq_.toBuilder(); + } + checkversionReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(checkversionReq_); + checkversionReq_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = checkversionAns_.toBuilder(); + } + checkversionAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(checkversionAns_); + checkversionAns_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + subBuilder = keepaliveReq_.toBuilder(); + } + keepaliveReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(keepaliveReq_); + keepaliveReq_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = keepaliveAns_.toBuilder(); + } + keepaliveAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(keepaliveAns_); + keepaliveAns_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 50: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + subBuilder = injectorReq_.toBuilder(); + } + injectorReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(injectorReq_); + injectorReq_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + case 58: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder subBuilder = null; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + subBuilder = injectorAns_.toBuilder(); + } + injectorAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(injectorAns_); + injectorAns_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000040; + break; + } + case 66: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + subBuilder = injectorNtf_.toBuilder(); + } + injectorNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(injectorNtf_); + injectorNtf_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } + case 74: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder subBuilder = null; + if (((bitField0_ & 0x00000100) == 0x00000100)) { + subBuilder = deviceReq_.toBuilder(); + } + deviceReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(deviceReq_); + deviceReq_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000100; + break; + } + case 82: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder subBuilder = null; + if (((bitField0_ & 0x00000200) == 0x00000200)) { + subBuilder = deviceAns_.toBuilder(); + } + deviceAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(deviceAns_); + deviceAns_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000200; + break; + } + case 90: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder subBuilder = null; + if (((bitField0_ & 0x00000400) == 0x00000400)) { + subBuilder = deviceNtf_.toBuilder(); + } + deviceNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(deviceNtf_); + deviceNtf_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000400; + break; + } + case 98: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder subBuilder = null; + if (((bitField0_ & 0x00000800) == 0x00000800)) { + subBuilder = monitorReq_.toBuilder(); + } + monitorReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(monitorReq_); + monitorReq_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000800; + break; + } + case 106: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder subBuilder = null; + if (((bitField0_ & 0x00001000) == 0x00001000)) { + subBuilder = monitorAns_.toBuilder(); + } + monitorAns_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(monitorAns_); + monitorAns_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00001000; + break; + } + case 114: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder subBuilder = null; + if (((bitField0_ & 0x00002000) == 0x00002000)) { + subBuilder = monitorNtf_.toBuilder(); + } + monitorNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(monitorNtf_); + monitorNtf_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00002000; + break; + } + case 810: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder subBuilder = null; + if (((bitField0_ & 0x00004000) == 0x00004000)) { + subBuilder = nfcReq_.toBuilder(); + } + nfcReq_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(nfcReq_); + nfcReq_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00004000; + break; + } + case 818: { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder subBuilder = null; + if (((bitField0_ & 0x00008000) == 0x00008000)) { + subBuilder = nfcNtf_.toBuilder(); + } + nfcNtf_ = input.readMessage(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(nfcNtf_); + nfcNtf_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00008000; + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public Master parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Master(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required .ECS.Master_Type type = 1; + public static final int TYPE_FIELD_NUMBER = 1; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type type_; + /** + * required .ECS.Master_Type type = 1; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ECS.Master_Type type = 1; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type getType() { + return type_; + } + + // optional .ECS.CheckVersionReq checkversion_req = 2; + public static final int CHECKVERSION_REQ_FIELD_NUMBER = 2; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq checkversionReq_; + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public boolean hasCheckversionReq() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getCheckversionReq() { + return checkversionReq_; + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder getCheckversionReqOrBuilder() { + return checkversionReq_; + } + + // optional .ECS.CheckVersionAns checkversion_ans = 3; + public static final int CHECKVERSION_ANS_FIELD_NUMBER = 3; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns checkversionAns_; + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public boolean hasCheckversionAns() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getCheckversionAns() { + return checkversionAns_; + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder getCheckversionAnsOrBuilder() { + return checkversionAns_; + } + + // optional .ECS.KeepAliveReq keepalive_req = 4; + public static final int KEEPALIVE_REQ_FIELD_NUMBER = 4; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq keepaliveReq_; + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public boolean hasKeepaliveReq() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getKeepaliveReq() { + return keepaliveReq_; + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder getKeepaliveReqOrBuilder() { + return keepaliveReq_; + } + + // optional .ECS.KeepAliveAns keepalive_ans = 5; + public static final int KEEPALIVE_ANS_FIELD_NUMBER = 5; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns keepaliveAns_; + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public boolean hasKeepaliveAns() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getKeepaliveAns() { + return keepaliveAns_; + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder getKeepaliveAnsOrBuilder() { + return keepaliveAns_; + } + + // optional .ECS.InjectorReq injector_req = 6; + public static final int INJECTOR_REQ_FIELD_NUMBER = 6; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq injectorReq_; + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public boolean hasInjectorReq() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getInjectorReq() { + return injectorReq_; + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder getInjectorReqOrBuilder() { + return injectorReq_; + } + + // optional .ECS.InjectorAns injector_ans = 7; + public static final int INJECTOR_ANS_FIELD_NUMBER = 7; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns injectorAns_; + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public boolean hasInjectorAns() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getInjectorAns() { + return injectorAns_; + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder getInjectorAnsOrBuilder() { + return injectorAns_; + } + + // optional .ECS.InjectorNtf injector_ntf = 8; + public static final int INJECTOR_NTF_FIELD_NUMBER = 8; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf injectorNtf_; + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public boolean hasInjectorNtf() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getInjectorNtf() { + return injectorNtf_; + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder getInjectorNtfOrBuilder() { + return injectorNtf_; + } + + // optional .ECS.DeviceReq device_req = 9; + public static final int DEVICE_REQ_FIELD_NUMBER = 9; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq deviceReq_; + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public boolean hasDeviceReq() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDeviceReq() { + return deviceReq_; + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder getDeviceReqOrBuilder() { + return deviceReq_; + } + + // optional .ECS.DeviceAns device_ans = 10; + public static final int DEVICE_ANS_FIELD_NUMBER = 10; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns deviceAns_; + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public boolean hasDeviceAns() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDeviceAns() { + return deviceAns_; + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder getDeviceAnsOrBuilder() { + return deviceAns_; + } + + // optional .ECS.DeviceNtf device_ntf = 11; + public static final int DEVICE_NTF_FIELD_NUMBER = 11; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf deviceNtf_; + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public boolean hasDeviceNtf() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDeviceNtf() { + return deviceNtf_; + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder getDeviceNtfOrBuilder() { + return deviceNtf_; + } + + // optional .ECS.MonitorReq monitor_req = 12; + public static final int MONITOR_REQ_FIELD_NUMBER = 12; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq monitorReq_; + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public boolean hasMonitorReq() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getMonitorReq() { + return monitorReq_; + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder getMonitorReqOrBuilder() { + return monitorReq_; + } + + // optional .ECS.MonitorAns monitor_ans = 13; + public static final int MONITOR_ANS_FIELD_NUMBER = 13; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns monitorAns_; + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public boolean hasMonitorAns() { + return ((bitField0_ & 0x00001000) == 0x00001000); + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getMonitorAns() { + return monitorAns_; + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder getMonitorAnsOrBuilder() { + return monitorAns_; + } + + // optional .ECS.MonitorNtf monitor_ntf = 14; + public static final int MONITOR_NTF_FIELD_NUMBER = 14; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf monitorNtf_; + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public boolean hasMonitorNtf() { + return ((bitField0_ & 0x00002000) == 0x00002000); + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getMonitorNtf() { + return monitorNtf_; + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder getMonitorNtfOrBuilder() { + return monitorNtf_; + } + + // optional .ECS.NfcReq nfc_req = 101; + public static final int NFC_REQ_FIELD_NUMBER = 101; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq nfcReq_; + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+     * Extensions 101 to 150;
+     *
+ */ + public boolean hasNfcReq() { + return ((bitField0_ & 0x00004000) == 0x00004000); + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+     * Extensions 101 to 150;
+     *
+ */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getNfcReq() { + return nfcReq_; + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+     * Extensions 101 to 150;
+     *
+ */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder getNfcReqOrBuilder() { + return nfcReq_; + } + + // optional .ECS.NfcNtf nfc_ntf = 102; + public static final int NFC_NTF_FIELD_NUMBER = 102; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf nfcNtf_; + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public boolean hasNfcNtf() { + return ((bitField0_ & 0x00008000) == 0x00008000); + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getNfcNtf() { + return nfcNtf_; + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder getNfcNtfOrBuilder() { + return nfcNtf_; + } + + private void initFields() { + type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ; + checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance(); + checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance(); + keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance(); + keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance(); + injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance(); + injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance(); + injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance(); + deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance(); + deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance(); + deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance(); + monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance(); + monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance(); + monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance(); + nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance(); + nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasCheckversionReq()) { + if (!getCheckversionReq().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasCheckversionAns()) { + if (!getCheckversionAns().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasInjectorReq()) { + if (!getInjectorReq().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasInjectorAns()) { + if (!getInjectorAns().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasInjectorNtf()) { + if (!getInjectorNtf().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDeviceReq()) { + if (!getDeviceReq().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDeviceAns()) { + if (!getDeviceAns().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDeviceNtf()) { + if (!getDeviceNtf().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasMonitorReq()) { + if (!getMonitorReq().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasMonitorAns()) { + if (!getMonitorAns().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasMonitorNtf()) { + if (!getMonitorNtf().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasNfcReq()) { + if (!getNfcReq().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasNfcNtf()) { + if (!getNfcNtf().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, type_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, checkversionReq_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, checkversionAns_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, keepaliveReq_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, keepaliveAns_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeMessage(6, injectorReq_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeMessage(7, injectorAns_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeMessage(8, injectorNtf_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + output.writeMessage(9, deviceReq_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + output.writeMessage(10, deviceAns_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + output.writeMessage(11, deviceNtf_); + } + if (((bitField0_ & 0x00000800) == 0x00000800)) { + output.writeMessage(12, monitorReq_); + } + if (((bitField0_ & 0x00001000) == 0x00001000)) { + output.writeMessage(13, monitorAns_); + } + if (((bitField0_ & 0x00002000) == 0x00002000)) { + output.writeMessage(14, monitorNtf_); + } + if (((bitField0_ & 0x00004000) == 0x00004000)) { + output.writeMessage(101, nfcReq_); + } + if (((bitField0_ & 0x00008000) == 0x00008000)) { + output.writeMessage(102, nfcNtf_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, checkversionReq_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, checkversionAns_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, keepaliveReq_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, keepaliveAns_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, injectorReq_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, injectorAns_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, injectorNtf_); + } + if (((bitField0_ & 0x00000100) == 0x00000100)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, deviceReq_); + } + if (((bitField0_ & 0x00000200) == 0x00000200)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(10, deviceAns_); + } + if (((bitField0_ & 0x00000400) == 0x00000400)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(11, deviceNtf_); + } + if (((bitField0_ & 0x00000800) == 0x00000800)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(12, monitorReq_); + } + if (((bitField0_ & 0x00001000) == 0x00001000)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(13, monitorAns_); + } + if (((bitField0_ & 0x00002000) == 0x00002000)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(14, monitorNtf_); + } + if (((bitField0_ & 0x00004000) == 0x00004000)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(101, nfcReq_); + } + if (((bitField0_ & 0x00008000) == 0x00008000)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(102, nfcNtf_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ECS.Master} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MasterOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.class, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.Builder.class); + } + + // Construct using org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getCheckversionReqFieldBuilder(); + getCheckversionAnsFieldBuilder(); + getKeepaliveReqFieldBuilder(); + getKeepaliveAnsFieldBuilder(); + getInjectorReqFieldBuilder(); + getInjectorAnsFieldBuilder(); + getInjectorNtfFieldBuilder(); + getDeviceReqFieldBuilder(); + getDeviceAnsFieldBuilder(); + getDeviceNtfFieldBuilder(); + getMonitorReqFieldBuilder(); + getMonitorAnsFieldBuilder(); + getMonitorNtfFieldBuilder(); + getNfcReqFieldBuilder(); + getNfcNtfFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ; + bitField0_ = (bitField0_ & ~0x00000001); + if (checkversionReqBuilder_ == null) { + checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance(); + } else { + checkversionReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + if (checkversionAnsBuilder_ == null) { + checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance(); + } else { + checkversionAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (keepaliveReqBuilder_ == null) { + keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance(); + } else { + keepaliveReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (keepaliveAnsBuilder_ == null) { + keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance(); + } else { + keepaliveAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + if (injectorReqBuilder_ == null) { + injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance(); + } else { + injectorReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + if (injectorAnsBuilder_ == null) { + injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance(); + } else { + injectorAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + if (injectorNtfBuilder_ == null) { + injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance(); + } else { + injectorNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + if (deviceReqBuilder_ == null) { + deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance(); + } else { + deviceReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + if (deviceAnsBuilder_ == null) { + deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance(); + } else { + deviceAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000200); + if (deviceNtfBuilder_ == null) { + deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance(); + } else { + deviceNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000400); + if (monitorReqBuilder_ == null) { + monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance(); + } else { + monitorReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000800); + if (monitorAnsBuilder_ == null) { + monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance(); + } else { + monitorAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00001000); + if (monitorNtfBuilder_ == null) { + monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance(); + } else { + monitorNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00002000); + if (nfcReqBuilder_ == null) { + nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance(); + } else { + nfcReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00004000); + if (nfcNtfBuilder_ == null) { + nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance(); + } else { + nfcNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00008000); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.internal_static_ECS_Master_descriptor; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master getDefaultInstanceForType() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.getDefaultInstance(); + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master build() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master buildPartial() { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master result = new org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + if (checkversionReqBuilder_ == null) { + result.checkversionReq_ = checkversionReq_; + } else { + result.checkversionReq_ = checkversionReqBuilder_.build(); + } + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + if (checkversionAnsBuilder_ == null) { + result.checkversionAns_ = checkversionAns_; + } else { + result.checkversionAns_ = checkversionAnsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + if (keepaliveReqBuilder_ == null) { + result.keepaliveReq_ = keepaliveReq_; + } else { + result.keepaliveReq_ = keepaliveReqBuilder_.build(); + } + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + if (keepaliveAnsBuilder_ == null) { + result.keepaliveAns_ = keepaliveAns_; + } else { + result.keepaliveAns_ = keepaliveAnsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000020; + } + if (injectorReqBuilder_ == null) { + result.injectorReq_ = injectorReq_; + } else { + result.injectorReq_ = injectorReqBuilder_.build(); + } + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000040; + } + if (injectorAnsBuilder_ == null) { + result.injectorAns_ = injectorAns_; + } else { + result.injectorAns_ = injectorAnsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000080; + } + if (injectorNtfBuilder_ == null) { + result.injectorNtf_ = injectorNtf_; + } else { + result.injectorNtf_ = injectorNtfBuilder_.build(); + } + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000100; + } + if (deviceReqBuilder_ == null) { + result.deviceReq_ = deviceReq_; + } else { + result.deviceReq_ = deviceReqBuilder_.build(); + } + if (((from_bitField0_ & 0x00000200) == 0x00000200)) { + to_bitField0_ |= 0x00000200; + } + if (deviceAnsBuilder_ == null) { + result.deviceAns_ = deviceAns_; + } else { + result.deviceAns_ = deviceAnsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000400) == 0x00000400)) { + to_bitField0_ |= 0x00000400; + } + if (deviceNtfBuilder_ == null) { + result.deviceNtf_ = deviceNtf_; + } else { + result.deviceNtf_ = deviceNtfBuilder_.build(); + } + if (((from_bitField0_ & 0x00000800) == 0x00000800)) { + to_bitField0_ |= 0x00000800; + } + if (monitorReqBuilder_ == null) { + result.monitorReq_ = monitorReq_; + } else { + result.monitorReq_ = monitorReqBuilder_.build(); + } + if (((from_bitField0_ & 0x00001000) == 0x00001000)) { + to_bitField0_ |= 0x00001000; + } + if (monitorAnsBuilder_ == null) { + result.monitorAns_ = monitorAns_; + } else { + result.monitorAns_ = monitorAnsBuilder_.build(); + } + if (((from_bitField0_ & 0x00002000) == 0x00002000)) { + to_bitField0_ |= 0x00002000; + } + if (monitorNtfBuilder_ == null) { + result.monitorNtf_ = monitorNtf_; + } else { + result.monitorNtf_ = monitorNtfBuilder_.build(); + } + if (((from_bitField0_ & 0x00004000) == 0x00004000)) { + to_bitField0_ |= 0x00004000; + } + if (nfcReqBuilder_ == null) { + result.nfcReq_ = nfcReq_; + } else { + result.nfcReq_ = nfcReqBuilder_.build(); + } + if (((from_bitField0_ & 0x00008000) == 0x00008000)) { + to_bitField0_ |= 0x00008000; + } + if (nfcNtfBuilder_ == null) { + result.nfcNtf_ = nfcNtf_; + } else { + result.nfcNtf_ = nfcNtfBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master) { + return mergeFrom((org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master other) { + if (other == org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasCheckversionReq()) { + mergeCheckversionReq(other.getCheckversionReq()); + } + if (other.hasCheckversionAns()) { + mergeCheckversionAns(other.getCheckversionAns()); + } + if (other.hasKeepaliveReq()) { + mergeKeepaliveReq(other.getKeepaliveReq()); + } + if (other.hasKeepaliveAns()) { + mergeKeepaliveAns(other.getKeepaliveAns()); + } + if (other.hasInjectorReq()) { + mergeInjectorReq(other.getInjectorReq()); + } + if (other.hasInjectorAns()) { + mergeInjectorAns(other.getInjectorAns()); + } + if (other.hasInjectorNtf()) { + mergeInjectorNtf(other.getInjectorNtf()); + } + if (other.hasDeviceReq()) { + mergeDeviceReq(other.getDeviceReq()); + } + if (other.hasDeviceAns()) { + mergeDeviceAns(other.getDeviceAns()); + } + if (other.hasDeviceNtf()) { + mergeDeviceNtf(other.getDeviceNtf()); + } + if (other.hasMonitorReq()) { + mergeMonitorReq(other.getMonitorReq()); + } + if (other.hasMonitorAns()) { + mergeMonitorAns(other.getMonitorAns()); + } + if (other.hasMonitorNtf()) { + mergeMonitorNtf(other.getMonitorNtf()); + } + if (other.hasNfcReq()) { + mergeNfcReq(other.getNfcReq()); + } + if (other.hasNfcNtf()) { + mergeNfcNtf(other.getNfcNtf()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasType()) { + + return false; + } + if (hasCheckversionReq()) { + if (!getCheckversionReq().isInitialized()) { + + return false; + } + } + if (hasCheckversionAns()) { + if (!getCheckversionAns().isInitialized()) { + + return false; + } + } + if (hasInjectorReq()) { + if (!getInjectorReq().isInitialized()) { + + return false; + } + } + if (hasInjectorAns()) { + if (!getInjectorAns().isInitialized()) { + + return false; + } + } + if (hasInjectorNtf()) { + if (!getInjectorNtf().isInitialized()) { + + return false; + } + } + if (hasDeviceReq()) { + if (!getDeviceReq().isInitialized()) { + + return false; + } + } + if (hasDeviceAns()) { + if (!getDeviceAns().isInitialized()) { + + return false; + } + } + if (hasDeviceNtf()) { + if (!getDeviceNtf().isInitialized()) { + + return false; + } + } + if (hasMonitorReq()) { + if (!getMonitorReq().isInitialized()) { + + return false; + } + } + if (hasMonitorAns()) { + if (!getMonitorAns().isInitialized()) { + + return false; + } + } + if (hasMonitorNtf()) { + if (!getMonitorNtf().isInitialized()) { + + return false; + } + } + if (hasNfcReq()) { + if (!getNfcReq().isInitialized()) { + + return false; + } + } + if (hasNfcNtf()) { + if (!getNfcNtf().isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.Master) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required .ECS.Master_Type type = 1; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ; + /** + * required .ECS.Master_Type type = 1; + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .ECS.Master_Type type = 1; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type getType() { + return type_; + } + /** + * required .ECS.Master_Type type = 1; + */ + public Builder setType(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value; + onChanged(); + return this; + } + /** + * required .ECS.Master_Type type = 1; + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.Master_Type.CHECKVERSION_REQ; + onChanged(); + return this; + } + + // optional .ECS.CheckVersionReq checkversion_req = 2; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder> checkversionReqBuilder_; + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public boolean hasCheckversionReq() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq getCheckversionReq() { + if (checkversionReqBuilder_ == null) { + return checkversionReq_; + } else { + return checkversionReqBuilder_.getMessage(); + } + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public Builder setCheckversionReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq value) { + if (checkversionReqBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + checkversionReq_ = value; + onChanged(); + } else { + checkversionReqBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public Builder setCheckversionReq( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder builderForValue) { + if (checkversionReqBuilder_ == null) { + checkversionReq_ = builderForValue.build(); + onChanged(); + } else { + checkversionReqBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public Builder mergeCheckversionReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq value) { + if (checkversionReqBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + checkversionReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance()) { + checkversionReq_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.newBuilder(checkversionReq_).mergeFrom(value).buildPartial(); + } else { + checkversionReq_ = value; + } + onChanged(); + } else { + checkversionReqBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public Builder clearCheckversionReq() { + if (checkversionReqBuilder_ == null) { + checkversionReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.getDefaultInstance(); + onChanged(); + } else { + checkversionReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder getCheckversionReqBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getCheckversionReqFieldBuilder().getBuilder(); + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder getCheckversionReqOrBuilder() { + if (checkversionReqBuilder_ != null) { + return checkversionReqBuilder_.getMessageOrBuilder(); + } else { + return checkversionReq_; + } + } + /** + * optional .ECS.CheckVersionReq checkversion_req = 2; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder> + getCheckversionReqFieldBuilder() { + if (checkversionReqBuilder_ == null) { + checkversionReqBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionReqOrBuilder>( + checkversionReq_, + getParentForChildren(), + isClean()); + checkversionReq_ = null; + } + return checkversionReqBuilder_; + } + + // optional .ECS.CheckVersionAns checkversion_ans = 3; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder> checkversionAnsBuilder_; + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public boolean hasCheckversionAns() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns getCheckversionAns() { + if (checkversionAnsBuilder_ == null) { + return checkversionAns_; + } else { + return checkversionAnsBuilder_.getMessage(); + } + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public Builder setCheckversionAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns value) { + if (checkversionAnsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + checkversionAns_ = value; + onChanged(); + } else { + checkversionAnsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public Builder setCheckversionAns( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder builderForValue) { + if (checkversionAnsBuilder_ == null) { + checkversionAns_ = builderForValue.build(); + onChanged(); + } else { + checkversionAnsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public Builder mergeCheckversionAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns value) { + if (checkversionAnsBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + checkversionAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance()) { + checkversionAns_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.newBuilder(checkversionAns_).mergeFrom(value).buildPartial(); + } else { + checkversionAns_ = value; + } + onChanged(); + } else { + checkversionAnsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public Builder clearCheckversionAns() { + if (checkversionAnsBuilder_ == null) { + checkversionAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.getDefaultInstance(); + onChanged(); + } else { + checkversionAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder getCheckversionAnsBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCheckversionAnsFieldBuilder().getBuilder(); + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder getCheckversionAnsOrBuilder() { + if (checkversionAnsBuilder_ != null) { + return checkversionAnsBuilder_.getMessageOrBuilder(); + } else { + return checkversionAns_; + } + } + /** + * optional .ECS.CheckVersionAns checkversion_ans = 3; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder> + getCheckversionAnsFieldBuilder() { + if (checkversionAnsBuilder_ == null) { + checkversionAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.CheckVersionAnsOrBuilder>( + checkversionAns_, + getParentForChildren(), + isClean()); + checkversionAns_ = null; + } + return checkversionAnsBuilder_; + } + + // optional .ECS.KeepAliveReq keepalive_req = 4; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder> keepaliveReqBuilder_; + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public boolean hasKeepaliveReq() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq getKeepaliveReq() { + if (keepaliveReqBuilder_ == null) { + return keepaliveReq_; + } else { + return keepaliveReqBuilder_.getMessage(); + } + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public Builder setKeepaliveReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq value) { + if (keepaliveReqBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + keepaliveReq_ = value; + onChanged(); + } else { + keepaliveReqBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public Builder setKeepaliveReq( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder builderForValue) { + if (keepaliveReqBuilder_ == null) { + keepaliveReq_ = builderForValue.build(); + onChanged(); + } else { + keepaliveReqBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public Builder mergeKeepaliveReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq value) { + if (keepaliveReqBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + keepaliveReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance()) { + keepaliveReq_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.newBuilder(keepaliveReq_).mergeFrom(value).buildPartial(); + } else { + keepaliveReq_ = value; + } + onChanged(); + } else { + keepaliveReqBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public Builder clearKeepaliveReq() { + if (keepaliveReqBuilder_ == null) { + keepaliveReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.getDefaultInstance(); + onChanged(); + } else { + keepaliveReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder getKeepaliveReqBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getKeepaliveReqFieldBuilder().getBuilder(); + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder getKeepaliveReqOrBuilder() { + if (keepaliveReqBuilder_ != null) { + return keepaliveReqBuilder_.getMessageOrBuilder(); + } else { + return keepaliveReq_; + } + } + /** + * optional .ECS.KeepAliveReq keepalive_req = 4; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder> + getKeepaliveReqFieldBuilder() { + if (keepaliveReqBuilder_ == null) { + keepaliveReqBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveReqOrBuilder>( + keepaliveReq_, + getParentForChildren(), + isClean()); + keepaliveReq_ = null; + } + return keepaliveReqBuilder_; + } + + // optional .ECS.KeepAliveAns keepalive_ans = 5; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder> keepaliveAnsBuilder_; + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public boolean hasKeepaliveAns() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns getKeepaliveAns() { + if (keepaliveAnsBuilder_ == null) { + return keepaliveAns_; + } else { + return keepaliveAnsBuilder_.getMessage(); + } + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public Builder setKeepaliveAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns value) { + if (keepaliveAnsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + keepaliveAns_ = value; + onChanged(); + } else { + keepaliveAnsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public Builder setKeepaliveAns( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder builderForValue) { + if (keepaliveAnsBuilder_ == null) { + keepaliveAns_ = builderForValue.build(); + onChanged(); + } else { + keepaliveAnsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public Builder mergeKeepaliveAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns value) { + if (keepaliveAnsBuilder_ == null) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + keepaliveAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance()) { + keepaliveAns_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.newBuilder(keepaliveAns_).mergeFrom(value).buildPartial(); + } else { + keepaliveAns_ = value; + } + onChanged(); + } else { + keepaliveAnsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public Builder clearKeepaliveAns() { + if (keepaliveAnsBuilder_ == null) { + keepaliveAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.getDefaultInstance(); + onChanged(); + } else { + keepaliveAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder getKeepaliveAnsBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getKeepaliveAnsFieldBuilder().getBuilder(); + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder getKeepaliveAnsOrBuilder() { + if (keepaliveAnsBuilder_ != null) { + return keepaliveAnsBuilder_.getMessageOrBuilder(); + } else { + return keepaliveAns_; + } + } + /** + * optional .ECS.KeepAliveAns keepalive_ans = 5; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder> + getKeepaliveAnsFieldBuilder() { + if (keepaliveAnsBuilder_ == null) { + keepaliveAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.KeepAliveAnsOrBuilder>( + keepaliveAns_, + getParentForChildren(), + isClean()); + keepaliveAns_ = null; + } + return keepaliveAnsBuilder_; + } + + // optional .ECS.InjectorReq injector_req = 6; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder> injectorReqBuilder_; + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public boolean hasInjectorReq() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq getInjectorReq() { + if (injectorReqBuilder_ == null) { + return injectorReq_; + } else { + return injectorReqBuilder_.getMessage(); + } + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public Builder setInjectorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq value) { + if (injectorReqBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + injectorReq_ = value; + onChanged(); + } else { + injectorReqBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public Builder setInjectorReq( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder builderForValue) { + if (injectorReqBuilder_ == null) { + injectorReq_ = builderForValue.build(); + onChanged(); + } else { + injectorReqBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public Builder mergeInjectorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq value) { + if (injectorReqBuilder_ == null) { + if (((bitField0_ & 0x00000020) == 0x00000020) && + injectorReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance()) { + injectorReq_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.newBuilder(injectorReq_).mergeFrom(value).buildPartial(); + } else { + injectorReq_ = value; + } + onChanged(); + } else { + injectorReqBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public Builder clearInjectorReq() { + if (injectorReqBuilder_ == null) { + injectorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.getDefaultInstance(); + onChanged(); + } else { + injectorReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder getInjectorReqBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getInjectorReqFieldBuilder().getBuilder(); + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder getInjectorReqOrBuilder() { + if (injectorReqBuilder_ != null) { + return injectorReqBuilder_.getMessageOrBuilder(); + } else { + return injectorReq_; + } + } + /** + * optional .ECS.InjectorReq injector_req = 6; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder> + getInjectorReqFieldBuilder() { + if (injectorReqBuilder_ == null) { + injectorReqBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorReqOrBuilder>( + injectorReq_, + getParentForChildren(), + isClean()); + injectorReq_ = null; + } + return injectorReqBuilder_; + } + + // optional .ECS.InjectorAns injector_ans = 7; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder> injectorAnsBuilder_; + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public boolean hasInjectorAns() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns getInjectorAns() { + if (injectorAnsBuilder_ == null) { + return injectorAns_; + } else { + return injectorAnsBuilder_.getMessage(); + } + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public Builder setInjectorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns value) { + if (injectorAnsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + injectorAns_ = value; + onChanged(); + } else { + injectorAnsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public Builder setInjectorAns( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder builderForValue) { + if (injectorAnsBuilder_ == null) { + injectorAns_ = builderForValue.build(); + onChanged(); + } else { + injectorAnsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public Builder mergeInjectorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns value) { + if (injectorAnsBuilder_ == null) { + if (((bitField0_ & 0x00000040) == 0x00000040) && + injectorAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance()) { + injectorAns_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.newBuilder(injectorAns_).mergeFrom(value).buildPartial(); + } else { + injectorAns_ = value; + } + onChanged(); + } else { + injectorAnsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public Builder clearInjectorAns() { + if (injectorAnsBuilder_ == null) { + injectorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.getDefaultInstance(); + onChanged(); + } else { + injectorAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder getInjectorAnsBuilder() { + bitField0_ |= 0x00000040; + onChanged(); + return getInjectorAnsFieldBuilder().getBuilder(); + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder getInjectorAnsOrBuilder() { + if (injectorAnsBuilder_ != null) { + return injectorAnsBuilder_.getMessageOrBuilder(); + } else { + return injectorAns_; + } + } + /** + * optional .ECS.InjectorAns injector_ans = 7; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder> + getInjectorAnsFieldBuilder() { + if (injectorAnsBuilder_ == null) { + injectorAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorAnsOrBuilder>( + injectorAns_, + getParentForChildren(), + isClean()); + injectorAns_ = null; + } + return injectorAnsBuilder_; + } + + // optional .ECS.InjectorNtf injector_ntf = 8; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder> injectorNtfBuilder_; + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public boolean hasInjectorNtf() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf getInjectorNtf() { + if (injectorNtfBuilder_ == null) { + return injectorNtf_; + } else { + return injectorNtfBuilder_.getMessage(); + } + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public Builder setInjectorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf value) { + if (injectorNtfBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + injectorNtf_ = value; + onChanged(); + } else { + injectorNtfBuilder_.setMessage(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public Builder setInjectorNtf( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder builderForValue) { + if (injectorNtfBuilder_ == null) { + injectorNtf_ = builderForValue.build(); + onChanged(); + } else { + injectorNtfBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public Builder mergeInjectorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf value) { + if (injectorNtfBuilder_ == null) { + if (((bitField0_ & 0x00000080) == 0x00000080) && + injectorNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance()) { + injectorNtf_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.newBuilder(injectorNtf_).mergeFrom(value).buildPartial(); + } else { + injectorNtf_ = value; + } + onChanged(); + } else { + injectorNtfBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public Builder clearInjectorNtf() { + if (injectorNtfBuilder_ == null) { + injectorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.getDefaultInstance(); + onChanged(); + } else { + injectorNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder getInjectorNtfBuilder() { + bitField0_ |= 0x00000080; + onChanged(); + return getInjectorNtfFieldBuilder().getBuilder(); + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder getInjectorNtfOrBuilder() { + if (injectorNtfBuilder_ != null) { + return injectorNtfBuilder_.getMessageOrBuilder(); + } else { + return injectorNtf_; + } + } + /** + * optional .ECS.InjectorNtf injector_ntf = 8; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder> + getInjectorNtfFieldBuilder() { + if (injectorNtfBuilder_ == null) { + injectorNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.InjectorNtfOrBuilder>( + injectorNtf_, + getParentForChildren(), + isClean()); + injectorNtf_ = null; + } + return injectorNtfBuilder_; + } + + // optional .ECS.DeviceReq device_req = 9; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder> deviceReqBuilder_; + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public boolean hasDeviceReq() { + return ((bitField0_ & 0x00000100) == 0x00000100); + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq getDeviceReq() { + if (deviceReqBuilder_ == null) { + return deviceReq_; + } else { + return deviceReqBuilder_.getMessage(); + } + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public Builder setDeviceReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq value) { + if (deviceReqBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + deviceReq_ = value; + onChanged(); + } else { + deviceReqBuilder_.setMessage(value); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public Builder setDeviceReq( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder builderForValue) { + if (deviceReqBuilder_ == null) { + deviceReq_ = builderForValue.build(); + onChanged(); + } else { + deviceReqBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public Builder mergeDeviceReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq value) { + if (deviceReqBuilder_ == null) { + if (((bitField0_ & 0x00000100) == 0x00000100) && + deviceReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance()) { + deviceReq_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.newBuilder(deviceReq_).mergeFrom(value).buildPartial(); + } else { + deviceReq_ = value; + } + onChanged(); + } else { + deviceReqBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public Builder clearDeviceReq() { + if (deviceReqBuilder_ == null) { + deviceReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.getDefaultInstance(); + onChanged(); + } else { + deviceReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder getDeviceReqBuilder() { + bitField0_ |= 0x00000100; + onChanged(); + return getDeviceReqFieldBuilder().getBuilder(); + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder getDeviceReqOrBuilder() { + if (deviceReqBuilder_ != null) { + return deviceReqBuilder_.getMessageOrBuilder(); + } else { + return deviceReq_; + } + } + /** + * optional .ECS.DeviceReq device_req = 9; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder> + getDeviceReqFieldBuilder() { + if (deviceReqBuilder_ == null) { + deviceReqBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceReqOrBuilder>( + deviceReq_, + getParentForChildren(), + isClean()); + deviceReq_ = null; + } + return deviceReqBuilder_; + } + + // optional .ECS.DeviceAns device_ans = 10; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder> deviceAnsBuilder_; + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public boolean hasDeviceAns() { + return ((bitField0_ & 0x00000200) == 0x00000200); + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns getDeviceAns() { + if (deviceAnsBuilder_ == null) { + return deviceAns_; + } else { + return deviceAnsBuilder_.getMessage(); + } + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public Builder setDeviceAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns value) { + if (deviceAnsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + deviceAns_ = value; + onChanged(); + } else { + deviceAnsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public Builder setDeviceAns( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder builderForValue) { + if (deviceAnsBuilder_ == null) { + deviceAns_ = builderForValue.build(); + onChanged(); + } else { + deviceAnsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public Builder mergeDeviceAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns value) { + if (deviceAnsBuilder_ == null) { + if (((bitField0_ & 0x00000200) == 0x00000200) && + deviceAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance()) { + deviceAns_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.newBuilder(deviceAns_).mergeFrom(value).buildPartial(); + } else { + deviceAns_ = value; + } + onChanged(); + } else { + deviceAnsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000200; + return this; + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public Builder clearDeviceAns() { + if (deviceAnsBuilder_ == null) { + deviceAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.getDefaultInstance(); + onChanged(); + } else { + deviceAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder getDeviceAnsBuilder() { + bitField0_ |= 0x00000200; + onChanged(); + return getDeviceAnsFieldBuilder().getBuilder(); + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder getDeviceAnsOrBuilder() { + if (deviceAnsBuilder_ != null) { + return deviceAnsBuilder_.getMessageOrBuilder(); + } else { + return deviceAns_; + } + } + /** + * optional .ECS.DeviceAns device_ans = 10; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder> + getDeviceAnsFieldBuilder() { + if (deviceAnsBuilder_ == null) { + deviceAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceAnsOrBuilder>( + deviceAns_, + getParentForChildren(), + isClean()); + deviceAns_ = null; + } + return deviceAnsBuilder_; + } + + // optional .ECS.DeviceNtf device_ntf = 11; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder> deviceNtfBuilder_; + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public boolean hasDeviceNtf() { + return ((bitField0_ & 0x00000400) == 0x00000400); + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf getDeviceNtf() { + if (deviceNtfBuilder_ == null) { + return deviceNtf_; + } else { + return deviceNtfBuilder_.getMessage(); + } + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public Builder setDeviceNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf value) { + if (deviceNtfBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + deviceNtf_ = value; + onChanged(); + } else { + deviceNtfBuilder_.setMessage(value); + } + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public Builder setDeviceNtf( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder builderForValue) { + if (deviceNtfBuilder_ == null) { + deviceNtf_ = builderForValue.build(); + onChanged(); + } else { + deviceNtfBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public Builder mergeDeviceNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf value) { + if (deviceNtfBuilder_ == null) { + if (((bitField0_ & 0x00000400) == 0x00000400) && + deviceNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance()) { + deviceNtf_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.newBuilder(deviceNtf_).mergeFrom(value).buildPartial(); + } else { + deviceNtf_ = value; + } + onChanged(); + } else { + deviceNtfBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000400; + return this; + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public Builder clearDeviceNtf() { + if (deviceNtfBuilder_ == null) { + deviceNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.getDefaultInstance(); + onChanged(); + } else { + deviceNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000400); + return this; + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder getDeviceNtfBuilder() { + bitField0_ |= 0x00000400; + onChanged(); + return getDeviceNtfFieldBuilder().getBuilder(); + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder getDeviceNtfOrBuilder() { + if (deviceNtfBuilder_ != null) { + return deviceNtfBuilder_.getMessageOrBuilder(); + } else { + return deviceNtf_; + } + } + /** + * optional .ECS.DeviceNtf device_ntf = 11; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder> + getDeviceNtfFieldBuilder() { + if (deviceNtfBuilder_ == null) { + deviceNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.DeviceNtfOrBuilder>( + deviceNtf_, + getParentForChildren(), + isClean()); + deviceNtf_ = null; + } + return deviceNtfBuilder_; + } + + // optional .ECS.MonitorReq monitor_req = 12; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder> monitorReqBuilder_; + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public boolean hasMonitorReq() { + return ((bitField0_ & 0x00000800) == 0x00000800); + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq getMonitorReq() { + if (monitorReqBuilder_ == null) { + return monitorReq_; + } else { + return monitorReqBuilder_.getMessage(); + } + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public Builder setMonitorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq value) { + if (monitorReqBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + monitorReq_ = value; + onChanged(); + } else { + monitorReqBuilder_.setMessage(value); + } + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public Builder setMonitorReq( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder builderForValue) { + if (monitorReqBuilder_ == null) { + monitorReq_ = builderForValue.build(); + onChanged(); + } else { + monitorReqBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public Builder mergeMonitorReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq value) { + if (monitorReqBuilder_ == null) { + if (((bitField0_ & 0x00000800) == 0x00000800) && + monitorReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance()) { + monitorReq_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.newBuilder(monitorReq_).mergeFrom(value).buildPartial(); + } else { + monitorReq_ = value; + } + onChanged(); + } else { + monitorReqBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000800; + return this; + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public Builder clearMonitorReq() { + if (monitorReqBuilder_ == null) { + monitorReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.getDefaultInstance(); + onChanged(); + } else { + monitorReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder getMonitorReqBuilder() { + bitField0_ |= 0x00000800; + onChanged(); + return getMonitorReqFieldBuilder().getBuilder(); + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder getMonitorReqOrBuilder() { + if (monitorReqBuilder_ != null) { + return monitorReqBuilder_.getMessageOrBuilder(); + } else { + return monitorReq_; + } + } + /** + * optional .ECS.MonitorReq monitor_req = 12; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder> + getMonitorReqFieldBuilder() { + if (monitorReqBuilder_ == null) { + monitorReqBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorReqOrBuilder>( + monitorReq_, + getParentForChildren(), + isClean()); + monitorReq_ = null; + } + return monitorReqBuilder_; + } + + // optional .ECS.MonitorAns monitor_ans = 13; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder> monitorAnsBuilder_; + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public boolean hasMonitorAns() { + return ((bitField0_ & 0x00001000) == 0x00001000); + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns getMonitorAns() { + if (monitorAnsBuilder_ == null) { + return monitorAns_; + } else { + return monitorAnsBuilder_.getMessage(); + } + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public Builder setMonitorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns value) { + if (monitorAnsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + monitorAns_ = value; + onChanged(); + } else { + monitorAnsBuilder_.setMessage(value); + } + bitField0_ |= 0x00001000; + return this; + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public Builder setMonitorAns( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder builderForValue) { + if (monitorAnsBuilder_ == null) { + monitorAns_ = builderForValue.build(); + onChanged(); + } else { + monitorAnsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00001000; + return this; + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public Builder mergeMonitorAns(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns value) { + if (monitorAnsBuilder_ == null) { + if (((bitField0_ & 0x00001000) == 0x00001000) && + monitorAns_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance()) { + monitorAns_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.newBuilder(monitorAns_).mergeFrom(value).buildPartial(); + } else { + monitorAns_ = value; + } + onChanged(); + } else { + monitorAnsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00001000; + return this; + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public Builder clearMonitorAns() { + if (monitorAnsBuilder_ == null) { + monitorAns_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.getDefaultInstance(); + onChanged(); + } else { + monitorAnsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00001000); + return this; + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder getMonitorAnsBuilder() { + bitField0_ |= 0x00001000; + onChanged(); + return getMonitorAnsFieldBuilder().getBuilder(); + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder getMonitorAnsOrBuilder() { + if (monitorAnsBuilder_ != null) { + return monitorAnsBuilder_.getMessageOrBuilder(); + } else { + return monitorAns_; + } + } + /** + * optional .ECS.MonitorAns monitor_ans = 13; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder> + getMonitorAnsFieldBuilder() { + if (monitorAnsBuilder_ == null) { + monitorAnsBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAns.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorAnsOrBuilder>( + monitorAns_, + getParentForChildren(), + isClean()); + monitorAns_ = null; + } + return monitorAnsBuilder_; + } + + // optional .ECS.MonitorNtf monitor_ntf = 14; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder> monitorNtfBuilder_; + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public boolean hasMonitorNtf() { + return ((bitField0_ & 0x00002000) == 0x00002000); + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf getMonitorNtf() { + if (monitorNtfBuilder_ == null) { + return monitorNtf_; + } else { + return monitorNtfBuilder_.getMessage(); + } + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public Builder setMonitorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf value) { + if (monitorNtfBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + monitorNtf_ = value; + onChanged(); + } else { + monitorNtfBuilder_.setMessage(value); + } + bitField0_ |= 0x00002000; + return this; + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public Builder setMonitorNtf( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder builderForValue) { + if (monitorNtfBuilder_ == null) { + monitorNtf_ = builderForValue.build(); + onChanged(); + } else { + monitorNtfBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00002000; + return this; + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public Builder mergeMonitorNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf value) { + if (monitorNtfBuilder_ == null) { + if (((bitField0_ & 0x00002000) == 0x00002000) && + monitorNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance()) { + monitorNtf_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.newBuilder(monitorNtf_).mergeFrom(value).buildPartial(); + } else { + monitorNtf_ = value; + } + onChanged(); + } else { + monitorNtfBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00002000; + return this; + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public Builder clearMonitorNtf() { + if (monitorNtfBuilder_ == null) { + monitorNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.getDefaultInstance(); + onChanged(); + } else { + monitorNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00002000); + return this; + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder getMonitorNtfBuilder() { + bitField0_ |= 0x00002000; + onChanged(); + return getMonitorNtfFieldBuilder().getBuilder(); + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder getMonitorNtfOrBuilder() { + if (monitorNtfBuilder_ != null) { + return monitorNtfBuilder_.getMessageOrBuilder(); + } else { + return monitorNtf_; + } + } + /** + * optional .ECS.MonitorNtf monitor_ntf = 14; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder> + getMonitorNtfFieldBuilder() { + if (monitorNtfBuilder_ == null) { + monitorNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.MonitorNtfOrBuilder>( + monitorNtf_, + getParentForChildren(), + isClean()); + monitorNtf_ = null; + } + return monitorNtfBuilder_; + } + + // optional .ECS.NfcReq nfc_req = 101; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder> nfcReqBuilder_; + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public boolean hasNfcReq() { + return ((bitField0_ & 0x00004000) == 0x00004000); + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq getNfcReq() { + if (nfcReqBuilder_ == null) { + return nfcReq_; + } else { + return nfcReqBuilder_.getMessage(); + } + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public Builder setNfcReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq value) { + if (nfcReqBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nfcReq_ = value; + onChanged(); + } else { + nfcReqBuilder_.setMessage(value); + } + bitField0_ |= 0x00004000; + return this; + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public Builder setNfcReq( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder builderForValue) { + if (nfcReqBuilder_ == null) { + nfcReq_ = builderForValue.build(); + onChanged(); + } else { + nfcReqBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00004000; + return this; + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public Builder mergeNfcReq(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq value) { + if (nfcReqBuilder_ == null) { + if (((bitField0_ & 0x00004000) == 0x00004000) && + nfcReq_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance()) { + nfcReq_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.newBuilder(nfcReq_).mergeFrom(value).buildPartial(); + } else { + nfcReq_ = value; + } + onChanged(); + } else { + nfcReqBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00004000; + return this; + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public Builder clearNfcReq() { + if (nfcReqBuilder_ == null) { + nfcReq_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.getDefaultInstance(); + onChanged(); + } else { + nfcReqBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00004000); + return this; + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder getNfcReqBuilder() { + bitField0_ |= 0x00004000; + onChanged(); + return getNfcReqFieldBuilder().getBuilder(); + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder getNfcReqOrBuilder() { + if (nfcReqBuilder_ != null) { + return nfcReqBuilder_.getMessageOrBuilder(); + } else { + return nfcReq_; + } + } + /** + * optional .ECS.NfcReq nfc_req = 101; + * + * 
+       * Extensions 101 to 150;
+       *
+ */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder> + getNfcReqFieldBuilder() { + if (nfcReqBuilder_ == null) { + nfcReqBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReq.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcReqOrBuilder>( + nfcReq_, + getParentForChildren(), + isClean()); + nfcReq_ = null; + } + return nfcReqBuilder_; + } + + // optional .ECS.NfcNtf nfc_ntf = 102; + private org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder> nfcNtfBuilder_; + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public boolean hasNfcNtf() { + return ((bitField0_ & 0x00008000) == 0x00008000); + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf getNfcNtf() { + if (nfcNtfBuilder_ == null) { + return nfcNtf_; + } else { + return nfcNtfBuilder_.getMessage(); + } + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public Builder setNfcNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf value) { + if (nfcNtfBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + nfcNtf_ = value; + onChanged(); + } else { + nfcNtfBuilder_.setMessage(value); + } + bitField0_ |= 0x00008000; + return this; + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public Builder setNfcNtf( + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder builderForValue) { + if (nfcNtfBuilder_ == null) { + nfcNtf_ = builderForValue.build(); + onChanged(); + } else { + nfcNtfBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00008000; + return this; + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public Builder mergeNfcNtf(org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf value) { + if (nfcNtfBuilder_ == null) { + if (((bitField0_ & 0x00008000) == 0x00008000) && + nfcNtf_ != org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance()) { + nfcNtf_ = + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.newBuilder(nfcNtf_).mergeFrom(value).buildPartial(); + } else { + nfcNtf_ = value; + } + onChanged(); + } else { + nfcNtfBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00008000; + return this; + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public Builder clearNfcNtf() { + if (nfcNtfBuilder_ == null) { + nfcNtf_ = org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.getDefaultInstance(); + onChanged(); + } else { + nfcNtfBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00008000); + return this; + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder getNfcNtfBuilder() { + bitField0_ |= 0x00008000; + onChanged(); + return getNfcNtfFieldBuilder().getBuilder(); + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + public org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder getNfcNtfOrBuilder() { + if (nfcNtfBuilder_ != null) { + return nfcNtfBuilder_.getMessageOrBuilder(); + } else { + return nfcNtf_; + } + } + /** + * optional .ECS.NfcNtf nfc_ntf = 102; + */ + private com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder> + getNfcNtfFieldBuilder() { + if (nfcNtfBuilder_ == null) { + nfcNtfBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtf.Builder, org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.Ecs.NfcNtfOrBuilder>( + nfcNtf_, + getParentForChildren(), + isClean()); + nfcNtf_ = null; + } + return nfcNtfBuilder_; + } + + // @@protoc_insertion_point(builder_scope:ECS.Master) + } + + static { + defaultInstance = new Master(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ECS.Master) + } + + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_CheckVersionReq_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_CheckVersionReq_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_CheckVersionAns_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_CheckVersionAns_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_KeepAliveReq_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_KeepAliveReq_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_KeepAliveAns_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_KeepAliveAns_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_InjectorReq_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_InjectorReq_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_InjectorAns_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_InjectorAns_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_InjectorNtf_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_InjectorNtf_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_DeviceReq_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_DeviceReq_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_DeviceAns_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_DeviceAns_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_DeviceNtf_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_DeviceNtf_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_MonitorReq_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_MonitorReq_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_MonitorAns_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_MonitorAns_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_MonitorNtf_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_MonitorNtf_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_NfcReq_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_NfcReq_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_NfcNtf_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_NfcNtf_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_ECS_Master_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_ECS_Master_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\tecs.proto\022\003ECS\032\recs_ids.proto\"&\n\017Check" + + "VersionReq\022\023\n\013version_str\030\001 \002(\t\"7\n\017Check" + + "VersionAns\022\017\n\007errcode\030\001 \002(\005\022\023\n\013version_s" + + "tr\030\002 \002(\t\" \n\014KeepAliveReq\022\020\n\010time_str\030\001 \001" + + "(\t\" \n\014KeepAliveAns\022\020\n\010time_str\030\001 \001(\t\"\\\n\013" + + "InjectorReq\022\020\n\010category\030\001 \002(\t\022\016\n\006length\030" + + "\002 \002(\005\022\r\n\005group\030\003 \002(\005\022\016\n\006action\030\004 \002(\005\022\014\n\004" + + "data\030\005 \001(\014\"@\n\013InjectorAns\022\017\n\007errcode\030\001 \002" + + "(\005\022\016\n\006errstr\030\002 \001(\t\022\020\n\010category\030\003 \002(\t\"\\\n\013" + + "InjectorNtf\022\020\n\010category\030\001 \002(\t\022\016\n\006length\030", + "\002 \002(\005\022\r\n\005group\030\003 \002(\005\022\016\n\006action\030\004 \002(\005\022\014\n\004" + + "data\030\005 \001(\014\"Z\n\tDeviceReq\022\020\n\010category\030\001 \002(" + + "\t\022\016\n\006length\030\002 \002(\005\022\r\n\005group\030\003 \002(\005\022\016\n\006acti" + + "on\030\004 \002(\005\022\014\n\004data\030\005 \001(\014\"{\n\tDeviceAns\022\017\n\007e" + + "rrcode\030\001 \002(\005\022\016\n\006errstr\030\002 \001(\t\022\020\n\010category" + + "\030\003 \002(\t\022\016\n\006length\030\004 \002(\005\022\r\n\005group\030\005 \002(\005\022\016\n" + + "\006action\030\006 \002(\005\022\014\n\004data\030\007 \001(\014\"Z\n\tDeviceNtf" + + "\022\020\n\010category\030\001 \002(\t\022\016\n\006length\030\002 \002(\005\022\r\n\005gr" + + "oup\030\003 \002(\005\022\016\n\006action\030\004 \002(\005\022\014\n\004data\030\005 \001(\014\"" + + "\035\n\nMonitorReq\022\017\n\007command\030\001 \002(\t\"L\n\nMonito", + "rAns\022\017\n\007errcode\030\001 \002(\005\022\016\n\006errmsg\030\002 \001(\t\022\017\n" + + "\007command\030\003 \002(\t\022\014\n\004data\030\004 \001(\014\"+\n\nMonitorN" + + "tf\022\017\n\007command\030\001 \002(\t\022\014\n\004data\030\002 \001(\014\"(\n\006Nfc" + + "Req\022\020\n\010category\030\001 \002(\t\022\014\n\004data\030\002 \001(\014\"(\n\006N" + + "fcNtf\022\020\n\010category\030\001 \002(\t\022\014\n\004data\030\002 \001(\014\"\356\004" + + "\n\006Master\022\036\n\004type\030\001 \002(\0162\020.ECS.Master_Type" + + "\022.\n\020checkversion_req\030\002 \001(\0132\024.ECS.CheckVe" + + "rsionReq\022.\n\020checkversion_ans\030\003 \001(\0132\024.ECS" + + ".CheckVersionAns\022(\n\rkeepalive_req\030\004 \001(\0132" + + "\021.ECS.KeepAliveReq\022(\n\rkeepalive_ans\030\005 \001(", + "\0132\021.ECS.KeepAliveAns\022&\n\014injector_req\030\006 \001" + + "(\0132\020.ECS.InjectorReq\022&\n\014injector_ans\030\007 \001" + + "(\0132\020.ECS.InjectorAns\022&\n\014injector_ntf\030\010 \001" + + "(\0132\020.ECS.InjectorNtf\022\"\n\ndevice_req\030\t \001(\013" + + "2\016.ECS.DeviceReq\022\"\n\ndevice_ans\030\n \001(\0132\016.E" + + "CS.DeviceAns\022\"\n\ndevice_ntf\030\013 \001(\0132\016.ECS.D" + + "eviceNtf\022$\n\013monitor_req\030\014 \001(\0132\017.ECS.Moni" + + "torReq\022$\n\013monitor_ans\030\r \001(\0132\017.ECS.Monito" + + "rAns\022$\n\013monitor_ntf\030\016 \001(\0132\017.ECS.MonitorN" + + "tf\022\034\n\007nfc_req\030e \001(\0132\013.ECS.NfcReq\022\034\n\007nfc_", + "ntf\030f \001(\0132\013.ECS.NfcNtfB0\n.org.tizen.dyna" + + "micanalyzer.ui.info.snapshot.ecs" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + internal_static_ECS_CheckVersionReq_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_ECS_CheckVersionReq_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_CheckVersionReq_descriptor, + new java.lang.String[] { "VersionStr", }); + internal_static_ECS_CheckVersionAns_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_ECS_CheckVersionAns_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_CheckVersionAns_descriptor, + new java.lang.String[] { "Errcode", "VersionStr", }); + internal_static_ECS_KeepAliveReq_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_ECS_KeepAliveReq_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_KeepAliveReq_descriptor, + new java.lang.String[] { "TimeStr", }); + internal_static_ECS_KeepAliveAns_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_ECS_KeepAliveAns_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_KeepAliveAns_descriptor, + new java.lang.String[] { "TimeStr", }); + internal_static_ECS_InjectorReq_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_ECS_InjectorReq_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_InjectorReq_descriptor, + new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", }); + internal_static_ECS_InjectorAns_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_ECS_InjectorAns_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_InjectorAns_descriptor, + new java.lang.String[] { "Errcode", "Errstr", "Category", }); + internal_static_ECS_InjectorNtf_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_ECS_InjectorNtf_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_InjectorNtf_descriptor, + new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", }); + internal_static_ECS_DeviceReq_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_ECS_DeviceReq_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_DeviceReq_descriptor, + new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", }); + internal_static_ECS_DeviceAns_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_ECS_DeviceAns_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_DeviceAns_descriptor, + new java.lang.String[] { "Errcode", "Errstr", "Category", "Length", "Group", "Action", "Data", }); + internal_static_ECS_DeviceNtf_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_ECS_DeviceNtf_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_DeviceNtf_descriptor, + new java.lang.String[] { "Category", "Length", "Group", "Action", "Data", }); + internal_static_ECS_MonitorReq_descriptor = + getDescriptor().getMessageTypes().get(10); + internal_static_ECS_MonitorReq_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_MonitorReq_descriptor, + new java.lang.String[] { "Command", }); + internal_static_ECS_MonitorAns_descriptor = + getDescriptor().getMessageTypes().get(11); + internal_static_ECS_MonitorAns_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_MonitorAns_descriptor, + new java.lang.String[] { "Errcode", "Errmsg", "Command", "Data", }); + internal_static_ECS_MonitorNtf_descriptor = + getDescriptor().getMessageTypes().get(12); + internal_static_ECS_MonitorNtf_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_MonitorNtf_descriptor, + new java.lang.String[] { "Command", "Data", }); + internal_static_ECS_NfcReq_descriptor = + getDescriptor().getMessageTypes().get(13); + internal_static_ECS_NfcReq_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_NfcReq_descriptor, + new java.lang.String[] { "Category", "Data", }); + internal_static_ECS_NfcNtf_descriptor = + getDescriptor().getMessageTypes().get(14); + internal_static_ECS_NfcNtf_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_NfcNtf_descriptor, + new java.lang.String[] { "Category", "Data", }); + internal_static_ECS_Master_descriptor = + getDescriptor().getMessageTypes().get(15); + internal_static_ECS_Master_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_ECS_Master_descriptor, + new java.lang.String[] { "Type", "CheckversionReq", "CheckversionAns", "KeepaliveReq", "KeepaliveAns", "InjectorReq", "InjectorAns", "InjectorNtf", "DeviceReq", "DeviceAns", "DeviceNtf", "MonitorReq", "MonitorAns", "MonitorNtf", "NfcReq", "NfcNtf", }); + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.getDescriptor(), + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/EcsIds.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/EcsIds.java new file mode 100644 index 0000000..5dfd1c1 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/info/snapshot/ecs/EcsIds.java @@ -0,0 +1,244 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: ecs_ids.proto + +package org.tizen.dynamicanalyzer.ui.info.snapshot.ecs; + +public final class EcsIds { + private EcsIds() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + } + /** + * Protobuf enum {@code ECS.Master_Type} + */ + public enum Master_Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * CHECKVERSION_REQ = 2; + */ + CHECKVERSION_REQ(0, 2), + /** + * CHECKVERSION_ANS = 3; + */ + CHECKVERSION_ANS(1, 3), + /** + * KEEPALIVE_REQ = 4; + */ + KEEPALIVE_REQ(2, 4), + /** + * KEEPALIVE_ANS = 5; + */ + KEEPALIVE_ANS(3, 5), + /** + * INJECTOR_REQ = 6; + */ + INJECTOR_REQ(4, 6), + /** + * INJECTOR_ANS = 7; + */ + INJECTOR_ANS(5, 7), + /** + * INJECTOR_NTF = 8; + */ + INJECTOR_NTF(6, 8), + /** + * DEVICE_REQ = 9; + */ + DEVICE_REQ(7, 9), + /** + * DEVICE_ANS = 10; + */ + DEVICE_ANS(8, 10), + /** + * DEVICE_NTF = 11; + */ + DEVICE_NTF(9, 11), + /** + * MONITOR_REQ = 12; + */ + MONITOR_REQ(10, 12), + /** + * MONITOR_ANS = 13; + */ + MONITOR_ANS(11, 13), + /** + * MONITOR_NTF = 14; + */ + MONITOR_NTF(12, 14), + /** + * NFC_REQ = 101; + */ + NFC_REQ(13, 101), + /** + * NFC_NTF = 102; + */ + NFC_NTF(14, 102), + ; + + /** + * CHECKVERSION_REQ = 2; + */ + public static final int CHECKVERSION_REQ_VALUE = 2; + /** + * CHECKVERSION_ANS = 3; + */ + public static final int CHECKVERSION_ANS_VALUE = 3; + /** + * KEEPALIVE_REQ = 4; + */ + public static final int KEEPALIVE_REQ_VALUE = 4; + /** + * KEEPALIVE_ANS = 5; + */ + public static final int KEEPALIVE_ANS_VALUE = 5; + /** + * INJECTOR_REQ = 6; + */ + public static final int INJECTOR_REQ_VALUE = 6; + /** + * INJECTOR_ANS = 7; + */ + public static final int INJECTOR_ANS_VALUE = 7; + /** + * INJECTOR_NTF = 8; + */ + public static final int INJECTOR_NTF_VALUE = 8; + /** + * DEVICE_REQ = 9; + */ + public static final int DEVICE_REQ_VALUE = 9; + /** + * DEVICE_ANS = 10; + */ + public static final int DEVICE_ANS_VALUE = 10; + /** + * DEVICE_NTF = 11; + */ + public static final int DEVICE_NTF_VALUE = 11; + /** + * MONITOR_REQ = 12; + */ + public static final int MONITOR_REQ_VALUE = 12; + /** + * MONITOR_ANS = 13; + */ + public static final int MONITOR_ANS_VALUE = 13; + /** + * MONITOR_NTF = 14; + */ + public static final int MONITOR_NTF_VALUE = 14; + /** + * NFC_REQ = 101; + */ + public static final int NFC_REQ_VALUE = 101; + /** + * NFC_NTF = 102; + */ + public static final int NFC_NTF_VALUE = 102; + + + public final int getNumber() { return value; } + + public static Master_Type valueOf(int value) { + switch (value) { + case 2: return CHECKVERSION_REQ; + case 3: return CHECKVERSION_ANS; + case 4: return KEEPALIVE_REQ; + case 5: return KEEPALIVE_ANS; + case 6: return INJECTOR_REQ; + case 7: return INJECTOR_ANS; + case 8: return INJECTOR_NTF; + case 9: return DEVICE_REQ; + case 10: return DEVICE_ANS; + case 11: return DEVICE_NTF; + case 12: return MONITOR_REQ; + case 13: return MONITOR_ANS; + case 14: return MONITOR_NTF; + case 101: return NFC_REQ; + case 102: return NFC_NTF; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Master_Type findValueByNumber(int number) { + return Master_Type.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.tizen.dynamicanalyzer.ui.info.snapshot.ecs.EcsIds.getDescriptor().getEnumTypes().get(0); + } + + private static final Master_Type[] VALUES = values(); + + public static Master_Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private Master_Type(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:ECS.Master_Type) + } + + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\recs_ids.proto\022\003ECS*\222\002\n\013Master_Type\022\024\n\020" + + "CHECKVERSION_REQ\020\002\022\024\n\020CHECKVERSION_ANS\020\003" + + "\022\021\n\rKEEPALIVE_REQ\020\004\022\021\n\rKEEPALIVE_ANS\020\005\022\020" + + "\n\014INJECTOR_REQ\020\006\022\020\n\014INJECTOR_ANS\020\007\022\020\n\014IN" + + "JECTOR_NTF\020\010\022\016\n\nDEVICE_REQ\020\t\022\016\n\nDEVICE_A" + + "NS\020\n\022\016\n\nDEVICE_NTF\020\013\022\017\n\013MONITOR_REQ\020\014\022\017\n" + + "\013MONITOR_ANS\020\r\022\017\n\013MONITOR_NTF\020\016\022\013\n\007NFC_R" + + "EQ\020e\022\013\n\007NFC_NTF\020fB0\n.org.tizen.dynamican" + + "alyzer.ui.info.snapshot.ecs" + }; + com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = + new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { + public com.google.protobuf.ExtensionRegistry assignDescriptors( + com.google.protobuf.Descriptors.FileDescriptor root) { + descriptor = root; + return null; + } + }; + com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }, assigner); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ScreenshotChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ScreenshotChart.java index 9985a15..6cab103 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ScreenshotChart.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/ScreenshotChart.java @@ -34,6 +34,7 @@ import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.Display; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; +import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.nl.TimelineChartLabels; import org.tizen.dynamicanalyzer.resources.ImageResources; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; @@ -41,6 +42,7 @@ import org.tizen.dynamicanalyzer.swap.logparser.LogPackage; import org.tizen.dynamicanalyzer.swap.logparser.Logs; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.ScreenShotData; +import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketClient; import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants; import org.tizen.dynamicanalyzer.widgets.chart.DAChart; import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries; @@ -112,7 +114,16 @@ public class ScreenshotChart extends TimelineChart { + File.separator + AnalyzerConstants.IMAGE_FOLDER_NAME + File.separator + AnalyzerConstants.SMALL_IMAGE_FOLDER_NAME; - String imagePathLog = logData.getImageFilePath(); + String imagePathLog; + + if(DACommunicator.isTargetEmulator() + && SocketClient.getInstance().isConnected()) { + imagePathLog = DACommunicator.getSelectedDevice() + .emulatorSnapshot.getFilePath(); + } else { + imagePathLog = logData.getImageFilePath(); + } + String[] splitedImagePathLog = imagePathLog.split("/"); //$NON-NLS-1$ String fileName = splitedImagePathLog[splitedImagePathLog.length - 1]; imagePath += File.separator + fileName; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/ImageUtilSWT.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/ImageUtilSWT.java new file mode 100644 index 0000000..e56fc6b --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/ImageUtilSWT.java @@ -0,0 +1,177 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Woojin Jung + * Juyoung Kim + * Munkyu Im + * GiWoong Kim + * YeongKyoon Lee + * HyunJun Son + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.utils; + +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.SWTError; +import org.eclipse.swt.SWTException; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.ImageLoader; +import org.eclipse.swt.widgets.Display; + +public class ImageUtilSWT { + + /* + * reference web page : http://www.java2s.com/Code/Java/SWT-JFace-Eclipse/Rotateandflipanimage.htm + */ + private static ImageData rotateImageData( ImageData srcData, int direction ) { + int bytesPerPixel = srcData.bytesPerLine / srcData.width; + int destBytesPerLine = ( direction == SWT.DOWN ) ? srcData.width * bytesPerPixel : srcData.height + * bytesPerPixel; + byte[] newData = new byte[srcData.data.length]; + int width = 0, height = 0; + for ( int srcY = 0; srcY < srcData.height; srcY++ ) { + for ( int srcX = 0; srcX < srcData.width; srcX++ ) { + int destX = 0, destY = 0, destIndex = 0, srcIndex = 0; + switch ( direction ) { + case SWT.LEFT: // left 90 degrees + destX = srcY; + destY = srcData.width - srcX - 1; + width = srcData.height; + height = srcData.width; + break; + case SWT.RIGHT: // right 90 degrees + destX = srcData.height - srcY - 1; + destY = srcX; + width = srcData.height; + height = srcData.width; + break; + case SWT.DOWN: // 180 degrees + destX = srcData.width - srcX - 1; + destY = srcData.height - srcY - 1; + width = srcData.width; + height = srcData.height; + break; + } + destIndex = ( destY * destBytesPerLine ) + ( destX * bytesPerPixel ); + srcIndex = ( srcY * srcData.bytesPerLine ) + ( srcX * bytesPerPixel ); + System.arraycopy( srcData.data, srcIndex, newData, destIndex, bytesPerPixel ); + } + } + // destBytesPerLine is used as scanlinePad to ensure that no padding is + // required + return new ImageData( width, height, srcData.depth, srcData.palette, destBytesPerLine, newData ); + } + + private static void saveFile(Image image, String filePath) { + if ( null == filePath ) { + return; + } + + FileOutputStream fos = null; + + try { + ImageLoader loader = new ImageLoader(); + loader.data = new ImageData[] { image.getImageData() }; + + fos = new FileOutputStream( filePath, false ); + loader.save( fos, SWT.IMAGE_PNG ); + } catch ( FileNotFoundException ex ) { + ex.printStackTrace(); + } catch ( Exception ex ) { + ex.printStackTrace(); + } finally { + try { + if (null != fos) { + fos.close(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + private static Image createResizedImage(Image imageOrigin, + int width, int height) { + if (imageOrigin == null) { + return null; + } + + ImageData imageDataSrc = imageOrigin.getImageData(); + ImageData imageDataDst = (ImageData) imageDataSrc.clone(); + + imageDataDst = imageDataDst.scaledTo(width, height); + + return new Image(Display.getDefault(), imageDataDst); + } + + public static void transform(String originFilePath, String newFilePath, + int width, int height, int angle) { + Image img = null; + ImageData newImageData = null; + + try { + img = new Image(Display.getDefault(), originFilePath); + Image scaledImage = createResizedImage(img, width, height); + + if (angle == 0) { + newImageData = scaledImage.getImageData(); + } else if (angle == 90) { + newImageData = rotateImageData(scaledImage.getImageData(), SWT.RIGHT); + } else if (angle == 270) { + newImageData = rotateImageData(scaledImage.getImageData(), SWT.LEFT); + } else if (angle == 180) { + newImageData = rotateImageData(scaledImage.getImageData(), SWT.DOWN); + } + Image newImage = new Image(Display.getDefault(), newImageData); + saveFile(newImage, newFilePath); + } catch (IllegalArgumentException e) { + e.printStackTrace(); + } catch (SWTError err) { + err.printStackTrace(); + } catch (SWTException e) { + e.printStackTrace(); + } + } + + public static void resize(String originFilePath, String newFilePath, + int width, int height) { + Image img = null; + + try { + img = new Image(Display.getDefault(), originFilePath); + Image scaledImage = createResizedImage(img, width, height); + + saveFile(scaledImage, newFilePath); + } catch (IllegalArgumentException e) { + e.printStackTrace(); + } catch (SWTError err) { + err.printStackTrace(); + } catch (SWTException e) { + e.printStackTrace(); + } + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/JsonUtil.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/JsonUtil.java new file mode 100644 index 0000000..cb925e1 --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/utils/JsonUtil.java @@ -0,0 +1,141 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * WooJin Jung + * Juyoung Kim + * Jinhyung Choi + * MunKyu Im + * Daiyoung Kim + * YeongKyoon Lee + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +package org.tizen.dynamicanalyzer.utils; + +import org.json.simple.JSONArray; +import org.json.simple.JSONObject; +import org.json.simple.parser.JSONParser; +import org.json.simple.parser.ParseException; +import org.tizen.dynamicanalyzer.ui.info.snapshot.SocketConstants; + +public class JsonUtil { + public static final String CMD_SCREENDUMP = "screendump"; + public static final String CMD_EXECUTE = "execute"; + public static final String CMD_ARGS = "arguments"; + public static final String ARG_FILENAME = "filename"; + + private static JSONParser parser = new JSONParser(); + + public static JSONObject decodeObject(String message) { + JSONObject obj = null; + if (null == message) { + System.out.println("decodeObject - message string is null."); + return obj; + } + try { + obj = (JSONObject) parser.parse(message); + } catch (ParseException e) { + e.printStackTrace(); + System.out.println("[info] position: " + e.getPosition()); + System.out.println("[info] " + e.toString()); + } + return obj; + } + + public static JSONArray decodeArray(String message) { + JSONArray obj = null; + if (null == message) { + System.out.println("decodeArray - message string is null."); + return obj; + } + try { + obj = (JSONArray) parser.parse(message); + } catch (ParseException e) { + System.out.println("[info] position: " + e.getPosition()); + System.out.println("[info] " + e.toString()); + } + return obj; + } + + public static String decodeString(String message) { + if (null == message) { + System.out.println("decodeArray - message string is null."); + return null; + } + JSONObject obj = decodeObject(message); + if (null == obj) { + return null; + } + return obj.toJSONString(); + } + + @SuppressWarnings("unchecked") + public static String encodeString(String key, String value) { + if (null == value) { + return null; + } + JSONObject obj = new JSONObject(); + + obj.put(key, value); + + return obj.toJSONString().trim(); + } + + @SuppressWarnings("unchecked") + public static String encodeString(String key1, String value1, String key2, + String value2) { + JSONObject obj = new JSONObject(); + obj.put(key1, value1); + obj.put(key2, value2); + + return obj.toJSONString().trim(); + } + + @SuppressWarnings("unchecked") + public static String encodeString(String key1, String value1, String key2, + JSONObject objs) { + JSONObject obj = new JSONObject(); + obj.put(key1, value1); + obj.put(key2, objs); + + return obj.toJSONString().trim(); + } + + @SuppressWarnings("unchecked") + public static String encodeString(String key1, String value1, String key2, + JSONObject objs, String type) { + JSONObject obj = new JSONObject(); + obj.put(key1, value1); + obj.put(key2, objs); + obj.put(SocketConstants.MESSAGE_TYPE, type); + + return obj.toJSONString().trim(); + } + + @SuppressWarnings("unchecked") + public static JSONObject encodeObject(String key, String value) { + JSONObject obj = new JSONObject(); + + obj.put(key, value); + + return obj; + } +}