mirror of
https://github.com/johndoe6345789/tustu.git
synced 2026-04-30 16:45:40 +00:00
stuff
This commit is contained in:
@@ -0,0 +1,480 @@
|
||||
package SerializableImplExceptionprintstacktrace;
|
||||
|
||||
import G.J;
|
||||
import G.R;
|
||||
import G.T;
|
||||
import G.GInterfaceAf;
|
||||
import G.SerializableImplExceptionprintstacktrace;
|
||||
import G.GComponentCq;
|
||||
import G.ManagerUsingArrayList;
|
||||
import G.i;
|
||||
import L.y;
|
||||
import V.ExceptionInVPackage;
|
||||
import W.OutputStreamExtension;
|
||||
import W.e;
|
||||
import bH.D;
|
||||
import bH.aa;
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.text.DecimalFormat;
|
||||
import java.text.NumberFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
public abstract class AbstractUsingArrayList implements GInterfaceAf {
|
||||
protected ArrayList d = new ArrayList();
|
||||
|
||||
static List e = new ArrayList();
|
||||
|
||||
private List ExceptionInVPackage = new ArrayList();
|
||||
|
||||
protected static h f = null;
|
||||
|
||||
protected OutputStream g = null;
|
||||
|
||||
private static String b = null;
|
||||
|
||||
protected boolean h = false;
|
||||
|
||||
long i = System.currentTimeMillis();
|
||||
|
||||
long j = -1L;
|
||||
|
||||
protected k k = null;
|
||||
|
||||
private long c = -1L;
|
||||
|
||||
File l = null;
|
||||
|
||||
boolean m = false;
|
||||
|
||||
private double p = 0.0D;
|
||||
|
||||
private static int q = 0;
|
||||
|
||||
private String[] r = null;
|
||||
|
||||
boolean n = false;
|
||||
|
||||
private static h s = null;
|
||||
|
||||
private boolean t = true;
|
||||
|
||||
private GComponentCq u = null;
|
||||
|
||||
private static B v = null;
|
||||
|
||||
private boolean w = false;
|
||||
|
||||
final List o = new ArrayList();
|
||||
|
||||
protected AbstractUsingArrayList() {
|
||||
this.u = new i(this);
|
||||
}
|
||||
|
||||
protected abstract void ExceptionInVPackage(R[] paramArrayOfR, OutputStream paramOutputStream);
|
||||
|
||||
public void d(String paramString) {
|
||||
ExceptionInVPackage(this.g, paramString);
|
||||
f(paramString);
|
||||
}
|
||||
|
||||
protected abstract void ExceptionInVPackage(OutputStream paramOutputStream, String paramString);
|
||||
|
||||
protected abstract void ExceptionInVPackage(OutputStream paramOutputStream, byte[][] paramArrayOfbyte);
|
||||
|
||||
protected abstract void ExceptionInVPackage(OutputStream paramOutputStream);
|
||||
|
||||
public void ExceptionInVPackage(ExceptionInVPackage parama) {
|
||||
if (u())
|
||||
throw new A("Can not modify LoggerFields while logging.");
|
||||
if (!this.ExceptionInVPackage.contains(parama))
|
||||
this.ExceptionInVPackage.add(parama);
|
||||
}
|
||||
|
||||
public void i() {
|
||||
if (u())
|
||||
throw new A("Can not modify LoggerFields while logging.");
|
||||
this.ExceptionInVPackage.clear();
|
||||
}
|
||||
|
||||
protected List j() {
|
||||
return this.ExceptionInVPackage;
|
||||
}
|
||||
|
||||
public static h k() {
|
||||
return s;
|
||||
}
|
||||
|
||||
public void ExceptionInVPackage(h paramh) {
|
||||
s = paramh;
|
||||
}
|
||||
|
||||
public synchronized void ExceptionInVPackage(String paramString1, String paramString2) {
|
||||
String[] arrayOfString = new String[1];
|
||||
arrayOfString[0] = paramString1;
|
||||
ExceptionInVPackage(arrayOfString, paramString2);
|
||||
}
|
||||
|
||||
public synchronized void ExceptionInVPackage(String[] paramArrayOfString, String paramString) {
|
||||
T t = T.ExceptionInVPackage();
|
||||
R[] arrayOfR = new R[paramArrayOfString.length];
|
||||
R r = t.c();
|
||||
D.c("Starting Log for " + arrayOfR.length + " Configs.");
|
||||
for (byte b1 = 0; b1 < paramArrayOfString.length; b1++) {
|
||||
R r1 = t.c(paramArrayOfString[b1]);
|
||||
if (b1 > 0 && r1.equals(r)) {
|
||||
R r2 = arrayOfR[0];
|
||||
arrayOfR[0] = r1;
|
||||
arrayOfR[b1] = r2;
|
||||
} else {
|
||||
arrayOfR[b1] = r1;
|
||||
}
|
||||
if (arrayOfR[b1] == null)
|
||||
throw new ExceptionInVPackage("Configuration '" + paramArrayOfString[b1] + "' not currently loaded. \nCan't start data Log.");
|
||||
}
|
||||
ArrayList<R> arrayList = new ArrayList();
|
||||
for (byte b2 = 0; b2 < arrayOfR.length; b2++) {
|
||||
if (b2 == 0 || (arrayOfR[b2].S() && arrayOfR[b2].C().e(arrayOfR[b2].O())))
|
||||
arrayList.add(arrayOfR[b2]);
|
||||
}
|
||||
arrayOfR = arrayList.<R>toArray(new R[arrayList.size()]);
|
||||
ArrayList arrayList1 = ExceptionInVPackage(arrayOfR);
|
||||
aa aa = new aa();
|
||||
aa.ExceptionInVPackage();
|
||||
HashMap<Object, Object> hashMap = new HashMap<>();
|
||||
for (q q : arrayList1) {
|
||||
if (q.g() != null) {
|
||||
List<String> list = (List)hashMap.get(q.g());
|
||||
if (list == null) {
|
||||
list = new ArrayList();
|
||||
hashMap.put(q.g(), list);
|
||||
}
|
||||
if (q.c() == null) {
|
||||
D.b("OutputChannel is null! Cannot datalog: " + q.ExceptionInVPackage());
|
||||
continue;
|
||||
}
|
||||
list.add(q.c().aL());
|
||||
}
|
||||
}
|
||||
for (String str : hashMap.keySet()) {
|
||||
List list = (List)hashMap.get(str);
|
||||
ManagerUsingArrayList.ExceptionInVPackage().ExceptionInVPackage(str, list, this.u);
|
||||
}
|
||||
D.c("Time to subscribe all data log channels: " + aa.d());
|
||||
try {
|
||||
this.g = e(paramString);
|
||||
ExceptionInVPackage(arrayOfR, this.g);
|
||||
} catch (Exception exception) {
|
||||
exception.printStackTrace();
|
||||
throw new ExceptionInVPackage("Could not create file " + paramString);
|
||||
}
|
||||
ArrayList<J> arrayList2 = new ArrayList();
|
||||
for (byte b3 = 0; b3 < arrayOfR.length; b3++) {
|
||||
J j = T.ExceptionInVPackage().c(paramArrayOfString[b3]).C();
|
||||
if (!arrayList2.contains(j))
|
||||
j.b(this);
|
||||
arrayList2.add(j);
|
||||
this.d.add(new m(this, paramArrayOfString[b3], b3, arrayOfR[b3].O().n()));
|
||||
}
|
||||
ExceptionInVPackage(new File(paramString));
|
||||
D.d("Started Data Log to file: " + paramString);
|
||||
y.ExceptionInVPackage();
|
||||
this.j = -1L;
|
||||
this.n = false;
|
||||
this.h = true;
|
||||
try {
|
||||
String str1 = paramArrayOfString[0];
|
||||
String str2 = "Channels active on main config " + str1 + ": " + ManagerUsingArrayList.ExceptionInVPackage().b(str1);
|
||||
D.d(str2);
|
||||
} catch (Exception exception) {}
|
||||
}
|
||||
|
||||
public void l() {
|
||||
this.n = true;
|
||||
j j = new j(this);
|
||||
j.start();
|
||||
}
|
||||
|
||||
protected void m() {
|
||||
this.h = false;
|
||||
y.b();
|
||||
try {
|
||||
for (byte b = 0; b < this.d.size(); b++) {
|
||||
m m = this.d.get(b);
|
||||
String str = m.ExceptionInVPackage();
|
||||
T t = T.ExceptionInVPackage();
|
||||
R r = t.c(str);
|
||||
if (r == null)
|
||||
throw new ExceptionInVPackage("Configuration '" + str + "' not currently loaded. \nCan't stop data Log.");
|
||||
J j = T.ExceptionInVPackage().c(str).C();
|
||||
j.c(this);
|
||||
this.d.remove(m);
|
||||
b--;
|
||||
}
|
||||
ExceptionInVPackage(this.g);
|
||||
ManagerUsingArrayList.ExceptionInVPackage().ExceptionInVPackage(this.u);
|
||||
q();
|
||||
if (!this.m && this.l != null && this.l.exists()) {
|
||||
D.d("No records written to log file: " + this.l.getName() + ", will delete.");
|
||||
this.l.delete();
|
||||
}
|
||||
this.j = -1L;
|
||||
} catch (Exception exception) {
|
||||
exception.printStackTrace();
|
||||
throw new ExceptionInVPackage("Could Not close log file, error\n" + exception.getMessage());
|
||||
}
|
||||
if (this.k != null)
|
||||
this.k.ExceptionInVPackage();
|
||||
}
|
||||
|
||||
protected boolean ExceptionInVPackage(R paramR, SerializableImplExceptionprintstacktrace paramac) {
|
||||
String str = T.ExceptionInVPackage().c().equals(paramR) ? "" : paramR.c();
|
||||
return (!ExceptionInVPackage(str, this.r, paramac.b()) && r.ExceptionInVPackage(paramR, paramac));
|
||||
}
|
||||
|
||||
private boolean ExceptionInVPackage(String paramString1, String[] paramArrayOfString, String paramString2) {
|
||||
if (paramArrayOfString == null || paramString2 == null)
|
||||
return false;
|
||||
for (byte b = 0; b < paramArrayOfString.length; b++) {
|
||||
if ((paramString1 == null || paramString1.isEmpty()) && paramArrayOfString[b].equals(paramString2))
|
||||
return true;
|
||||
if (paramArrayOfString[b].equals(paramString1 + "." + paramString2))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
protected ArrayList ExceptionInVPackage(R[] paramArrayOfR) {
|
||||
ArrayList<q> arrayList = new ArrayList();
|
||||
for (byte b = 0; b < paramArrayOfR.length; b++) {
|
||||
if (paramArrayOfR[b].S()) {
|
||||
q = 0;
|
||||
for (SerializableImplExceptionprintstacktrace SerializableImplExceptionprintstacktrace : paramArrayOfR[b].g()) {
|
||||
if (ExceptionInVPackage(paramArrayOfR[b], SerializableImplExceptionprintstacktrace)) {
|
||||
q q = new q();
|
||||
if (b == 0) {
|
||||
String str = SerializableImplExceptionprintstacktrace.b();
|
||||
byte b1 = 0;
|
||||
while (ExceptionInVPackage(arrayList, str))
|
||||
str = SerializableImplExceptionprintstacktrace.b() + "_" + b1++;
|
||||
q.ExceptionInVPackage(str);
|
||||
} else {
|
||||
String str = paramArrayOfR[b].c() + "." + SerializableImplExceptionprintstacktrace.b();
|
||||
byte b1 = 0;
|
||||
while (ExceptionInVPackage(arrayList, str))
|
||||
str = paramArrayOfR[b].c() + "." + SerializableImplExceptionprintstacktrace.b() + "_" + b1++;
|
||||
q.ExceptionInVPackage(str);
|
||||
}
|
||||
q.b(paramArrayOfR[b].c());
|
||||
q.ExceptionInVPackage(SerializableImplExceptionprintstacktrace);
|
||||
q.ExceptionInVPackage(b);
|
||||
q.ExceptionInVPackage(paramArrayOfR[b].g(SerializableImplExceptionprintstacktrace.ExceptionInVPackage()));
|
||||
q.b(SerializableImplExceptionprintstacktrace.f());
|
||||
if (q.h() > q)
|
||||
q = q.h();
|
||||
q.c(SerializableImplExceptionprintstacktrace.m());
|
||||
q.d(SerializableImplExceptionprintstacktrace.n());
|
||||
arrayList.add(q);
|
||||
}
|
||||
}
|
||||
for (q q : arrayList)
|
||||
q.c(q);
|
||||
}
|
||||
}
|
||||
return arrayList;
|
||||
}
|
||||
|
||||
private boolean ExceptionInVPackage(ArrayList paramArrayList, String paramString) {
|
||||
for (q q : paramArrayList) {
|
||||
if (q.ExceptionInVPackage().equals(paramString))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public synchronized void ExceptionInVPackage(String paramString, byte[] paramArrayOfbyte) {
|
||||
double d = 0.0D;
|
||||
long l1 = System.currentTimeMillis();
|
||||
long l2 = System.nanoTime();
|
||||
if (this.c != -1L) {
|
||||
d = (l1 - this.c) / 1000.0D;
|
||||
} else {
|
||||
d = 0.1D;
|
||||
}
|
||||
this.c = l1;
|
||||
this.p = (this.p * 20.0D + 1.0D / d) / 21.0D;
|
||||
m m = ExceptionInVPackage(paramString);
|
||||
if (m == null || paramArrayOfbyte == null)
|
||||
return;
|
||||
m.ExceptionInVPackage(paramArrayOfbyte);
|
||||
for (m m1 : this.d) {
|
||||
if (m1.b() == null)
|
||||
return;
|
||||
}
|
||||
byte[][] arrayOfByte = new byte[this.d.size()][0];
|
||||
String[] arrayOfString = new String[this.d.size()];
|
||||
for (byte b = 0; b < this.d.size(); b++) {
|
||||
m m1 = this.d.get(b);
|
||||
arrayOfByte[b] = m1.b();
|
||||
m1.ExceptionInVPackage((byte[])null);
|
||||
arrayOfString[b] = m1.ExceptionInVPackage();
|
||||
}
|
||||
try {
|
||||
if (this.j == -1L) {
|
||||
i.b();
|
||||
this.j = System.currentTimeMillis();
|
||||
}
|
||||
long l3 = System.nanoTime() - l2;
|
||||
if (v != null)
|
||||
ManagerUsingArrayList.ExceptionInVPackage().ExceptionInVPackage("dataLogTime", v.ExceptionInVPackage());
|
||||
ExceptionInVPackage(this.g, arrayOfByte);
|
||||
long l4 = System.nanoTime() - l2 - l3;
|
||||
p();
|
||||
this.m = true;
|
||||
long l5 = System.nanoTime() - l2 - l3 - l4;
|
||||
if ((System.nanoTime() - l2) > 4.0E7D) {
|
||||
NumberFormat numberFormat = DecimalFormat.getNumberInstance();
|
||||
numberFormat.setMaximumFractionDigits(6);
|
||||
D.b("Data Log write time seems to be taking an unusually long amount of time.");
|
||||
D.c("Time to write Data Log Record: " + numberFormat.format(l4 / 1000000.0D) + "ms. Time to notify Listeners: " + (l5 / 1000000.0D) + "ms. Prework time:" + (l3 / 1000000.0D));
|
||||
}
|
||||
} catch (Exception exception) {
|
||||
D.ExceptionInVPackage("Failed to write log record. Error:");
|
||||
Logger.getLogger(h.class.getName()).log(Level.SEVERE, (String)null, exception);
|
||||
}
|
||||
try {
|
||||
this.g.flush();
|
||||
} catch (IOException iOException) {
|
||||
iOException.printStackTrace();
|
||||
}
|
||||
if (this.n && q == 0) {
|
||||
try {
|
||||
m();
|
||||
} catch (ExceptionInVPackage ExceptionInVPackage) {
|
||||
D.ExceptionInVPackage(ExceptionInVPackage.getLocalizedMessage(), (Exception)ExceptionInVPackage, null);
|
||||
}
|
||||
} else if (this.n && q > 0) {
|
||||
q--;
|
||||
}
|
||||
}
|
||||
|
||||
private m ExceptionInVPackage(String paramString) {
|
||||
for (m m : this.d) {
|
||||
if (m.ExceptionInVPackage().equals(paramString))
|
||||
return m;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected OutputStream e(String paramString) {
|
||||
File file = new File(paramString);
|
||||
try {
|
||||
file.getParentFile().mkdirs();
|
||||
b(file);
|
||||
} catch (Exception exception) {
|
||||
exception.printStackTrace();
|
||||
}
|
||||
e e = new e(new FileOutputStream(file));
|
||||
OutputStreamExtension OutputStreamExtension = new OutputStreamExtension((OutputStream)e);
|
||||
this.l = file;
|
||||
this.m = false;
|
||||
return (OutputStream)OutputStreamExtension;
|
||||
}
|
||||
|
||||
public String n() {
|
||||
return b;
|
||||
}
|
||||
|
||||
public void ExceptionInVPackage(File paramFile) {
|
||||
b = paramFile.getAbsolutePath();
|
||||
}
|
||||
|
||||
public double o() {
|
||||
return this.p;
|
||||
}
|
||||
|
||||
protected void b(File paramFile) {
|
||||
if (this.t) {
|
||||
Iterator<f> iterator = e.iterator();
|
||||
while (iterator.hasNext())
|
||||
((f)iterator.next()).ExceptionInVPackage(paramFile);
|
||||
}
|
||||
}
|
||||
|
||||
protected void p() {
|
||||
if (this.t) {
|
||||
Iterator<f> iterator = e.iterator();
|
||||
while (iterator.hasNext())
|
||||
((f)iterator.next()).c();
|
||||
}
|
||||
}
|
||||
|
||||
protected void q() {
|
||||
if (this.t) {
|
||||
Iterator<f> iterator = e.iterator();
|
||||
while (iterator.hasNext())
|
||||
((f)iterator.next()).d();
|
||||
}
|
||||
}
|
||||
|
||||
protected void f(String paramString) {
|
||||
if (this.t) {
|
||||
Iterator<f> iterator = e.iterator();
|
||||
while (iterator.hasNext())
|
||||
((f)iterator.next()).b(paramString);
|
||||
}
|
||||
}
|
||||
|
||||
public void ExceptionInVPackage(f paramf) {
|
||||
e.add(paramf);
|
||||
}
|
||||
|
||||
public int r() {
|
||||
return q;
|
||||
}
|
||||
|
||||
public void ExceptionInVPackage(String[] paramArrayOfString) {
|
||||
this.r = paramArrayOfString;
|
||||
}
|
||||
|
||||
public void b(boolean paramBoolean) {
|
||||
this.t = paramBoolean;
|
||||
}
|
||||
|
||||
public static B s() {
|
||||
return v;
|
||||
}
|
||||
|
||||
public static void ExceptionInVPackage(B paramB) {
|
||||
v = paramB;
|
||||
}
|
||||
|
||||
public boolean t() {
|
||||
return this.w;
|
||||
}
|
||||
|
||||
public void c(boolean paramBoolean) {
|
||||
this.w = paramBoolean;
|
||||
}
|
||||
|
||||
public boolean u() {
|
||||
return this.h;
|
||||
}
|
||||
|
||||
public void d(boolean paramBoolean) {
|
||||
this.h = paramBoolean;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/SerializableImplExceptionprintstacktrace/h.class
|
||||
* Java compiler version: 8 (52.0)
|
||||
* JD-Core Version: 1.1.3
|
||||
*/
|
||||
@@ -0,0 +1,131 @@
|
||||
package SerializableImplExceptionprintstacktrace;
|
||||
|
||||
import G.SerializableImpl;
|
||||
import G.SerializableImplExceptionprintstacktrace;
|
||||
import bH.X;
|
||||
import bH.c;
|
||||
|
||||
public class AcInterfaceQuebec {
|
||||
private String a = null;
|
||||
|
||||
private SerializableImplExceptionprintstacktrace b = null;
|
||||
|
||||
private SerializableImpl c = null;
|
||||
|
||||
private int d = 0;
|
||||
|
||||
private String e = null;
|
||||
|
||||
private int f = 0;
|
||||
|
||||
private double[] g = new double[1];
|
||||
|
||||
private int h = 0;
|
||||
|
||||
private String i = null;
|
||||
|
||||
private String j = null;
|
||||
|
||||
public double a(byte[] paramArrayOfbyte) {
|
||||
int i = (this.h + this.g.length - this.f - 1) % this.g.length;
|
||||
this.g[i] = c().b(paramArrayOfbyte);
|
||||
double d = this.g[this.h % this.g.length];
|
||||
this.h++;
|
||||
return d;
|
||||
}
|
||||
|
||||
public String a(double paramDouble) {
|
||||
if (this.b.e() == 0)
|
||||
return X.c(paramDouble, e());
|
||||
if (this.b.e() == 1) {
|
||||
int i = c.a((byte)(int)paramDouble);
|
||||
return "0x" + X.a(Integer.toHexString(i), '0', 2).toUpperCase();
|
||||
}
|
||||
return (paramDouble == 0.0D && this.b.h() != null && this.b.h().length() > 0) ? this.b.h() : ((paramDouble != 0.0D && this.b.i() != null && this.b.h().length() > 0) ? this.b.i() : X.c(paramDouble, e()));
|
||||
}
|
||||
|
||||
public String a() {
|
||||
return this.a;
|
||||
}
|
||||
|
||||
public void a(String paramString) {
|
||||
this.a = paramString;
|
||||
}
|
||||
|
||||
public SerializableImplExceptionprintstacktrace b() {
|
||||
return this.b;
|
||||
}
|
||||
|
||||
public void a(SerializableImplExceptionprintstacktrace paramac) {
|
||||
this.b = paramac;
|
||||
}
|
||||
|
||||
public SerializableImpl c() {
|
||||
return this.c;
|
||||
}
|
||||
|
||||
public void a(SerializableImpl paramaH) {
|
||||
this.c = paramaH;
|
||||
}
|
||||
|
||||
public int d() {
|
||||
return this.d;
|
||||
}
|
||||
|
||||
public void a(int paramInt) {
|
||||
this.d = paramInt;
|
||||
}
|
||||
|
||||
public int e() {
|
||||
return b().d();
|
||||
}
|
||||
|
||||
public String f() {
|
||||
return (this.b.e() != 0 && this.b.j() != null) ? this.b.j() : ((this.c.e() != null) ? this.c.e() : "");
|
||||
}
|
||||
|
||||
public String g() {
|
||||
return this.e;
|
||||
}
|
||||
|
||||
public void b(String paramString) {
|
||||
this.e = paramString;
|
||||
}
|
||||
|
||||
public int h() {
|
||||
return this.f;
|
||||
}
|
||||
|
||||
public void b(int paramInt) {
|
||||
this.f = paramInt;
|
||||
}
|
||||
|
||||
public void c(int paramInt) {
|
||||
this.g = new double[paramInt + 1];
|
||||
this.h = 0;
|
||||
for (byte b = 0; b < this.g.length; b++)
|
||||
this.g[b] = Double.NaN;
|
||||
}
|
||||
|
||||
public String i() {
|
||||
return this.i;
|
||||
}
|
||||
|
||||
public void c(String paramString) {
|
||||
this.i = paramString;
|
||||
}
|
||||
|
||||
public String j() {
|
||||
return this.j;
|
||||
}
|
||||
|
||||
public void d(String paramString) {
|
||||
this.j = paramString;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/SerializableImplExceptionprintstacktrace/q.class
|
||||
* Java compiler version: 8 (52.0)
|
||||
* JD-Core Version: 1.1.3
|
||||
*/
|
||||
@@ -0,0 +1,58 @@
|
||||
package SerializableImplExceptionprintstacktrace;
|
||||
|
||||
import G.R;
|
||||
import G.SerializableImplExceptionprintstacktrace;
|
||||
import V.ExceptionPrintstacktrace;
|
||||
import bH.D;
|
||||
import bH.p;
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class AcInterfaceRomeo {
|
||||
public static ArrayList a(R[] paramArrayOfR) {
|
||||
ArrayList<q> arrayList = new ArrayList();
|
||||
for (byte b = 0; b < paramArrayOfR.length; b++) {
|
||||
if (paramArrayOfR[b].S())
|
||||
for (SerializableImplExceptionprintstacktrace SerializableImplExceptionprintstacktrace : paramArrayOfR[b].ExceptionPrintstacktrace()) {
|
||||
D.c(SerializableImplExceptionprintstacktrace.aL());
|
||||
if (a(paramArrayOfR[b], SerializableImplExceptionprintstacktrace)) {
|
||||
q q = new q();
|
||||
if (b == 0) {
|
||||
q.a(SerializableImplExceptionprintstacktrace.b());
|
||||
} else {
|
||||
q.a(paramArrayOfR[b].c() + "." + SerializableImplExceptionprintstacktrace.b());
|
||||
}
|
||||
q.b(paramArrayOfR[b].c());
|
||||
q.a(SerializableImplExceptionprintstacktrace);
|
||||
q.a(b);
|
||||
q.a(paramArrayOfR[b].ExceptionPrintstacktrace(SerializableImplExceptionprintstacktrace.a()));
|
||||
q.b(SerializableImplExceptionprintstacktrace.f());
|
||||
arrayList.add(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
return arrayList;
|
||||
}
|
||||
|
||||
public static boolean a(R paramR, SerializableImplExceptionprintstacktrace paramac) {
|
||||
try {
|
||||
return (paramac.aJ() == null || paramac.aJ().equals("") || p.a(paramac.aJ(), paramR));
|
||||
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
||||
D.b("Unable to process enable logic (Assuming true) for DataLog Field: " + paramac);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean a() {
|
||||
return (c.a().u() || u.a().u());
|
||||
}
|
||||
|
||||
public static String b() {
|
||||
return c.a().u() ? c.a().n() : (u.a().u() ? u.a().n() : null);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/SerializableImplExceptionprintstacktrace/r.class
|
||||
* Java compiler version: 8 (52.0)
|
||||
* JD-Core Version: 1.1.3
|
||||
*/
|
||||
@@ -0,0 +1,158 @@
|
||||
package SerializableImplExceptionprintstacktrace;
|
||||
|
||||
import G.SerializableImpl;
|
||||
import G.SerializableImplExceptionprintstacktrace;
|
||||
import V.ExceptionPrintstacktrace;
|
||||
|
||||
public class AcInterfaceXray extends w {
|
||||
private q a = null;
|
||||
|
||||
private byte[] b = new byte[4];
|
||||
|
||||
private byte[] C = new byte[4];
|
||||
|
||||
private byte D = 0;
|
||||
|
||||
private float E = 1.0F;
|
||||
|
||||
private float F = 0.0F;
|
||||
|
||||
public AcInterfaceXray() {}
|
||||
|
||||
public AcInterfaceXray(q paramq) {
|
||||
a(paramq);
|
||||
}
|
||||
|
||||
public void a(q paramq) {
|
||||
this.a = paramq;
|
||||
SerializableImpl SerializableImpl = paramq.c();
|
||||
if (!SerializableImpl.b().equals("formula")) {
|
||||
this.E = (float)SerializableImpl.h();
|
||||
this.F = (float)SerializableImpl.i();
|
||||
a(SerializableImpl.c());
|
||||
} else if (paramq.b().e() == 1 || paramq.b().e() == 2) {
|
||||
a("U32");
|
||||
} else if (paramq.b().e() == 3) {
|
||||
a("S64");
|
||||
} else {
|
||||
a("F32");
|
||||
}
|
||||
d(paramq.f());
|
||||
a((byte)paramq.e());
|
||||
b(this.E);
|
||||
c(this.F);
|
||||
SerializableImplExceptionprintstacktrace SerializableImplExceptionprintstacktrace = paramq.b();
|
||||
b(paramq.a());
|
||||
e(SerializableImplExceptionprintstacktrace.e());
|
||||
c(paramq.i());
|
||||
}
|
||||
|
||||
public byte[] a(int paramInt) {
|
||||
byte[] arrayOfByte = new byte[d(paramInt)];
|
||||
int i = 0;
|
||||
arrayOfByte[i] = ExceptionPrintstacktrace();
|
||||
System.arraycopy(this.x, 0, arrayOfByte, ++i, this.x.length);
|
||||
i += this.x.length;
|
||||
System.arraycopy(this.z, 0, arrayOfByte, i, this.z.length);
|
||||
i += this.z.length;
|
||||
System.arraycopy(this.A, 0, arrayOfByte, i, this.A.length);
|
||||
i += this.A.length;
|
||||
System.arraycopy(this.b, 0, arrayOfByte, i, this.b.length);
|
||||
i += this.b.length;
|
||||
System.arraycopy(this.C, 0, arrayOfByte, i, this.C.length);
|
||||
i += this.C.length;
|
||||
arrayOfByte[i] = this.D;
|
||||
if (paramInt > 1)
|
||||
System.arraycopy(this.y, 0, arrayOfByte, ++i, this.y.length);
|
||||
return arrayOfByte;
|
||||
}
|
||||
|
||||
public byte[] a(double paramDouble) {
|
||||
byte b = ExceptionPrintstacktrace();
|
||||
if (b == d || b == c) {
|
||||
byte[] arrayOfByte = new byte[1];
|
||||
arrayOfByte[0] = (byte)(int)Math.round(paramDouble / this.E - this.F);
|
||||
return arrayOfByte;
|
||||
}
|
||||
if (b == f || b == e) {
|
||||
byte[] arrayOfByte = new byte[2];
|
||||
int i = (int)Math.round(paramDouble / this.E - this.F);
|
||||
arrayOfByte[0] = (byte)((i & 0xFF00) >> 8);
|
||||
arrayOfByte[1] = (byte)(i & 0xFF);
|
||||
return arrayOfByte;
|
||||
}
|
||||
if (b == h || b == ExceptionPrintstacktrace) {
|
||||
int i = (int)Math.round(paramDouble / this.E - this.F);
|
||||
return f(i);
|
||||
}
|
||||
if (b == j) {
|
||||
float f = (float)(paramDouble / this.E - this.F);
|
||||
return a(f);
|
||||
}
|
||||
if (b == i) {
|
||||
long l = Math.round(paramDouble / this.E - this.F);
|
||||
return a(l);
|
||||
}
|
||||
throw new ExceptionPrintstacktrace("Unsupported Field type: " + b);
|
||||
}
|
||||
|
||||
public int d(int paramInt) {
|
||||
return (paramInt == 1) ? (1 + this.x.length + this.z.length + this.A.length + this.b.length + this.C.length + 1) : (1 + this.x.length + this.z.length + this.A.length + this.b.length + this.C.length + this.y.length + 1);
|
||||
}
|
||||
|
||||
private void a(String paramString) {
|
||||
if (paramString.equals("U08")) {
|
||||
b(c);
|
||||
} else if (paramString.equals("S08")) {
|
||||
b(d);
|
||||
} else if (paramString.equals("U16")) {
|
||||
b(e);
|
||||
} else if (paramString.equals("S16")) {
|
||||
b(f);
|
||||
} else if (paramString.equals("U32")) {
|
||||
b(ExceptionPrintstacktrace);
|
||||
} else if (paramString.equals("S32")) {
|
||||
b(h);
|
||||
} else if (paramString.equals("F32")) {
|
||||
b(j);
|
||||
} else {
|
||||
throw new ExceptionPrintstacktrace("Unsupported Logger Field Type: " + paramString);
|
||||
}
|
||||
}
|
||||
|
||||
public void b(float paramFloat) {
|
||||
this.E = paramFloat;
|
||||
this.b = a(paramFloat, this.b);
|
||||
}
|
||||
|
||||
public float a() {
|
||||
return this.E;
|
||||
}
|
||||
|
||||
public void c(float paramFloat) {
|
||||
this.F = paramFloat;
|
||||
this.C = a(paramFloat, this.C);
|
||||
}
|
||||
|
||||
public float b() {
|
||||
return this.F;
|
||||
}
|
||||
|
||||
public void a(byte paramByte) {
|
||||
this.D = paramByte;
|
||||
}
|
||||
|
||||
public byte c() {
|
||||
return this.D;
|
||||
}
|
||||
|
||||
public double a(byte[][] paramArrayOfbyte) {
|
||||
return this.a.a(paramArrayOfbyte[this.a.d()]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/SerializableImplExceptionprintstacktrace/x.class
|
||||
* Java compiler version: 8 (52.0)
|
||||
* JD-Core Version: 1.1.3
|
||||
*/
|
||||
Reference in New Issue
Block a user