Exemple #1
0
        ///////////////////////////////////////////////////////////////////////

        public virtual string ToString(
            ToStringFlags flags,
            string @default /* NOT USED */
            )
        {
            return(ToString());
        }
Exemple #2
0
 public string ToString(
     ToStringFlags flags,
     string @default /* NOT USED */
     )
 {
     return(ToString("{0}"));
 }
Exemple #3
0
        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ToStringFlags flags,
            ToStringFlags hasFlags,
            bool all
            )
        {
            if (all)
            {
                return((flags & hasFlags) == hasFlags);
            }
            else
            {
                return((flags & hasFlags) != ToStringFlags.None);
            }
        }
Exemple #4
0
        ///////////////////////////////////////////////////////////////////////

        public string ToRawString(
            ToStringFlags toStringFlags,
            string separator
            )
        {
            StringBuilder result = StringOps.NewStringBuilder();

            foreach (Result element in this)
            {
                if (element != null)
                {
                    if ((separator != null) && (result.Length > 0))
                    {
                        result.Append(separator);
                    }

                    result.Append(element.ToString(toStringFlags));
                }
            }

            return(result.ToString());
        }
Exemple #5
0
        ///////////////////////////////////////////////////////////////////////

        public string ToString(
            ToStringFlags toStringFlags,
            string pattern,
            bool noCase
            )
        {
#if CACHE_ARGUMENTLIST_TOSTRING
            bool canUseCachedString = CanUseCachedString(
                toStringFlags, DefaultSeparator, pattern, noCase);

            if (canUseCachedString && (@string != null))
            {
#if CACHE_STATISTICS
                Interlocked.Increment(
                    ref cacheCounts[(int)CacheCountType.Hit]);
#endif

                return(@string);
            }

#if CACHE_STATISTICS
            Interlocked.Increment(
                ref cacheCounts[(int)CacheCountType.Miss]);
#endif
#endif

            string result = GenericOps <Argument> .ListToString(
                this, Index.Invalid, Index.Invalid, toStringFlags,
                DefaultSeparator, pattern, noCase);

#if CACHE_ARGUMENTLIST_TOSTRING
            if (canUseCachedString)
            {
                @string = result;
            }
#endif

            return(result);
        }
Exemple #6
0
        ///////////////////////////////////////////////////////////////////////

        private static bool CanUseCachedString(
            ToStringFlags toStringFlags,
            string separator,
            string pattern,
            bool noCase
            )
        {
            if (toStringFlags != ToStringFlags.None)
            {
                return(false);
            }

            if (!Parser.IsListSeparator(separator))
            {
                return(false);
            }

            if (pattern != null)
            {
                return(false);
            }

            return(true);
        }
Exemple #7
0
        ///////////////////////////////////////////////////////////////////////

        #region IToString Members
        public virtual string ToString(
            ToStringFlags flags
            )
        {
            return(ToString(flags, null));
        }
Exemple #8
0
        public void ToString(StringBuilder sb, ToStringFlags flags)
        {
            sb.Append('{');
            if (Has(flags, ToStringFlags.Id))
            {
                sb.Append(Type).Append("#").Append(Id).Append(' ');
            }
            sb.Append('\'').Append(InAdapter?.Name).Append('\'');
            var outAdapter = ConnectResult?.Adapter ?? RunningHandler;

            if (outAdapter != null && Has(flags, ToStringFlags.OutAdapter))
            {
                sb.Append("->'").Append(outAdapter.Name).Append('\'');
            }
            if (Has(flags, ToStringFlags.Time))
            {
                sb.Append(" T=").AppendFormat((WebSocket.CurrentTime - CreateTime).ToString("N0"));
            }
            if (Has(flags, ToStringFlags.Bytes) && BytesCountersRW.TotalValue.Packets > 0)
            {
                sb.Append(' ').Append(BytesCountersRW.ToString());
            }
            var addition = (Has(flags, ToStringFlags.AdditionFields)) ? GetInfoStr() : null;

            if (addition != null)
            {
                sb.Append(' ').Append(addition);
            }
            sb.Append(" dest=").Append(Dest.Host);
            if (DestOriginalName != null)
            {
                sb.Append('(').Append(DestOriginalName).Append(')');
            }
            sb.Append(':').Append(Dest.Port);
            if (ConnectResult != null)
            {
                if (ConnectResult.Result == ConnectResultEnum.OK)
                {
                    if (ConnectResult is ConnectResult tcp && Has(flags, ToStringFlags.OutStream) && tcp.Stream != null)
                    {
                        sb.Append(" ->").Append(tcp.Stream);
                    }
                }
                else if (ConnectResult.Result == ConnectResultEnum.Failed)
                {
                    sb.Append(" (FAIL)");
                }
                else if (ConnectResult.IsRedirected)
                {
                    sb.Append(" (REDIR->'").Append(ConnectResult.Redirected.Adapter?.Name).Append("')");
                }
            }
            else
            {
                sb.Append(" (...)");
            }
            if (IsStoppingRequested)
            {
                sb.Append(" (STOPPING)");
            }
            if (IsFinished)
            {
                sb.Append(" (END)");
            }
            sb.Append('}');
        }
Exemple #9
0
 private static bool Has(ToStringFlags flag, ToStringFlags has) => (flag & has) != 0;
Exemple #10
0
        ///////////////////////////////////////////////////////////////////////

        public string ToString(
            ToStringFlags toStringFlags
            )
        {
            return(ToString(toStringFlags, null, false));
        }