<version>1.0.0/1.1.0</version>
          <type>String</type>
          <description>
            Specify the execution strategy: {@code once-per-session}, {@code always}.
          </description>
          <defaultValue>once-per-session</defaultValue>
        </field>
        <field>
          <name>since</name>
          <version>1.0.0+</version>
          <type>String</type>

                                                </c:when>
                                                <c:when test="${info.key == 'User Session ID'}">
                                                    <td><la:link

	// Claim key-prefix for LDAP attributes
	ldapAttribPrefix = "ldapAttrib_"

	// Role Claim key
	roleArnClaim = "roleArn"

	// maximum supported STS session policy size
	maxSTSSessionPolicySize = 2048
)

type stsClaims map[string]interface{}

func (c stsClaims) populateSessionPolicy(form url.Values) error {
	if len(form) == 0 {
		return nil
	}

        this.b = b;
        this.off = off;
        this.count = len;
        this.digest = null; /*
                             * otherwise recycled commands
                             * like writeandx will choke if session
                             * closes in between
                             */
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.session;


import jcifs.CIFSContext;
import jcifs.internal.smb2.ServerMessageBlock2;
import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

@Experimental
public interface PathType {
    /**
     * The type for all paths that could not be placed in any of the types requested by a caller.
     * This type can appear in the return value of a call to
     * {@link Session#resolveDependencies resolveDependencies(...)} when at least one dependency
     * cannot be associated to any type specified in the {@code desiredTypes} argument.

    }

    private ModelResolver newModelResolver() throws ComponentLookupException, MalformedURLException {
        return new DefaultModelResolver(
                this.session,
                null,
                this.getClass().getName(),
                getContainer().lookup(ArtifactResolver.class),
                getContainer().lookup(VersionRangeResolver.class),

        /* Downgrade one transport to the lower of the negotiated buffer sizes
         * so we can just send whatever is received.
         */

        SmbTransport t1 = tree.session.transport;
        SmbTransport t2 = dest.tree.session.transport;

        if( t1.snd_buf_size < t2.snd_buf_size ) {
            t2.snd_buf_size = t1.snd_buf_size;
        } else {
            t1.snd_buf_size = t2.snd_buf_size;

                .replace(CACHE_AND_SESSION_INVALIDATE_STATEMENT, "<% }catch(Exception e){session.invalidate();} %>");
    }

    public static String encodeJsp(final String value) {
        return value.replace("<% try{ %>", TRY_STATEMENT).replace("<% }catch(Exception e){session.invalidate();} %>",
                CACHE_AND_SESSION_INVALIDATE_STATEMENT);
    }

    /** The Plexus component type */
    public static final String MAVEN_PLUGIN = "maven-plugin";

    /** "once-per-session" execution strategy */
    public static final String SINGLE_PASS_EXEC_STRATEGY = "once-per-session";

    /** "always" execution strategy */
    public static final String MULTI_PASS_EXEC_STRATEGY = "always";