public Client(ClientCodec codec = default, sync.Mutex reqMutex = default, Request request = default, sync.Mutex mutex = default, ulong seq = default, map <ulong, ptr <Call> > pending = default, bool closing = default, bool shutdown = default)
{
this.codec = codec;
this.reqMutex = reqMutex;
this.request = request;
this.mutex = mutex;
this.seq = seq;
this.pending = pending;
this.closing = closing;
this.shutdown = shutdown;
}
public Decoder(sync.Mutex mutex = default, io.Reader r = default, decBuffer buf = default, map <typeId, ptr <wireType> > wireType = default, map <reflect.Type, map <typeId, ptr <ptr <decEngine> > > > decoderCache = default, map <typeId, ptr <ptr <decEngine> > > ignorerCache = default, ref ptr <decoderState> freeList = default, slice <byte> countBuf = default, error err = default)
{
this.mutex = mutex;
this.r = r;
this.buf = buf;
this.wireType = wireType;
this.decoderCache = decoderCache;
this.ignorerCache = ignorerCache;
this.freeList = freeList;
this.countBuf = countBuf;
this.err = err;
}
public pipe(sync.Mutex wrMu = default, channel <slice <byte> > rdRx = default, channel <long> rdTx = default, channel <slice <byte> > wrTx = default, channel <long> wrRx = default, sync.Once once = default, channel <object> localDone = default, channel <object> remoteDone = default, pipeDeadline readDeadline = default, pipeDeadline writeDeadline = default)
{
this.wrMu = wrMu;
this.rdRx = rdRx;
this.rdTx = rdTx;
this.wrTx = wrTx;
this.wrRx = wrRx;
this.once = once;
this.localDone = localDone;
this.remoteDone = remoteDone;
this.readDeadline = readDeadline;
this.writeDeadline = writeDeadline;
}
public ServerConn(sync.Mutex mu = default, net.Conn c = default, ref ptr <bufio.Reader> r = default, error re = default, error we = default, io.ReadCloser lastbody = default, long nread = default, long nwritten = default, map <ptr <http.Request>, ulong> pipereq = default, textproto.Pipeline pipe = default)
{
this.mu = mu;
this.c = c;
this.r = r;
this.re = re;
this.we = we;
this.lastbody = lastbody;
this.nread = nread;
this.nwritten = nwritten;
this.pipereq = pipereq;
this.pipe = pipe;
}
public FD(fdMutex fdmu = default, Action Destroy = default, sync.Mutex rmu = default, sync.Mutex wmu = default, ref ptr <asyncIO> raio = default, ref ptr <asyncIO> waio = default, ref ptr <time.Timer> rtimer = default, ref ptr <time.Timer> wtimer = default, atomicBool rtimedout = default, atomicBool wtimedout = default, bool isFile = default)
{
this.fdmu = fdmu;
this.Destroy = Destroy;
this.rmu = rmu;
this.wmu = wmu;
this.raio = raio;
this.waio = waio;
this.rtimer = rtimer;
this.wtimer = wtimer;
this.rtimedout = rtimedout;
this.wtimedout = wtimedout;
this.isFile = isFile;
}
public DB(long waitDuration = default, driver.Connector connector = default, ulong numClosed = default, sync.Mutex mu = default, slice <ptr <driverConn> > freeConn = default, map <ulong, channel <connRequest> > connRequests = default, ulong nextRequest = default, long numOpen = default, channel <object> openerCh = default, bool closed = default, map <finalCloser, depSet> dep = default, map <ptr <driverConn>, @string> lastPut = default, long maxIdleCount = default, long maxOpen = default, time.Duration maxLifetime = default, time.Duration maxIdleTime = default, channel <object> cleanerCh = default, long waitCount = default, long maxIdleClosed = default, long maxIdleTimeClosed = default, long maxLifetimeClosed = default, Action stop = default)
{
this.waitDuration = waitDuration;
this.connector = connector;
this.numClosed = numClosed;
this.mu = mu;
this.freeConn = freeConn;
this.connRequests = connRequests;
this.nextRequest = nextRequest;
this.numOpen = numOpen;
this.openerCh = openerCh;
this.closed = closed;
this.dep = dep;
this.lastPut = lastPut;
this.maxIdleCount = maxIdleCount;
this.maxOpen = maxOpen;
this.maxLifetime = maxLifetime;
this.maxIdleTime = maxIdleTime;
this.cleanerCh = cleanerCh;
this.waitCount = waitCount;
this.maxIdleClosed = maxIdleClosed;
this.maxIdleTimeClosed = maxIdleTimeClosed;
this.maxLifetimeClosed = maxLifetimeClosed;
this.stop = stop;
}
public Transport(sync.Mutex idleMu = default, bool closeIdle = default, map <connectMethodKey, slice <ptr <persistConn> > > idleConn = default, map <connectMethodKey, wantConnQueue> idleConnWait = default, connLRU idleLRU = default, sync.Mutex reqMu = default, map <cancelKey, Action <error> > reqCanceler = default, sync.Mutex altMu = default, atomic.Value altProto = default, sync.Mutex connsPerHostMu = default, map <connectMethodKey, long> connsPerHost = default, map <connectMethodKey, wantConnQueue> connsPerHostWait = default, Func <ptr <Request>, (ptr <url.URL>, error)> Proxy = default, Func <context.Context, @string, @string, (net.Conn, error)> DialContext = default, Func <@string, @string, (net.Conn, error)> Dial = default, Func <context.Context, @string, @string, (net.Conn, error)> DialTLSContext = default, Func <@string, @string, (net.Conn, error)> DialTLS = default, ref ptr <tls.Config> TLSClientConfig = default, time.Duration TLSHandshakeTimeout = default, bool DisableKeepAlives = default, bool DisableCompression = default, long MaxIdleConns = default, long MaxIdleConnsPerHost = default, long MaxConnsPerHost = default, time.Duration IdleConnTimeout = default, time.Duration ResponseHeaderTimeout = default, time.Duration ExpectContinueTimeout = default, map <@string, Func <@string, ptr <tls.Conn>, RoundTripper> > TLSNextProto = default, Header ProxyConnectHeader = default, long MaxResponseHeaderBytes = default, long WriteBufferSize = default, long ReadBufferSize = default, sync.Once nextProtoOnce = default, h2Transport h2transport = default, bool tlsNextProtoWasNil = default, bool ForceAttemptHTTP2 = default)
public Program(ref ptr <token.FileSet> Fset = default, map <@string, ptr <Package> > imported = default, map <ptr <types.Package>, ptr <Package> > packages = default, BuilderMode mode = default, typeutil.MethodSetCache MethodSets = default, sync.Mutex methodsMu = default, typeutil.Map methodSets = default, typeutil.Map runtimeTypes = default, typeutil.Map canon = default, map <ptr <types.Func>, ptr <Function> > bounds = default, map <selectionKey, ptr <Function> > thunks = default)
{
this.Fset = Fset;
this.imported = imported;
this.packages = packages;
this.mode = mode;
this.MethodSets = MethodSets;
this.methodsMu = methodsMu;
this.methodSets = methodSets;
this.runtimeTypes = runtimeTypes;
this.canon = canon;
this.bounds = bounds;
this.thunks = thunks;
}
public child(ref ptr <conn> conn = default, http.Handler handler = default, sync.Mutex mu = default, map <ushort, ptr <request> > requests = default)
{
this.conn = conn;
this.handler = handler;
this.mu = mu;
this.requests = requests;
}
public Mutex(@string Path = default, sync.Mutex mu = default)
{
this.Path = Path;
this.mu = mu;
}
public Group(sync.Mutex mu = default, map <@string, ptr <call> > m = default)
{
this.mu = mu;
this.m = m;
}
public SafeCounter(sync.Mutex mu = default, map <@string, int> v = default)
{
this.mu = mu;
this.v = v;
}
public lockedSource(sync.Mutex lk = default, ref ptr <rngSource> src = default)
{
this.lk = lk;
this.src = src;
}
public ErrorReporter(loader.ErrorReporter ErrorReporter = default, sync.Once unresOnce = default, map <unresolvedSymKey, bool> unresSyms = default, map <unresolvedSymKey2, bool> unresSyms2 = default, sync.Mutex unresMutex = default, lookupFn lookup = default, symNameFn SymName = default)
{
this.m_ErrorReporterRef = new ptr <loader.ErrorReporter>(ErrorReporter);
this.unresOnce = unresOnce;
this.unresSyms = unresSyms;
this.unresSyms2 = unresSyms2;
this.unresMutex = unresMutex;
this.lookup = lookup;
this.SymName = SymName;
}
public sequencer(sync.Mutex mu = default, ulong id = default, map <ulong, channel <object> > wait = default)
{
this.mu = mu;
this.id = id;
this.wait = wait;
}
public FieldMutex(sync.Mutex s = default)
{
this.s = s;
}
public testContext(ref ptr <matcher> match = default, time.Time deadline = default, sync.Mutex mu = default, channel <bool> startParallel = default, long running = default, long numWaiting = default, long maxParallel = default)
{
this.match = match;
this.deadline = deadline;
this.mu = mu;
this.startParallel = startParallel;
this.running = running;
this.numWaiting = numWaiting;
this.maxParallel = maxParallel;
}
public http2serverInternalState(sync.Mutex mu = default)
{
this.mu = mu;
}
public clientCodec(ref ptr <json.Decoder> dec = default, ref ptr <json.Encoder> enc = default, io.Closer c = default, clientRequest req = default, clientResponse resp = default, sync.Mutex mutex = default, map <ulong, @string> pending = default)
{
this.dec = dec;
this.enc = enc;
this.c = c;
this.req = req;
this.resp = resp;
this.mutex = mutex;
this.pending = pending;
}
public Client(ClientOps ops = default, uint didLookup = default, sync.Once initOnce = default, error initErr = default, @string name = default, note.Verifiers verifiers = default, tileReader tileReader = default, long tileHeight = default, @string nosumdb = default, parCache record = default, parCache tileCache = default, sync.Mutex latestMu = default, tlog.Tree latest = default, slice <byte> latestMsg = default, sync.Mutex tileSavedMu = default, map <tlog.Tile, bool> tileSaved = default)
{
this.ops = ops;
this.didLookup = didLookup;
this.initOnce = initOnce;
this.initErr = initErr;
this.name = name;
this.verifiers = verifiers;
this.tileReader = tileReader;
this.tileHeight = tileHeight;
this.nosumdb = nosumdb;
this.record = record;
this.tileCache = tileCache;
this.latestMu = latestMu;
this.latest = latest;
this.latestMsg = latestMsg;
this.tileSavedMu = tileSavedMu;
this.tileSaved = tileSaved;
}
public body(io.Reader src = default, ref ptr <bufio.Reader> r = default, bool closing = default, bool doEarlyClose = default, sync.Mutex mu = default, bool sawEOF = default, bool closed = default, bool earlyClose = default, Action onHitEOF = default)
{
this.src = src;
this.r = r;
this.closing = closing;
this.doEarlyClose = doEarlyClose;
this.mu = mu;
this.sawEOF = sawEOF;
this.closed = closed;
this.earlyClose = earlyClose;
this.onHitEOF = onHitEOF;
}
public L2(sync.Mutex Mutex = default)
{
this.m_MutexRef = new ptr <sync.Mutex>(Mutex);
}
public response(ref ptr <conn> conn = default, ref ptr <Request> req = default, io.ReadCloser reqBody = default, context.CancelFunc cancelCtx = default, bool wroteHeader = default, bool wroteContinue = default, bool wants10KeepAlive = default, bool wantsClose = default, atomicBool canWriteContinue = default, sync.Mutex writeContinueMu = default, ref ptr <bufio.Writer> w = default, chunkWriter cw = default, Header handlerHeader = default, bool calledHeader = default, long written = default, long contentLength = default, long status = default, bool closeAfterReply = default, bool requestBodyLimitHit = default, slice <@string> trailers = default, atomicBool handlerDone = default, array <byte> dateBuf = default, array <byte> clenBuf = default, array <byte> statusBuf = default, channel <bool> closeNotifyCh = default, int didCloseNotify = default)
{
this.conn = conn;
this.req = req;
this.reqBody = reqBody;
this.cancelCtx = cancelCtx;
this.wroteHeader = wroteHeader;
this.wroteContinue = wroteContinue;
this.wants10KeepAlive = wants10KeepAlive;
this.wantsClose = wantsClose;
this.canWriteContinue = canWriteContinue;
this.writeContinueMu = writeContinueMu;
this.w = w;
this.cw = cw;
this.handlerHeader = handlerHeader;
this.calledHeader = calledHeader;
this.written = written;
this.contentLength = contentLength;
this.status = status;
this.closeAfterReply = closeAfterReply;
this.requestBodyLimitHit = requestBodyLimitHit;
this.trailers = trailers;
this.handlerDone = handlerDone;
this.dateBuf = dateBuf;
this.clenBuf = clenBuf;
this.statusBuf = statusBuf;
this.closeNotifyCh = closeNotifyCh;
this.didCloseNotify = didCloseNotify;
}
public Span(@string Name = default, SpanContext ID = default, SpanID ParentID = default, sync.Mutex mu = default, core.Event start = default, core.Event finish = default, slice <core.Event> events = default)
{
this.Name = Name;
this.ID = ID;
this.ParentID = ParentID;
this.mu = mu;
this.start = start;
this.finish = finish;
this.events = events;
}
public Profile(slice <ptr <ValueType> > SampleType = default, @string DefaultSampleType = default, slice <ptr <Sample> > Sample = default, slice <ptr <Mapping> > Mapping = default, slice <ptr <Location> > Location = default, slice <ptr <Function> > Function = default, slice <@string> Comments = default, @string DropFrames = default, @string KeepFrames = default, long TimeNanos = default, long DurationNanos = default, ref ptr <ValueType> PeriodType = default, long Period = default, sync.Mutex encodeMu = default, slice <long> commentX = default, long dropFramesX = default, long keepFramesX = default, slice <@string> stringTable = default, long defaultSampleTypeX = default)
{
this.SampleType = SampleType;
this.DefaultSampleType = DefaultSampleType;
this.Sample = Sample;
this.Mapping = Mapping;
this.Location = Location;
this.Function = Function;
this.Comments = Comments;
this.DropFrames = DropFrames;
this.KeepFrames = KeepFrames;
this.TimeNanos = TimeNanos;
this.DurationNanos = DurationNanos;
this.PeriodType = PeriodType;
this.Period = Period;
this.encodeMu = encodeMu;
this.commentX = commentX;
this.dropFramesX = dropFramesX;
this.keepFramesX = keepFramesX;
this.stringTable = stringTable;
this.defaultSampleTypeX = defaultSampleTypeX;
}
public pipeDeadline(sync.Mutex mu = default, ref ptr <time.Timer> timer = default, channel <object> cancel = default)
{
this.mu = mu;
this.timer = timer;
this.cancel = cancel;
}
public testExporter(sync.Mutex mu = default, ref ptr <bytes.Buffer> buffer = default, event.Exporter logger = default)
public testPrinter(bool chatty = default, sync.Mutex lastNameMu = default, @string lastName = default)
{
this.chatty = chatty;
this.lastNameMu = lastNameMu;
this.lastName = lastName;
}
public pooledFlateWriter(sync.Mutex mu = default, ref ptr <flate.Writer> fw = default)
{
this.mu = mu;
this.fw = fw;
}
public netFD(ref ptr <bufferedPipe> r = default, ref ptr <bufferedPipe> w = default, channel <ptr <netFD> > incoming = default, sync.Mutex closedMu = default, bool closed = default, bool listener = default, long family = default, long sotype = default, @string net = default, Addr laddr = default, Addr raddr = default, poll.FD pfd = default, bool isConnected = default)
{
this.r = r;
this.w = w;
this.incoming = incoming;
this.closedMu = closedMu;
this.closed = closed;
this.listener = listener;
this.family = family;
this.sotype = sotype;
this.net = net;
this.laddr = laddr;
this.raddr = raddr;
this.pfd = pfd;
this.isConnected = isConnected;
}
