0001: /*
0002: * $Id: Throwables.java,v 1.4 2002/09/16 08:05:02 jkl Exp $
0003: *
0004: * Copyright (c) 2002 Njet Communications Ltd. All Rights Reserved.
0005: *
0006: * Use is subject to license terms, as defined in
0007: * Anvil Sofware License, Version 1.1. See LICENSE
0008: * file, or http://njet.org/license-1.1.txt
0009: */
0010: package anvil.core;
0011:
0012: import anvil.script.Type;
0013: import anvil.script.Context;
0014: import anvil.ErrorListener;
0015:
0016: import java.sql.SQLException;
0017: import javax.naming.NamingException;
0018:
0019: public class Throwables {
0020:
0021: public static class TypeError extends AnyThrowable {
0022:
0023: public static final Object[] newInstance = { null, "*message",
0024: null };
0025:
0026: public static Any newInstance(Context context, String message) {
0027: return new TypeError(context, message);
0028: }
0029:
0030: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0031: "TypeError", TypeError.class, AnyThrowable.__class__,
0032: "");
0033:
0034: public TypeError(Context context, String message) {
0035: super (context, message);
0036: }
0037:
0038: public anvil.script.ClassType classOf() {
0039: return __class__;
0040: }
0041:
0042: public static class BadParameter extends TypeError {
0043:
0044: public static final Object[] newInstance = { null,
0045: "*message", null };
0046:
0047: public static final Any newInstance(Context context,
0048: String message) {
0049: return new BadParameter(context, message);
0050: }
0051:
0052: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0053: "BadParameter", BadParameter.class,
0054: TypeError.__class__, "");
0055:
0056: public BadParameter(Context context, String message) {
0057: super (context, message);
0058: }
0059:
0060: public anvil.script.ClassType classOf() {
0061: return __class__;
0062: }
0063:
0064: }
0065:
0066: public static class NotEnoughParameters extends AnyThrowable {
0067:
0068: public static final Object[] newInstance = { null,
0069: "*message", null };
0070:
0071: public static final Any newInstance(Context context,
0072: String message) {
0073: return new NotEnoughParameters(context, message);
0074: }
0075:
0076: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0077: "NotEnoughParameters", NotEnoughParameters.class,
0078: TypeError.__class__, "");
0079:
0080: public NotEnoughParameters(Context context, String message) {
0081: super (context, message);
0082: }
0083:
0084: public anvil.script.ClassType classOf() {
0085: return __class__;
0086: }
0087:
0088: }
0089:
0090: public static class NoSuchMethod extends AnyThrowable {
0091:
0092: public static final Object[] newInstance = { null,
0093: "*message", null };
0094:
0095: public static final Any newInstance(Context context,
0096: String message) {
0097: return new NoSuchMethod(context, message);
0098: }
0099:
0100: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0101: "NoSuchMethod", NoSuchMethod.class,
0102: TypeError.__class__, "");
0103:
0104: public NoSuchMethod(Context context, String message) {
0105: super (context, message);
0106: }
0107:
0108: public anvil.script.ClassType classOf() {
0109: return __class__;
0110: }
0111:
0112: }
0113:
0114: public static class NoSuchMember extends AnyThrowable {
0115:
0116: public static final Object[] newInstance = { null,
0117: "*message", null };
0118:
0119: public static final Any newInstance(Context context,
0120: String message) {
0121: return new NoSuchMember(context, message);
0122: }
0123:
0124: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0125: "NoSuchMember", NoSuchMember.class,
0126: TypeError.__class__, "");
0127:
0128: public NoSuchMember(Context context, String message) {
0129: super (context, message);
0130: }
0131:
0132: public anvil.script.ClassType classOf() {
0133: return __class__;
0134: }
0135:
0136: }
0137:
0138: public static class NoSuchFunction extends AnyThrowable {
0139:
0140: public static final Object[] newInstance = { null,
0141: "*message", null };
0142:
0143: public static final Any newInstance(Context context,
0144: String message) {
0145: return new NoSuchFunction(context, message);
0146: }
0147:
0148: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0149: "NoSuchFunction", NoSuchFunction.class,
0150: TypeError.__class__, "");
0151:
0152: public NoSuchFunction(Context context, String message) {
0153: super (context, message);
0154: }
0155:
0156: public anvil.script.ClassType classOf() {
0157: return __class__;
0158: }
0159:
0160: }
0161:
0162: public static class NoSuchClass extends AnyThrowable {
0163:
0164: public static final Object[] newInstance = { null,
0165: "*message", null };
0166:
0167: public static final Any newInstance(Context context,
0168: String message) {
0169: return new NoSuchClass(context, message);
0170: }
0171:
0172: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0173: "NoSuchClass", NoSuchClass.class,
0174: TypeError.__class__, "");
0175:
0176: public NoSuchClass(Context context, String message) {
0177: super (context, message);
0178: }
0179:
0180: public anvil.script.ClassType classOf() {
0181: return __class__;
0182: }
0183:
0184: }
0185:
0186: public static class NoSuchEntity extends AnyThrowable {
0187:
0188: public static final Object[] newInstance = { null,
0189: "*message", null };
0190:
0191: public static final Any newInstance(Context context,
0192: String message) {
0193: return new NoSuchEntity(context, message);
0194: }
0195:
0196: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0197: "NoSuchEntity", NoSuchEntity.class,
0198: TypeError.__class__, "");
0199:
0200: public NoSuchEntity(Context context, String message) {
0201: super (context, message);
0202: }
0203:
0204: public anvil.script.ClassType classOf() {
0205: return __class__;
0206: }
0207:
0208: }
0209:
0210: public static class NoInstance extends AnyThrowable {
0211:
0212: public static final Object[] newInstance = { null,
0213: "*message", null };
0214:
0215: public static final Any newInstance(Context context,
0216: String message) {
0217: return new NoInstance(context, message);
0218: }
0219:
0220: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0221: "NoInstance", NoInstance.class,
0222: TypeError.__class__, "");
0223:
0224: public NoInstance(Context context, String message) {
0225: super (context, message);
0226: }
0227:
0228: public anvil.script.ClassType classOf() {
0229: return __class__;
0230: }
0231:
0232: }
0233:
0234: public static class InstantiationError extends AnyThrowable {
0235:
0236: public static final Object[] newInstance = { null,
0237: "*message", null };
0238:
0239: public static final Any newInstance(Context context,
0240: String message) {
0241: return new InstantiationError(context, message);
0242: }
0243:
0244: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0245: "InstantiationError", InstantiationError.class,
0246: TypeError.__class__, "");
0247:
0248: public InstantiationError(Context context, String message) {
0249: super (context, message);
0250: }
0251:
0252: public anvil.script.ClassType classOf() {
0253: return __class__;
0254: }
0255:
0256: }
0257:
0258: public static class AttributeError extends AnyThrowable {
0259:
0260: public static final Object[] newInstance = { null,
0261: "*message", null };
0262:
0263: public static final Any newInstance(Context context,
0264: String message) {
0265: return new AttributeError(context, message);
0266: }
0267:
0268: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0269: "AttributeError", AttributeError.class,
0270: TypeError.__class__, "");
0271:
0272: public AttributeError(Context context, String message) {
0273: super (context, message);
0274: }
0275:
0276: public anvil.script.ClassType classOf() {
0277: return __class__;
0278: }
0279:
0280: }
0281:
0282: public static class ReferenceError extends AnyThrowable {
0283:
0284: public static final Object[] newInstance = { null,
0285: "*message", null };
0286:
0287: public static final Any newInstance(Context context,
0288: String message) {
0289: return new ReferenceError(context, message);
0290: }
0291:
0292: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0293: "ReferenceError", ReferenceError.class,
0294: TypeError.__class__, "");
0295:
0296: public ReferenceError(Context context, String message) {
0297: super (context, message);
0298: }
0299:
0300: public anvil.script.ClassType classOf() {
0301: return __class__;
0302: }
0303:
0304: }
0305:
0306: public static class CallError extends AnyThrowable {
0307:
0308: public static final Object[] newInstance = { null,
0309: "*message", null };
0310:
0311: public static final Any newInstance(Context context,
0312: String message) {
0313: return new CallError(context, message);
0314: }
0315:
0316: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0317: "CallError", CallError.class, TypeError.__class__,
0318: "");
0319:
0320: public CallError(Context context, String message) {
0321: super (context, message);
0322: }
0323:
0324: public anvil.script.ClassType classOf() {
0325: return __class__;
0326: }
0327:
0328: }
0329:
0330: }
0331:
0332: public static class JavaError extends AnyThrowable {
0333: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0334: "JavaError", JavaError.class, AnyThrowable.__class__,
0335: "");
0336:
0337: private static final String getMessage(Throwable throwable) {
0338: String cls = throwable.getClass().getName();
0339: String msg = throwable.getMessage();
0340: if (msg == null || msg.length() == 0) {
0341: return cls;
0342: } else {
0343: return cls + ": " + msg;
0344: }
0345: }
0346:
0347: private Throwable _throwable;
0348:
0349: public JavaError(Context context, Throwable throwable) {
0350: super (context, getMessage(throwable));
0351: _throwable = throwable;
0352: }
0353:
0354: public anvil.script.ClassType classOf() {
0355: return __class__;
0356: }
0357:
0358: public Any m_getType() {
0359: return Any.create(_throwable.getClass().getName());
0360: }
0361:
0362: public Any m_getThrowable() {
0363: return new AnyObject(_throwable);
0364: }
0365:
0366: public Any m_getJavaStackTrace() {
0367: java.io.CharArrayWriter writer = new java.io.CharArrayWriter();
0368: java.io.PrintWriter printwriter = new java.io.PrintWriter(
0369: writer);
0370: _throwable.printStackTrace(printwriter);
0371: return Any.create(writer.toString());
0372: }
0373:
0374: }
0375:
0376: public static class BadState extends AnyThrowable {
0377:
0378: public static final Object[] newInstance = { null, "*message",
0379: null };
0380:
0381: public static final Any newInstance(Context context,
0382: String message) {
0383: return new BadState(context, message);
0384: }
0385:
0386: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0387: "BadState", BadState.class, AnyThrowable.__class__, "");
0388:
0389: public BadState(Context context, String message) {
0390: super (context, message);
0391: }
0392:
0393: public anvil.script.ClassType classOf() {
0394: return __class__;
0395: }
0396:
0397: }
0398:
0399: public static class Interrupted extends AnyThrowable {
0400:
0401: public static final Object[] newInstance = { null, "*message",
0402: null };
0403:
0404: public static final Any newInstance(Context context,
0405: String message) {
0406: return new Interrupted(context, message);
0407: }
0408:
0409: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0410: "Interrupted", Interrupted.class,
0411: AnyThrowable.__class__, "");
0412:
0413: public Interrupted(Context context, String message) {
0414: super (context, message);
0415: }
0416:
0417: public anvil.script.ClassType classOf() {
0418: return __class__;
0419: }
0420:
0421: }
0422:
0423: public static class AssertFailed extends AnyThrowable {
0424:
0425: public static final Object[] newInstance = { null, "*message",
0426: null };
0427:
0428: public static final Any newInstance(Context context,
0429: String message) {
0430: return new AssertFailed(context, message);
0431: }
0432:
0433: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0434: "AssertFailed", AssertFailed.class,
0435: AnyThrowable.__class__, "");
0436:
0437: public AssertFailed(Context context, String message) {
0438: super (context, message);
0439: }
0440:
0441: public anvil.script.ClassType classOf() {
0442: return __class__;
0443: }
0444:
0445: }
0446:
0447: public static class CorruptedSerialization extends AnyThrowable {
0448:
0449: public static final Object[] newInstance = { null, "*message",
0450: null };
0451:
0452: public static final Any newInstance(Context context,
0453: String message) {
0454: return new CorruptedSerialization(context, message);
0455: }
0456:
0457: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0458: "CorruptedSerialization", CorruptedSerialization.class,
0459: AnyThrowable.__class__, "");
0460:
0461: public CorruptedSerialization(Context context, String message) {
0462: super (context, message);
0463: }
0464:
0465: public anvil.script.ClassType classOf() {
0466: return __class__;
0467: }
0468:
0469: }
0470:
0471: public static class MalformedPattern extends AnyThrowable {
0472:
0473: public static final Object[] newInstance = { null, "*message",
0474: null };
0475:
0476: public static final Any newInstance(Context context,
0477: String message) {
0478: return new MalformedPattern(context, message);
0479: }
0480:
0481: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0482: "MalformedPattern", MalformedPattern.class,
0483: AnyThrowable.__class__, "");
0484:
0485: public MalformedPattern(Context context, String message) {
0486: super (context, message);
0487: }
0488:
0489: public anvil.script.ClassType classOf() {
0490: return __class__;
0491: }
0492:
0493: }
0494:
0495: public static class AcquireError extends AnyThrowable {
0496:
0497: public static final Object[] newInstance = { null, "*message",
0498: null };
0499:
0500: public static final Any newInstance(Context context,
0501: String message) {
0502: return new AcquireError(context, message);
0503: }
0504:
0505: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0506: "AcquireError", AcquireError.class,
0507: AnyThrowable.__class__, "");
0508:
0509: public AcquireError(Context context, String message) {
0510: super (context, message);
0511: }
0512:
0513: public anvil.script.ClassType classOf() {
0514: return __class__;
0515: }
0516:
0517: }
0518:
0519: public static class XMLError extends AnyThrowable {
0520:
0521: public static final Object[] newInstance = { null, "*message",
0522: null };
0523:
0524: public static final Any newInstance(Context context,
0525: String message) {
0526: return new XMLError(context, message, null);
0527: }
0528:
0529: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0530: "XMLError", XMLError.class, AnyThrowable.__class__, "");
0531:
0532: public XMLError(Context context, String message,
0533: ErrorListener listener) {
0534: super (context, message, listener);
0535: }
0536:
0537: public anvil.script.ClassType classOf() {
0538: return __class__;
0539: }
0540:
0541: }
0542:
0543: public static class ImportError extends AnyThrowable {
0544:
0545: public static final Object[] newInstance = { null, "*message",
0546: null };
0547:
0548: public static final Any newInstance(Context context,
0549: String message) {
0550: return new ImportError(context, message, null);
0551: }
0552:
0553: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0554: "ImportError", ImportError.class,
0555: AnyThrowable.__class__, "");
0556:
0557: public ImportError(Context context, String message,
0558: ErrorListener listener) {
0559: super (context, message, listener);
0560: }
0561:
0562: public anvil.script.ClassType classOf() {
0563: return __class__;
0564: }
0565:
0566: }
0567:
0568: public static class AccessDenied extends AnyThrowable {
0569:
0570: public static final Object[] newInstance = { null, "*message",
0571: null };
0572:
0573: public static final Any newInstance(Context context,
0574: String message) {
0575: return new AccessDenied(context, message);
0576: }
0577:
0578: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0579: "AccessDenied", AccessDenied.class,
0580: AnyThrowable.__class__, "");
0581:
0582: public AccessDenied(Context context, String message) {
0583: super (context, message);
0584: }
0585:
0586: public anvil.script.ClassType classOf() {
0587: return __class__;
0588: }
0589:
0590: }
0591:
0592: public static class ClassNotFound extends AnyThrowable {
0593:
0594: public static final Object[] newInstance = { null, "*message",
0595: null };
0596:
0597: public static final Any newInstance(Context context,
0598: String message) {
0599: return new ClassNotFound(context, message);
0600: }
0601:
0602: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0603: "ClassNotFound", ClassNotFound.class,
0604: AnyThrowable.__class__, "");
0605:
0606: public ClassNotFound(Context context, String message) {
0607: super (context, message);
0608: }
0609:
0610: public anvil.script.ClassType classOf() {
0611: return __class__;
0612: }
0613:
0614: }
0615:
0616: public static class InternalError extends AnyThrowable {
0617:
0618: public static final Object[] newInstance = { null, "*message",
0619: null };
0620:
0621: public static final Any newInstance(Context context,
0622: String message) {
0623: return new InternalError(context, message);
0624: }
0625:
0626: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0627: "InternalError", InternalError.class,
0628: AnyThrowable.__class__, "");
0629:
0630: public InternalError(Context context, String message) {
0631: super (context, message);
0632: }
0633:
0634: public anvil.script.ClassType classOf() {
0635: return __class__;
0636: }
0637:
0638: }
0639:
0640: public static class OperationFailed extends AnyThrowable {
0641:
0642: public static final Object[] newInstance = { null, "*message",
0643: null };
0644:
0645: public static final Any newInstance(Context context,
0646: String message) {
0647: return new OperationFailed(context, message);
0648: }
0649:
0650: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0651: "OperationFailed", OperationFailed.class,
0652: AnyThrowable.__class__, "");
0653:
0654: public OperationFailed(Context context, String message) {
0655: super (context, message);
0656: }
0657:
0658: public anvil.script.ClassType classOf() {
0659: return __class__;
0660: }
0661:
0662: }
0663:
0664: public static class SQLError extends AnyThrowable {
0665: protected SQLException _exception;
0666:
0667: public static final Object[] newInstance = { null, "*reason",
0668: null, "*state", null, "vendorCode", null };
0669:
0670: public static final Any newInstance(Context context,
0671: String reason, String state, int vendorCode) {
0672: return new SQLError(context, new SQLException(reason,
0673: state, vendorCode));
0674: }
0675:
0676: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0677: "SQLError", SQLError.class, AnyThrowable.__class__, "");
0678:
0679: public SQLError(Context context, SQLException exception) {
0680: super (context, exception.getMessage());
0681: _exception = exception;
0682: }
0683:
0684: public anvil.script.ClassType classOf() {
0685: return __class__;
0686: }
0687:
0688: public Any m_getErrorCode() {
0689: return Any.create(_exception.getErrorCode());
0690: }
0691:
0692: public Any m_getSQLState() {
0693: return Any.create(_exception.getSQLState());
0694: }
0695:
0696: public Any m_getNextException(Context context) {
0697: SQLException next = _exception.getNextException();
0698: if (next != null) {
0699: return new SQLError(context, next);
0700: }
0701: return NULL;
0702: }
0703: }
0704:
0705: public static class IOError extends AnyThrowable {
0706:
0707: public static final Object[] newInstance = { null, "*message",
0708: null };
0709:
0710: public static Any newInstance(Context context, String message) {
0711: return new IOError(context, message);
0712: }
0713:
0714: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0715: "IOError", IOError.class, AnyThrowable.__class__, "");
0716:
0717: public IOError(Context context, String message) {
0718: super (context, message);
0719: }
0720:
0721: public anvil.script.ClassType classOf() {
0722: return __class__;
0723: }
0724:
0725: public static class FileNotFound extends IOError {
0726:
0727: public static final Object[] newInstance = { null,
0728: "*message", null };
0729:
0730: public static final Any newInstance(Context context,
0731: String message) {
0732: return new FileNotFound(context, message);
0733: }
0734:
0735: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0736: "FileNotFound", FileNotFound.class,
0737: IOError.__class__, "");
0738:
0739: public FileNotFound(Context context, String message) {
0740: super (context, message);
0741: }
0742:
0743: public anvil.script.ClassType classOf() {
0744: return __class__;
0745: }
0746:
0747: }
0748:
0749: public static class InterruptedIO extends IOError {
0750:
0751: public static final Object[] newInstance = { null,
0752: "*message", null };
0753:
0754: public static final Any newInstance(Context context,
0755: String message) {
0756: return new InterruptedIO(context, message);
0757: }
0758:
0759: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0760: "InterruptedIO", InterruptedIO.class,
0761: IOError.__class__, "");
0762:
0763: public InterruptedIO(Context context, String message) {
0764: super (context, message);
0765: }
0766:
0767: public anvil.script.ClassType classOf() {
0768: return __class__;
0769: }
0770:
0771: }
0772:
0773: public static class SyncFailed extends IOError {
0774:
0775: public static final Object[] newInstance = { null,
0776: "*message", null };
0777:
0778: public static final Any newInstance(Context context,
0779: String message) {
0780: return new SyncFailed(context, message);
0781: }
0782:
0783: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0784: "SyncFailed", SyncFailed.class, IOError.__class__,
0785: "");
0786:
0787: public SyncFailed(Context context, String message) {
0788: super (context, message);
0789: }
0790:
0791: public anvil.script.ClassType classOf() {
0792: return __class__;
0793: }
0794:
0795: }
0796:
0797: public static class EndOfFile extends IOError {
0798:
0799: public static final Object[] newInstance = { null,
0800: "*message", null };
0801:
0802: public static final Any newInstance(Context context,
0803: String message) {
0804: return new EndOfFile(context, message);
0805: }
0806:
0807: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0808: "EndOfFile", EndOfFile.class, IOError.__class__, "");
0809:
0810: public EndOfFile(Context context, String message) {
0811: super (context, message);
0812: }
0813:
0814: public anvil.script.ClassType classOf() {
0815: return __class__;
0816: }
0817:
0818: }
0819:
0820: public static class SocketError extends IOError {
0821:
0822: public static final Object[] newInstance = { null,
0823: "*message", null };
0824:
0825: public static Any newInstance(Context context,
0826: String message) {
0827: return new SocketError(context, message);
0828: }
0829:
0830: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0831: "SocketError", SocketError.class,
0832: IOError.__class__, "");
0833:
0834: public SocketError(Context context, String message) {
0835: super (context, message);
0836: }
0837:
0838: public anvil.script.ClassType classOf() {
0839: return __class__;
0840: }
0841:
0842: public static class BindError extends SocketError {
0843:
0844: public static final Object[] newInstance = { null,
0845: "*message", null };
0846:
0847: public static final Any newInstance(Context context,
0848: String message) {
0849: return new BindError(context, message);
0850: }
0851:
0852: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0853: "BindError", BindError.class,
0854: SocketError.__class__, "");
0855:
0856: public BindError(Context context, String message) {
0857: super (context, message);
0858: }
0859:
0860: public anvil.script.ClassType classOf() {
0861: return __class__;
0862: }
0863:
0864: }
0865:
0866: public static class ConnectError extends SocketError {
0867:
0868: public static final Object[] newInstance = { null,
0869: "*message", null };
0870:
0871: public static final Any newInstance(Context context,
0872: String message) {
0873: return new ConnectError(context, message);
0874: }
0875:
0876: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0877: "ConnectError", ConnectError.class,
0878: SocketError.__class__, "");
0879:
0880: public ConnectError(Context context, String message) {
0881: super (context, message);
0882: }
0883:
0884: public anvil.script.ClassType classOf() {
0885: return __class__;
0886: }
0887:
0888: }
0889:
0890: public static class NoRouteToHost extends SocketError {
0891:
0892: public static final Object[] newInstance = { null,
0893: "*message", null };
0894:
0895: public static final Any newInstance(Context context,
0896: String message) {
0897: return new NoRouteToHost(context, message);
0898: }
0899:
0900: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0901: "NoRouteToHost", NoRouteToHost.class,
0902: SocketError.__class__, "");
0903:
0904: public NoRouteToHost(Context context, String message) {
0905: super (context, message);
0906: }
0907:
0908: public anvil.script.ClassType classOf() {
0909: return __class__;
0910: }
0911:
0912: }
0913:
0914: }
0915:
0916: public static class MalformedURL extends IOError {
0917:
0918: public static final Object[] newInstance = { null,
0919: "*message", null };
0920:
0921: public static final Any newInstance(Context context,
0922: String message) {
0923: return new MalformedURL(context, message);
0924: }
0925:
0926: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0927: "MalformedURL", MalformedURL.class,
0928: IOError.__class__, "");
0929:
0930: public MalformedURL(Context context, String message) {
0931: super (context, message);
0932: }
0933:
0934: public anvil.script.ClassType classOf() {
0935: return __class__;
0936: }
0937:
0938: }
0939:
0940: public static class UnknownHost extends IOError {
0941:
0942: public static final Object[] newInstance = { null,
0943: "*message", null };
0944:
0945: public static final Any newInstance(Context context,
0946: String message) {
0947: return new UnknownHost(context, message);
0948: }
0949:
0950: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0951: "UnknownHost", UnknownHost.class,
0952: IOError.__class__, "");
0953:
0954: public UnknownHost(Context context, String message) {
0955: super (context, message);
0956: }
0957:
0958: public anvil.script.ClassType classOf() {
0959: return __class__;
0960: }
0961:
0962: }
0963:
0964: public static class ProtocolError extends IOError {
0965:
0966: public static final Object[] newInstance = { null,
0967: "*message", null };
0968:
0969: public static final Any newInstance(Context context,
0970: String message) {
0971: return new ProtocolError(context, message);
0972: }
0973:
0974: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0975: "ProtocolError", ProtocolError.class,
0976: IOError.__class__, "");
0977:
0978: public ProtocolError(Context context, String message) {
0979: super (context, message);
0980: }
0981:
0982: public anvil.script.ClassType classOf() {
0983: return __class__;
0984: }
0985:
0986: }
0987:
0988: public static class UnknownService extends IOError {
0989:
0990: public static final Object[] newInstance = { null,
0991: "*message", null };
0992:
0993: public static final Any newInstance(Context context,
0994: String message) {
0995: return new UnknownService(context, message);
0996: }
0997:
0998: public static final anvil.script.compiler.NativeClass __class__ = new anvil.script.compiler.NativeClass(
0999: "UnknownService", UnknownService.class,
1000: IOError.__class__, "");
1001:
1002: public UnknownService(Context context, String message) {
1003: super (context, message);
1004: }
1005:
1006: public anvil.script.ClassType classOf() {
1007: return __class__;
1008: }
1009:
1010: }
1011:
1012: }
1013:
1014: }
|