{\r
private Hashtable table;\r
\r
- protected XmlSchemaObjectTable()\r
+ internal XmlSchemaObjectTable()\r
{\r
table = new Hashtable(); \r
}\r
{\r
#region Constructor\r
\r
- internal XmlDocumentFragment (XmlDocument doc)\r
+ protected internal XmlDocumentFragment (XmlDocument doc)\r
: base (doc)\r
{\r
}\r
#endregion
#region Constructors
- protected internal XmlLinkedNode(XmlDocument doc) : base(doc) { }
+ internal XmlLinkedNode(XmlDocument doc) : base(doc) { }
#endregion
#region Constructors
- protected internal XmlNode (XmlDocument ownerDocument)
+ internal XmlNode (XmlDocument ownerDocument)
{
this.ownerDocument = ownerDocument;
}
{
#region Constructors
- protected internal XmlNodeList() { }
+ protected XmlNodeList() { }
#endregion
protected bool openStartElement = false;
protected bool openStartAttribute = false;
protected bool documentStarted = false;
- protected bool namespaces = true;
+ private bool namespaces = true;
protected bool openAttribute = false;
protected bool attributeWrittenForElement = false;
protected Stack openElements = new Stack ();
- protected Formatting formatting = Formatting.None;
- protected int indentation = 2;
- protected char indentChar = ' ';
+ private Formatting formatting = Formatting.None;
+ private int indentation = 2;
+ private char indentChar = ' ';
protected string indentChars = " ";
- protected char quoteChar = '\"';
+ private char quoteChar = '\"';
protected int indentLevel = 0;
protected string indentFormatting;
protected Stream baseStream = null;
// Properties
//
- string DelegateType {
+ public string DelegateType {
get {
return delegateType;
}
bool disposed = false;
- public virtual void Dispose (bool release_all)
+ protected virtual void Dispose (bool release_all)
{
if (disposed)
return;
DesignerSerializationVisibility.Visible);
}
- DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility vis)
+ public DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility vis)
{
visibility = vis;
}
public abstract class PropertyDescriptor : MemberDescriptor {
- public PropertyDescriptor (MemberDescriptor reference)
+ protected PropertyDescriptor (MemberDescriptor reference)
: base (reference)
{
}
- public PropertyDescriptor (MemberDescriptor reference, Attribute [] attrs)
+ protected PropertyDescriptor (MemberDescriptor reference, Attribute [] attrs)
: base (reference, attrs)
{
}
- public PropertyDescriptor (string name, Attribute [] attrs)
+ protected PropertyDescriptor (string name, Attribute [] attrs)
: base (name, attrs)
{
}
/// <summary>
/// ConfigurationSettings Constructor.
/// </summary>
- public ConfigurationSettings ()
+ private ConfigurationSettings ()
{
}
/// </summary>
public sealed class Debug {
+ private Debug () {}
+
/// <summary>
/// Gets or sets value indicating whether Flush should
/// be called on the listeners.
/// </summary>
public sealed class Trace {
+ private Trace () {}
+
/// <summary>
/// Gets or sets value indicating whether Flush should
/// be called on the listeners.
private ArrayList listeners = new ArrayList ();
- public TraceListenerCollection ()
+ internal TraceListenerCollection ()
{
Add (new DefaultTraceListener ());
}
{
// Don't change the names of these fields without also
// changing socket-io.c in the runtime
- protected bool enabled;
+ private bool enabled;
protected int seconds;
public LingerOption (bool enable, int secs)
{
// Don't change the names of these fields without also
// changing socket-io.c in the runtime
- protected IPAddress group;
+ private IPAddress group;
protected IPAddress local;
public MulticastOption (IPAddress grp)
Dispose (true);
}
- public virtual void Dispose (bool disposing)
+ protected virtual void Dispose (bool disposing)
{
if (owns_socket)
if (socket != null)
namespace System.Net {
public sealed class Dns {
+
+ private Dns () {}
/// <summary>
/// Helper class
return factory.NewInstance ();\r
}\r
\r
- private string pattern;\r
+ protected internal string pattern;\r
private RegexOptions options;\r
\r
private IMachineFactory factory;\r
\r
Stack stack;\r
\r
- public SyncStack(Stack s) {\r
+ internal SyncStack(Stack s) {\r
stack = s;\r
}\r
\r
{\r
}\r
\r
- protected abstract void Remove ();\r
+ public abstract void Remove ();\r
}\r
}\r
{\r
public sealed class Directory : Object\r
{\r
+ private Directory () {}
+
public static DirectoryInfo CreateDirectory (string path)\r
{\r
if (path == null)\r
/// </summary>\r
public sealed class File : Object\r
{\r
+ private File () {}
+
public static StreamWriter AppendText (string path)\r
{ \r
return new StreamWriter (path, true);\r
{
}
- public IOException (SerializationInfo info, StreamingContext context)
+ protected IOException (SerializationInfo info, StreamingContext context)
: base (info, context)
{
}
private static readonly char[] PathSeparatorChars;
+ private Path () {}
+
// class methods
public static string ChangeExtension (string path, string extension)
{
System.Security.IEvidenceFactory, System.Runtime.Serialization.ISerializable {
private IntPtr _mono_assembly;
+ internal Assembly () {}
+
[MethodImplAttribute (MethodImplOptions.InternalCall)]
private extern string get_code_base ();
name = null;
}
- public AssemblyName (SerializationInfo si, StreamingContext sc)
+ internal AssemblyName (SerializationInfo si, StreamingContext sc)
{
name = si.GetString ("_Name");
codebase = si.GetString ("_CodeBase");
{
}
- public CustomAttributeFormatException (SerializationInfo info,
+ protected CustomAttributeFormatException (SerializationInfo info,
StreamingContext context)
{
}
{
}
- public InvalidFilterCriteriaException (SerializationInfo info,
+ protected InvalidFilterCriteriaException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
public sealed class Missing
{
public static readonly Missing Value;
+
+ internal Missing () {}
}
}
internal string name;
internal string scopename;
+ internal Module () {}
+
public Assembly Assembly {get {return assembly;}}
public virtual string FullyQualifiedName {get {return fqname;}}
public string Name {get {return name;}}
{
}
- public TargetException (SerializationInfo info, StreamingContext context)
+ protected TargetException (SerializationInfo info, StreamingContext context)
: base (info, context)
{
}
{
public class TargetInvocationException : ApplicationException
{
+ private TargetInvocationException () {}
}
}
{
}
- public TargetParameterCountException (SerializationInfo info,
+ internal TargetParameterCountException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
{
}
- public MissingManifestResourceException (SerializationInfo info, StreamingContext context)
+ protected MissingManifestResourceException (SerializationInfo info, StreamingContext context)
:base (info, context)
{
}
private Type resourceSetType;
// constructors
- public ResourceManager () {}
+ protected ResourceManager () {}
public ResourceManager (Type resourceSource)
{
protected int index = -1;
- public ResourceEnumerator(ResourceReader readerToEnumerate){
+ internal ResourceEnumerator(ResourceReader readerToEnumerate){
reader = readerToEnumerate;
}
// Constructors
protected ResourceSet () {}
- protected ResourceSet (IResourceReader reader)
+ public ResourceSet (IResourceReader reader)
{
if (reader == null)
throw new ArgumentNullException ("The reader is null.");
Reader = reader;
}
- protected ResourceSet (Stream stream)
+ public ResourceSet (Stream stream)
{
Reader = new ResourceReader (stream);
}
- protected ResourceSet (String fileName)
+ public ResourceSet (String fileName)
{
Reader = new ResourceReader (fileName);
}
Dispose (true);
}
- public void Dispose (bool disposing)
+ protected void Dispose (bool disposing)
{
if (disposing) {
Reader = null;
return null;
}
- public virtual void ReadResources ()
+ protected virtual void ReadResources ()
{
IDictionaryEnumerator i = Reader.GetEnumerator();
{
public sealed class RuntimeHelpers
{
+ private RuntimeHelpers () {}
+
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern void InitializeArray (Array array, RuntimeFieldHandle fldHandle);
{
class Marshal
{
+ private Marshal () {}
+
[MethodImplAttribute(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]
public static extern string PtrToStringAuto (IntPtr ptr);
\r
[MonoTODO]\r
public class LogicalCallContext : ISerializable, ICloneable {\r
+
+ internal LogicalCallContext () {}
+
public bool HasInfo {\r
get { return false; }\r
}\r
Type class_to_proxy;
- RealProxy () {
+ protected RealProxy () {
throw new NotImplementedException ();
}
- RealProxy (Type classToProxy) {
+ protected RealProxy (Type classToProxy) {
this.class_to_proxy = classToProxy;
}
- RealProxy (Type classToProxy, IntPtr stub, object stubData) {
+ protected RealProxy (Type classToProxy, IntPtr stub, object stubData) {
throw new NotImplementedException ();
}
}
[MonoTODO]
- public ObjRef (SerializationInfo si, StreamingContext sc)
+ protected ObjRef (SerializationInfo si, StreamingContext sc)
{
// FIXME: Implement.
//
{
public sealed class RemotingServices {
+ private RemotingServices () {}
+
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern static object InternalExecute (MonoMethod method, Object obj,
Object[] parameters, out object [] out_args);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal extern static bool IsTransparentProxy (object proxy);
+ public extern static bool IsTransparentProxy (object proxy);
public static IMethodReturnMessage ExecuteMessage (
MarshalByRefObject target, IMethodCallMessage reqMsg)
/// </summary>\r
public abstract class DSA : AsymmetricAlgorithm\r
{\r
+ internal DSA () {}
\r
public static new DSA Create()\r
{\r
/// <summary>\r
/// Called from constructor of derived class.\r
/// </summary>\r
- protected SHA256 () {\r
+ public SHA256 () {\r
\r
}\r
\r
/// <summary>\r
/// Called from constructor of derived class.\r
/// </summary>\r
- protected SHA384 () {\r
+ public SHA384 () {\r
\r
}\r
\r
/// <summary>\r
/// Called from constructor of derived class.\r
/// </summary>\r
- protected SHA512 () {\r
+ public SHA512 () {\r
\r
}\r
\r
namespace System.Security.Cryptography.X509Certificates {
public class X509Certificate {
+ internal X509Certificate () {}
}
}
]\r
public abstract class CodeAccessSecurityAttribute : SecurityAttribute {\r
\r
- protected CodeAccessSecurityAttribute(SecurityAction action) : base(action) {}\r
+ public CodeAccessSecurityAttribute(SecurityAction action) : base(action) {}\r
\r
} // public abstract class CodeAccessSecurityAttribute\r
-} // namespace System.Security.Permissions
\ No newline at end of file
+} // namespace System.Security.Permissions
+
public RegistryPermissionAttribute (SecurityAction action) : base (action) {}
// Properties
- string All
+ public string All
{
set { all = value; }
}
[Serializable]
public sealed class PolicyLevel
{
+ internal PolicyLevel () {}
+
public IList FullTrustAssemblies
{
get
public sealed class SecurityManager {\r
private static bool checkExecutionRights;\r
private static bool securityEnabled;\r
+
+ private SecurityManager () {}
\r
public static bool CheckExecutionRights {\r
get{\r
public static void SavePolicyLevel(PolicyLevel level){}\r
\r
}\r
-}
\ No newline at end of file
+}
{
public sealed class Interlocked
{
+ private Interlocked () {}
+
public static int CompareExchange(ref int location1, int value, int comparand) {
// lock
if(comparand==location1) {
{
public sealed class Monitor
{
+ private Monitor () {}
+
// Grabs the mutex on object 'obj', with a maximum
// wait time 'ms' but doesn't block - if it can't get
// the lock it returns false, true if it can
{
public sealed class RegisteredWaitHandle
{
+ internal RegisteredWaitHandle () {}
+
[MonoTODO]
public bool Unregister(WaitHandle waitObject) {
// FIXME
{
public sealed class ThreadAbortException : SystemException
{
+ private ThreadAbortException () {}
+
[MonoTODO]
public object ExceptionState {
get {
{
public sealed class ThreadPool
{
+ private ThreadPool () {}
+
[MonoTODO]
public static bool BindHandle(IntPtr osHandle) {
// FIXME
{
public sealed class Timeout
{
+ private Timeout () {}
public const int Infinite=-1;
}
}
IntPtr _mono_app_domain;
// Evidence evidence;
+
+ private AppDomain () {}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern AppDomainSetup getSetup ();
this.actual_value = actual_value;
}
- public ArgumentOutOfRangeException (SerializationInfo info, StreamingContext context)
+ protected ArgumentOutOfRangeException (SerializationInfo info, StreamingContext context)
: base (info, context)
{
actual_value = info.GetString ("ActualValue");
namespace System {
public class BitConverter {
+ private BitConverter () {}
+
static bool AmILittleEndian()
{
byte[] one = GetBytes((int)1);
namespace System {
public sealed class Buffer {
+
+ private Buffer () {}
+
public static int ByteLength (Array array) {
// note: the other methods in this class also use ByteLength to test for
// null and non-primitive arguments as a side-effect.
stdout = new StreamWriter (OpenStandardOutput ());
stdin = new StreamReader (OpenStandardInput ());
}
+
+ private Console () {}
public static TextWriter Error
{
// Fields\r
public static readonly object DBNull;\r
\r
+ private Convert () {}
+
// ========== BASE 64 Conversions ========== //\r
// the BASE64 convert methods are using the Base64 converting methods\r
// from System.Security.Cryptography.ToBase64Transform and\r
{
}
- public DllNotFoundException (SerializationInfo info,
+ protected DllNotFoundException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
{\r
public sealed class Environment\r
{\r
+ private Environment () {}
+
[MonoTODO]\r
public enum SpecialFolder\r
{ // TODO: Determine if these windoze style folder identifiers \r
{
}
- public FieldAccessException (SerializationInfo info,
+ protected FieldAccessException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
{
}
- public FormatException (SerializationInfo info,
+ protected FormatException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
namespace System {
public sealed class GC {
+
+ private GC () {}
[MonoTODO]
public static void SuppressFinalize (object obj)
{
public const double E = 2.7182818284590452354;
public const double PI = 3.14159265358979323846;
+
+ private Math () {}
+
public static decimal Abs(decimal value)
{
return (value < 0)? -value: value;
{
}
- public MethodAccessException (SerializationInfo info,
+ protected MethodAccessException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
{
}
- public PlatformNotSupportedException (SerializationInfo info,
+ protected PlatformNotSupportedException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
{
}
- protected StackOverflowException (SerializationInfo info, StreamingContext context)
+ internal StackOverflowException (SerializationInfo info, StreamingContext context)
: base (info, context)
{
}
msg = message;
}
- public TypeLoadException (SerializationInfo info,
+ protected TypeLoadException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
{
}
- public TypeUnloadedException (SerializationInfo info,
+ protected TypeUnloadedException (SerializationInfo info,
StreamingContext context)
: base (info, context)
{
projects / mono.git / commitdiff