/*
 * FlagOps.cs --
 *
 * Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: $
 */

using System.Reflection;
using Eagle._Attributes;

#if NATIVE && TCL
using Eagle._Components.Private.Tcl;
#endif

using Eagle._Components.Public;

namespace Eagle._Components.Private
{
    [ObjectId("c3397500-b84c-4b5e-a0cf-ea4dd6042d6b")]
    internal static class FlagOps
    {
        public static bool HasFlags(
            AliasFlags flags,
            AliasFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != AliasFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ArgumentFlags flags,
            ArgumentFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ArgumentFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            Base26FormattingOption flags,
            Base26FormattingOption hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != Base26FormattingOption.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ByRefArgumentFlags flags,
            ByRefArgumentFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ByRefArgumentFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            BindingFlags flags,
            BindingFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != BindingFlags.Default);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            BreakpointType flags,
            BreakpointType hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != BreakpointType.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if LIST_CACHE || PARSE_CACHE || EXECUTE_CACHE || TYPE_CACHE || COM_TYPE_CACHE
        public static bool HasFlags(
            CacheFlags flags,
            CacheFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != CacheFlags.None);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            CallFrameFlags flags,
            CallFrameFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != CallFrameFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            CallbackFlags flags,
            CallbackFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != CallbackFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            CommandFlags flags,
            CommandFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != CommandFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ChannelType flags,
            ChannelType hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ChannelType.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            CreateFlags flags,
            CreateFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != CreateFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            EventFlags flags,
            EventFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != EventFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            FilePermission flags,
            FilePermission hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != FilePermission.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            FileSearchFlags flags,
            FileSearchFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != FileSearchFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if NATIVE && TCL
        public static bool HasFlags(
            FindFlags flags,
            FindFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != FindFlags.None);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            FunctionFlags flags,
            FunctionFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != FunctionFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            HeaderFlags flags,
            HeaderFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != HeaderFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if HISTORY
        public static bool HasFlags(
            HistoryFlags flags,
            HistoryFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != HistoryFlags.None);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            HostFlags flags,
            HostFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != HostFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            HostStreamFlags flags,
            HostStreamFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != HostStreamFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            HostTestFlags flags,
            HostTestFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != HostTestFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            InterpreterFlags flags,
            InterpreterFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != InterpreterFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            InterpreterType flags,
            InterpreterType hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != InterpreterType.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            LevelFlags flags,
            LevelFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != LevelFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            LookupFlags flags,
            LookupFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != LookupFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            MakeFlags flags,
            MakeFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != MakeFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            MapOpenAccess access,
            MapOpenAccess flags,
            bool all
            )
        {
            if (all)
                return ((access & flags) == flags);
            else
                return ((access & flags) != MapOpenAccess.Default);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            MarshalFlags flags,
            MarshalFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != MarshalFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            MatchMode flags,
            MatchMode hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != MatchMode.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            MemberTypes flags,
            MemberTypes hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != 0);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            MethodFlags flags,
            MethodFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != MethodFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if NATIVE && LIBRARY
        public static bool HasFlags(
            ModuleFlags flags,
            ModuleFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ModuleFlags.None);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            NamespaceFlags flags,
            NamespaceFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != NamespaceFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if NOTIFY || NOTIFY_OBJECT
        public static bool HasFlags(
            NotifyFlags flags,
            NotifyFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != NotifyFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            NotifyType flags,
            NotifyType hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != NotifyType.None);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ObjectFlags flags,
            ObjectFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ObjectFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ObjectOptionType flags,
            ObjectOptionType hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ObjectOptionType.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            OperatorFlags flags,
            OperatorFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != OperatorFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            OptionFlags flags,
            OptionFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != OptionFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            OptionBehaviorFlags flags,
            OptionBehaviorFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != OptionBehaviorFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            OptionOriginFlags flags,
            OptionOriginFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != OptionOriginFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            OutputStyle flags,
            OutputStyle hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != OutputStyle.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            PackageFlags flags,
            PackageFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != PackageFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            PackageIndexFlags flags,
            PackageIndexFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != PackageIndexFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            PluginFlags flags,
            PluginFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != PluginFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            PolicyFlags flags,
            PolicyFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != PolicyFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ProcedureFlags flags,
            ProcedureFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ProcedureFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            PromptFlags flags,
            PromptFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != PromptFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ReadyFlags flags,
            ReadyFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ReadyFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ResultFlags flags,
            ResultFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ResultFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ScriptFlags flags,
            ScriptFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ScriptFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ScriptBlockFlags flags,
            ScriptBlockFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ScriptBlockFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if NATIVE && TCL
        public static bool HasFlags(
            Tcl_VarFlags flags,
            Tcl_VarFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != Tcl_VarFlags.TCL_VAR_NONE);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ThreadFlags flags,
            ThreadFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ThreadFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            TokenFlags flags,
            TokenFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != TokenFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

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

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            TraceFlags flags,
            TraceFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != TraceFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

#if NATIVE && TCL
        public static bool HasFlags(
            UnloadFlags flags,
            UnloadFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != UnloadFlags.None);
        }
#endif

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            ValueFlags flags,
            ValueFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != ValueFlags.None);
        }

        ///////////////////////////////////////////////////////////////////////

        public static bool HasFlags(
            VariableFlags flags,
            VariableFlags hasFlags,
            bool all
            )
        {
            if (all)
                return ((flags & hasFlags) == hasFlags);
            else
                return ((flags & hasFlags) != VariableFlags.None);
        }
    }
}
