*/
    public SmbSessionImpl getSession () {
        return this.session.acquire();
    }


    /**
     * @return the tid
     */
    public int getTid () {
        return this.tid;
    }


    /**
     * @return the tree_num (monotonically increasing counter to track reconnects)
     */
    public long getTreeNum () {
        return this.treeNum;

            return null;
        }

    }


    /**
     * 
     * {@inheritDoc}
     *
     * @see jcifs.DfsResolver#getDc(jcifs.CIFSContext, java.lang.String)
     */
    @Override
    public SmbTransport getDc ( CIFSContext tf, String domain ) throws SmbAuthException {
        if ( tf.getConfig().isDfsDisabled() )
            return null;

		if version.header.VersionID != uv || version.header.Type != ObjectType {
			continue
		}
		// if uv has tiered content we add a
		// free-version to track it for asynchronous
		// deletion via scanner.
		ver, err := x.getIdx(i)
		if err != nil {
			return err
		}

		if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
			return x.addVersion(freeVersion)
		}
		return nil
	}
	return nil

        }
        return "Invalid";
    }


    @Override
    public int getAccessMask () {
        return this.access;
    }


    @Override
    public SID getSID () {
        return this.sid;
    }


    @Override
    public int decode ( byte[] buf, int bi, int len ) {
        this.allow = buf[ bi++ ] == (byte) 0x00;
        this.flags = buf[ bi++ ] & 0xFF;

	for i, ver := range x.versions {
		if key == ver.header.VersionID {
			obj, err := x.getIdx(i)
			return i, obj, err
		}
	}
	return -1, nil, errFileVersionNotFound
}

func (x *xlMetaV2) getIdx(idx int) (ver *xlMetaV2Version, err error) {
	if idx < 0 || idx >= len(x.versions) {
		return nil, errFileNotFound
	}
	var dst xlMetaV2Version

    }


    /**
     * Get the RID
     * 
     * This is the last subauthority identifier
     * 
     * @return the RID
     */
    @Override
    public int getRid () {
        if ( getType() == SID_TYPE_DOMAIN )
            throw new IllegalArgumentException("This SID is a domain sid");
        return this.sub_authority[ this.sub_authority_count - 1 ];
    }

    /**
     * @return the oplockLevel
     */
    public final byte getOplockLevel () {
        return this.oplockLevel;
    }


    /**
     * @return the fid
     */
    public final int getFid () {
        return this.fid;
    }


    /**
     * @return the createAction
     */
    public final int getCreateAction () {
        return this.createAction;
    }


    /**

                return resp.getOutputLength();
            }
            else if ( this.transact ) {
                TransTransactNamedPipe req = new TransTransactNamedPipe(th.getConfig(), fh.getFid(), buf, off, length);
                TransTransactNamedPipeResponse resp = new TransTransactNamedPipeResponse(th.getConfig(), inB);

    /**
     * 
     */
    public static final int FLAGS_INHERITED = 0x10;


    /**
     * Return the SID associated with this ACE.
     * 
     * @return ACE target SID
     */
    SID getSID ();


    /**
     * Returns the access mask associated with this ACE. Use the
     * constants for <tt>FILE_READ_DATA</tt>, <tt>FILE_WRITE_DATA</tt>,

        }
        else {
            this.creationBacktrace = null;
        }
    }


    /**
     * @return the fid
     * @throws SmbException
     */
    public int getFid () throws SmbException {
        if ( !isValid() ) {
            throw new SmbException("Descriptor is no longer valid");
        }
        return this.fid;
    }