C# PhpValue.ToLong方法代码示例

        /// <summary>
        /// Performs bitwise negation.
        /// </summary>
        internal static PhpValue BitNot(ref PhpValue x)
        {
            switch (x.TypeCode)
            {
                case PhpTypeCode.Long: return PhpValue.Create(~x.Long);

                case PhpTypeCode.Int32: return PhpValue.Create(~x.ToLong());

                case PhpTypeCode.Alias: return BitNot(ref x.Alias.Value);

                case PhpTypeCode.String:
                case PhpTypeCode.WritableString:
                    throw new NotImplementedException();    // bitwise negation of each character in string

                case PhpTypeCode.Object:
                    if (x.Object == null)
                    {
                        return PhpValue.Null;
                    }
                    goto default;

                default:
                    // TODO: Err UnsupportedOperandTypes
                    return PhpValue.Null;
            }
        }

        /// <summary>
        /// Performs bitwise or operation.
        /// </summary>
        internal static PhpValue BitOr(ref PhpValue x, ref PhpValue y)
        {
            var xtype = x.TypeCode;
            if (xtype == PhpTypeCode.String || xtype == PhpTypeCode.WritableString)
            {
                var ytype = y.TypeCode;
                if (ytype == PhpTypeCode.String || ytype == PhpTypeCode.WritableString)
                {
                    throw new NotImplementedException();
                }
            }

            //
            return PhpValue.Create(x.ToLong() | y.ToLong());
        }

        int ProcessStatus(Context ctx, ref PhpValue status)
        {
            switch (status.TypeCode)
            {
                case PhpTypeCode.Alias:
                    return ProcessStatus(ctx, ref status.Alias.Value);

                case PhpTypeCode.Long:
                case PhpTypeCode.Int32:
                    return (int)status.ToLong();

                default:
                    if (ctx != null)
                    {
                        ctx.Echo(status);
                    }
                    return 0;
            }
        }

        public virtual bool SetParameter(StreamParameterOptions option, PhpValue value)
        {
            // Do not display error messages here, the caller will.
            // EX: will have to distinguish between failed and unsupported.
            // (use additional message when fails)

            // Descendants may call this default implementation for unhandled options
            switch (option)
            {
                case StreamParameterOptions.BlockingMode:
                    // Unimplemented in Win32 PHP.
                    return false;

                case StreamParameterOptions.ReadBufferSize:
                    // Unused option (only turns buffering off)
                    return false;

                case StreamParameterOptions.WriteBufferSize:
                    if (value.IsInteger())
                    {
                        // Let the write buffer reset on next write operation.
                        FlushWriteBuffer();
                        writeBuffer = null;
                        // Set the new size (0 to disable write buffering).
                        writeBufferSize = (int)value.ToLong();
                        if (writeBufferSize < 0) writeBufferSize = 0;
                        return true;
                    }
                    return false;

                case StreamParameterOptions.ReadTimeout:
                    // Set the read timeout for network-based streams (overrides DefaultTimeout).
                    this.readTimeout = (double)value;
                    return false;

                case StreamParameterOptions.SetChunkSize:
                    if (value.IsInteger())
                    {
                        // This setting will affect reading after the buffers are emptied.
                        readChunkSize = (int)value.ToLong();
                        if (readChunkSize < 1) readChunkSize = 1;
                        return true;
                    }
                    return false;

                case StreamParameterOptions.Locking:
                    return false;

                case StreamParameterOptions.MemoryMap:
                    return false;

                case StreamParameterOptions.Truncate:
                    // EX: [Truncate] Override SetParameter in NativeStream to truncate a local file.
                    return false;

                default:
                    Debug.Assert(false); // invalid option
                    return false;
            }
        }

        /// <summary>
        /// Sets variable's type.
        /// </summary>
        /// <param name="ctx">Current runtime context.</param>
        /// <param name="variable">The variable.</param>
        /// <param name="type">The string identifying a new type. See PHP manual for details.</param>
        /// <returns>Whether <paramref name="type"/> is valid type identifier.</returns>
        /// <exception cref="PhpException"><paramref name="type"/> has invalid value.</exception>
        public static bool settype(Context ctx, ref PhpValue variable, string type)
        {
            switch (type.ToLowerInvariant())
            {
                case "bool":
                case "boolean":
                    variable = PhpValue.Create(variable.ToBoolean());
                    return true;

                case "int":
                case "integer":
                    variable = PhpValue.Create(variable.ToLong());
                    return true;

                case "float":
                case "double":
                    variable = PhpValue.Create(variable.ToDouble());
                    return true;

                case "string":
                    variable = PhpValue.Create(variable.ToString(ctx));
                    return true;

                case "array":
                    variable = PhpValue.Create(variable.AsArray());
                    return true;

                case "object":
                    variable = PhpValue.FromClass(variable.ToClass());
                    return true;

                case "null":
                    variable = PhpValue.Null;
                    return true;
            }

            //PhpException.InvalidArgument("type", LibResources.GetString("invalid_type_name"));
            //return false;
            throw new ArgumentException(nameof(type));
        }

 /// <summary>
 /// Converts to integer using a specified base.
 /// </summary>
 /// <param name="variable">The variable.</param>
 /// <param name="base">The base.</param>
 /// <returns>The converted value.</returns>
 public static long intval(PhpValue variable, int @base)
 {
     // TODO: base
     // The integer value of var on success, or 0 on failure. Empty arrays and objects return 0, non-empty arrays and objects return 1. 
     // The maximum value depends on the system. 32 bit systems have a maximum signed integer range of -2147483648 to 2147483647. So for example on such a system, intval('1000000000000') will return 2147483647. The maximum signed integer value for 64 bit systems is 9223372036854775807. 
     return variable.ToLong();
 }