internal static int AccessMaskFromPropertyAccess(PropertyAccess access)
        {
            if ((access < PropertyAccess.Read) || (access > PropertyAccess.Write))
            {
                throw new InvalidEnumArgumentException("access", (int) access, typeof(PropertyAccess));
            }
            switch (access)
            {
                case PropertyAccess.Read:
                    return ActiveDirectoryRightsTranslator.AccessMaskFromRights(ActiveDirectoryRights.ReadProperty);

                case PropertyAccess.Write:
                    return ActiveDirectoryRightsTranslator.AccessMaskFromRights(ActiveDirectoryRights.WriteProperty);
            }
            throw new ArgumentException("access");
        }

        public IElement FromPropertyDefinition(string name, string type, PropertyAccess access)
        {
            string spec = Concat (access.ToString().ToLowerInvariant(),
                                  " property ", name, " : ", type);
            Dictionary<string, LangProcesser> temp = new Dictionary<string,LangProcesser>();

            foreach (KeyValuePair<ILangDefinition, IParserVisitor<string>> visitor in visitors) {
                temp.Add(visitor.Key.Name, delegate {
                    string realType = Parser.ParseDBusTypeExpression(type, visitor.Value);
                    return visitor.Key.PropertyFormat(name, realType, access);
                });
            }

            Element elem = new Element (name, new ElementRepresentation (spec, temp), propertyPb, 3);
            elem.Data = new InvocationData (type, Enumerable.Empty<Argument> (), true);
            elem.Data.PropertyAcces = access;

            return elem;
        }

        public static string GetName(string name, PropertyAccess access, FieldCase fieldCase)
        {
            switch (access)
            {
                case PropertyAccess.Property:
                    switch (fieldCase)
                    {
                        case FieldCase.Unchanged:
                            return name;
                        case FieldCase.Camelcase:
                            return MakeCamel(name);
                        case FieldCase.CamelcaseUnderscore:
                            return "_" + MakeCamel(name);
                        case FieldCase.CamelcaseMUnderscore:
                            return "m_" + MakeCamel(name);
                        case FieldCase.Pascalcase:
                            return MakePascal(name);
                        case FieldCase.PascalcaseUnderscore:
                            return "_" + MakePascal(name);
                        case FieldCase.PascalcaseMUnderscore:
                            return "m_" + MakePascal(name);
                    }
                    break;
                case PropertyAccess.Field:
                    return name;
                case PropertyAccess.FieldCamelcase:
                case PropertyAccess.NosetterCamelcase:
                    return MakeCamel(name);
                case PropertyAccess.FieldCamelcaseUnderscore:
                case PropertyAccess.NosetterCamelcaseUnderscore:
                    return "_" + MakeCamel(name);
                case PropertyAccess.FieldPascalcaseMUnderscore:
                case PropertyAccess.NosetterPascalcaseMUnderscore:
                    return "m_" + MakePascal(name);
                case PropertyAccess.FieldLowercaseUnderscore:
                case PropertyAccess.NosetterLowercaseUnderscore:
                    return "_" + name.ToLowerInvariant();
                case PropertyAccess.NosetterLowercase:
                    return name.ToLowerInvariant();
            }

            return name;
        }

		public static PropertyInfo[] GetPropertyInfoChain(
			Mobile m, Type type, string propertyString, PropertyAccess endAccess, ref string failReason)
		{
			var split = propertyString.Split('.');

			if (split.Length == 0)
			{
				return null;
			}

			var info = new PropertyInfo[split.Length];

			for (int i = 0; i < info.Length; ++i)
			{
				string propertyName = split[i];

				if (CIEqual(propertyName, "current"))
				{
					continue;
				}

				var props = type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);

				bool isFinal = i == info.Length - 1;

				PropertyAccess access = endAccess;

				if (!isFinal)
				{
					access |= PropertyAccess.Read;
				}

				foreach (PropertyInfo p in props)
				{
					if (!CIEqual(p.Name, propertyName))
					{
						continue;
					}

					CPA attr = GetCPA(p);

					if (attr == null)
					{
						failReason = String.Format("Property '{0}' not found.", propertyName);
						return null;
					}

					if ((access & PropertyAccess.Read) != 0 && m.AccessLevel < attr.ReadLevel)
					{
						failReason = String.Format(
							"You must be at least {0} to get the property '{1}'.", Mobile.GetAccessLevelName(attr.ReadLevel), propertyName);

						return null;
					}

					if ((access & PropertyAccess.Write) != 0 && m.AccessLevel < attr.WriteLevel)
					{
						failReason = String.Format(
							"You must be at least {0} to set the property '{1}'.", Mobile.GetAccessLevelName(attr.WriteLevel), propertyName);

						return null;
					}

					if ((access & PropertyAccess.Read) != 0 && !p.CanRead)
					{
						failReason = String.Format("Property '{0}' is write only.", propertyName);
						return null;
					}

					if ((access & PropertyAccess.Write) != 0 && (!p.CanWrite || attr.ReadOnly) && isFinal)
					{
						failReason = String.Format("Property '{0}' is read only.", propertyName);
						return null;
					}

					info[i] = p;
					type = p.PropertyType;
					break;
				}

				if (info[i] != null)
				{
					continue;
				}

				failReason = String.Format("Property '{0}' not found.", propertyName);
				return null;
			}

			return info;
		}

		public PropertySetAccessRule (IdentityReference identity, AccessControlType type, PropertyAccess access, Guid propertySetType, ActiveDirectorySecurityInheritance inheritanceType, Guid inheritedObjectType) : base(identity, (int)AccessControlType.Allow, type, propertySetType, false, InheritanceFlags.None, PropagationFlags.None, inheritedObjectType)
		{
		}

        private CodeMemberField GetGenericMemberField(string typeName, string name, string fieldType, Accessor accessor, PropertyAccess access)
        {
            CodeMemberField memberField = GetMemberFieldWithoutType(name, accessor, access);

            CodeTypeReference type = new CodeTypeReference(fieldType);
            if (!TypeHelper.ContainsGenericDecleration(fieldType, _language))
            {
                type.TypeArguments.Add(typeName);
            }
            memberField.Type = type;

            return memberField;
        }

        private void AddInternalWatchedListProperty(CodeTypeDeclaration typeDeclaration, CodeTypeReference propertyTypeReference, string propertyName, string fieldName, bool implementPropertyChanged, bool implementPropertyChanging, PropertyAccess propertyAccess)
        {
            CodeMemberProperty property = new CodeMemberProperty();
            property.Name = propertyName + "Internal";
            property.Type = propertyTypeReference;

            var list = new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, fieldName), "List");

            property.GetStatements.Add(new CodeMethodReturnStatement(list));

            // If the user specifies that they access the data through the property, then we
            // would want the change events to fire as if the property was being set.  If the
            // field is being accessed directly, we want to avoid the change events.

            if (implementPropertyChanging && propertyAccess == PropertyAccess.Property)
                property.SetStatements.Add(new CodeMethodInvokeExpression(null, Context.Model.PropertyChangingMethodName, new CodePrimitiveExpression(propertyName)));

            property.SetStatements.Add(new CodeAssignStatement(list, new CodeArgumentReferenceExpression("value")));

            if (implementPropertyChanged && propertyAccess == PropertyAccess.Property)
                property.SetStatements.Add(new CodeMethodInvokeExpression(null, Context.Model.PropertyChangedMethodName, new CodePrimitiveExpression(propertyName)));

            typeDeclaration.Members.Add(property);
        }

		public static Property Parse( Type type, string binding, PropertyAccess access )
		{
			Property prop = new Property( binding );

			prop.BindTo( type, access );

			return prop;
		}

 private CodeMemberField GetPrivateMemberFieldOfCompositeClass(CodeTypeDeclaration compositeClass, PropertyAccess access)
 {
     return GetMemberField(compositeClass.Name, compositeClass.Name, Accessor.Private, access);
 }

		/// <summary>
		/// Convert <param name="access"/> to its NHibernate string 
		/// </summary>
		public static string ToString(PropertyAccess access)
		{
			switch (access)
			{
				case PropertyAccess.Property:
					return "property";
				case PropertyAccess.Field:
					return "field";
				case PropertyAccess.AutomaticProperty:
					return "backfield";
				case PropertyAccess.ReadOnly:
					return "readonly";
				case PropertyAccess.FieldCamelcase:
					return "field.camelcase";
				case PropertyAccess.FieldCamelcaseUnderscore:
					return "field.camelcase-underscore";
				case PropertyAccess.FieldPascalcaseMUnderscore:
					return "field.pascalcase-m-underscore";
				case PropertyAccess.FieldLowercaseUnderscore:
					return "field.lowercase-underscore";
				case PropertyAccess.NosetterCamelcase:
					return "nosetter.camelcase";
				case PropertyAccess.NosetterCamelcaseUnderscore:
					return "nosetter.camelcase-underscore";
				case PropertyAccess.NosetterPascalcaseMUndersc:
					return "nosetter.pascalcase-m-underscore";
				case PropertyAccess.NosetterPascalcaseUnderscore:
					return "nosetter.pascalcase-underscore";
				case PropertyAccess.NosetterLowercaseUnderscore:
					return "nosetter.lowercase-underscore";
				case PropertyAccess.NosetterLowercase:
					return "nosetter.lowercase";
				default:
					throw new InvalidOperationException("Invalid value for PropertyAccess");
			}
		}

		public static PropertyInfo GetPropertyInfo( Mobile from, ref object obj, string propertyName, PropertyAccess access, ref string failReason )
		{
			PropertyInfo[] chain = GetPropertyInfoChain( from, obj.GetType(), propertyName, access, ref failReason );

			if ( chain == null )
				return null;

			return GetPropertyInfo( ref obj, chain, ref failReason );
		}

 public PropertyAccessRule(IdentityReference identity, AccessControlType type, PropertyAccess access, Guid propertyType, ActiveDirectorySecurityInheritance inheritanceType, Guid inheritedObjectType) : base(identity, PropertyAccessTranslator.AccessMaskFromPropertyAccess(access), type, propertyType, false, ActiveDirectoryInheritanceTranslator.GetInheritanceFlags(inheritanceType), ActiveDirectoryInheritanceTranslator.GetPropagationFlags(inheritanceType), inheritedObjectType)
 {
 }

            public dynamic GetValueFromScope(string propertyName, string format = null)
            {
                try
                {
                    var keys = propertyName.Split('.');
                    var digTo = keys.Count(x => x == "$parent");
                    var d = 0;
                    var p = this;

                    while (digTo > 0 && digTo + 1 > d)
                    {
                        p = p.Parent;
                        d += p.Scope != null ? 1 : 0;
                    }
                    if (digTo > 0) keys = keys.Where(x => x != "$parent").ToArray();

                    var property = new PropertyAccess(keys[0]);
                    var scope = p.Scope;
                    var parent = this;
                    while (scope == null || !scope.ContainsKey(property.Name))
                    {
                        parent = parent.Parent;
                        scope = parent.Scope;
                    }

                    var obj = scope[property.Name];
                    var level = 1;

                    while (level < keys.Length)
                    {
                        obj = property.GetValue(obj);
                        property = new PropertyAccess(keys[level]);
                        var t = obj.GetType();
                        obj = t == typeof(Dictionary<string, dynamic>) || t.IsArray
                            ? obj[property.Name]
                            : t.GetProperty(property.Name).GetValue(obj, null);
                        level++;
                    }

                    if (string.IsNullOrWhiteSpace(format))
                        return property.GetValue(obj);
                    return property.GetValue(obj).ToString(format);
                }
                catch (Exception)
                {
                    Trace.WriteLine(propertyName + " not found. default value returned = false");
                    return false;
                }
            }

 public PropertyAccessRule(
     IdentityReference identity,
     AccessControlType type,
     PropertyAccess access,
     ActiveDirectorySecurityInheritance inheritanceType)
     : base(
         identity,
         (int)PropertyAccessTranslator.AccessMaskFromPropertyAccess(access),
         type,
         Guid.Empty, // all properties
         false,
         ActiveDirectoryInheritanceTranslator.GetInheritanceFlags(inheritanceType),
         ActiveDirectoryInheritanceTranslator.GetPropagationFlags(inheritanceType),
         Guid.Empty)
 {
 }

        internal static int AccessMaskFromPropertyAccess(PropertyAccess access)
        {
            int accessMask = 0;

            if (access < PropertyAccess.Read || access > PropertyAccess.Write)
            {
                throw new InvalidEnumArgumentException("access", (int)access, typeof(PropertyAccess));
            }

            switch (access)
            {
                case PropertyAccess.Read:
                    {
                        accessMask = ActiveDirectoryRightsTranslator.AccessMaskFromRights(ActiveDirectoryRights.ReadProperty);
                        break;
                    }

                case PropertyAccess.Write:
                    {
                        accessMask = ActiveDirectoryRightsTranslator.AccessMaskFromRights(ActiveDirectoryRights.WriteProperty);
                        break;
                    }

                default:

                    //
                    // This should not happen. Indicates a problem with the 
                    // internal logic.
                    //
                    Debug.Fail("Invalid PropertyAccess value");
                    throw new ArgumentException("access");
            }
            return accessMask;
        }

        private void GenerateHasMany(CodeTypeDeclaration classDeclaration, string thisClassName, string propertyName, string customPropertyType, PropertyAccess propertyAccess, string description, CodeAttributeDeclaration attribute, bool genericRelation, bool propertyChanged, bool propertyChanging, string oppositeClassName, string oppositePropertyName, bool automaticAssociationGenerated, bool manyToMany, CodeAttributeDeclaration collectionIdAttribute)
        {
            string propertyType = String.IsNullOrEmpty(customPropertyType)
                                      ? Context.Model.EffectiveListInterface
                                      : customPropertyType;

            string memberType = propertyType;
            if (automaticAssociationGenerated)
                memberType = Context.Model.AutomaticAssociationCollectionImplementation;

            CodeMemberField memberField;
            if (!genericRelation)
                memberField = GetMemberField(propertyName, memberType, Accessor.Private, propertyAccess);
            else
                memberField = GetGenericMemberField(oppositeClassName, propertyName, memberType, Accessor.Private, propertyAccess);
            classDeclaration.Members.Add(memberField);

            // Initializes the collection by assigning a new list instance to the field.
            // Many-to-many relationships never had the initialization code enabled before.
            // Automatic associations initialize their lists in the constructor instead.
            if (Context.Model.InitializeIListFields && propertyType == Context.Model.EffectiveListInterface && !automaticAssociationGenerated)
            {
                CodeObjectCreateExpression fieldCreator = new CodeObjectCreateExpression();
                fieldCreator.CreateType = GetConcreteListType(oppositeClassName);
                memberField.InitExpression = fieldCreator;
            }

            bool createSetter = automaticAssociationGenerated ? false : true;

            if (description == "") description = null;
            CodeMemberProperty memberProperty = GetMemberProperty(memberField, propertyName, true, createSetter, propertyChanged, propertyChanging, description);
            // We need the propertyType with generic arguments added if there are any.
            memberProperty.Type = new CodeTypeReference(propertyType);
            memberProperty.Type.TypeArguments.AddRange(memberField.Type.TypeArguments);
                               
            classDeclaration.Members.Add(memberProperty);

            if (automaticAssociationGenerated)
            {
                AddConstructorForWatchedList(classDeclaration, memberField, propertyName);
                AddInternalWatchedListProperty(classDeclaration, memberProperty.Type, propertyName, memberField.Name, propertyChanged, propertyChanging, propertyAccess);
                AddItemAddedRemovedMethods(classDeclaration, thisClassName, propertyName, oppositeClassName, oppositePropertyName, manyToMany);
            }

            memberProperty.CustomAttributes.Add(attribute);

            if (collectionIdAttribute != null)
                memberProperty.CustomAttributes.Add(collectionIdAttribute);
        }

 private CodeMemberField GetMemberField(string name, string fieldType, Accessor accessor, PropertyAccess access)
 {
     return GetMemberField(name, new CodeTypeReference(fieldType), accessor, access);
 }

 public string PropertyFormat(string name, string type, PropertyAccess access)
 {
     return propDelegate(name, type, access);
 }

 public PropertyAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.AccessControlType type, PropertyAccess access, ActiveDirectorySecurityInheritance inheritanceType) : base (default(System.Security.Principal.IdentityReference), default(ActiveDirectoryRights), default(System.Security.AccessControl.AccessControlType))
 {
   Contract.Requires(identity != null);
 }

		PropertyAccessExpression EvaluatePropertyExpression (int start, int end)
		{
			// member access
			int dotAt = source.LastIndexOf ('.', end, end - start);
			int colonsAt = source.LastIndexOf ("::", end, end - start, StringComparison.Ordinal);
			if (dotAt < 0 && colonsAt < 0) {
				// property access without member specification
				int parenAt = source.IndexOf ('(', start, end - start);
				string name = parenAt < 0 ? source.Substring (start, end - start) : source.Substring (start, parenAt - start);
				var access = new PropertyAccess () {
					Name = new NameToken () { Name = name },
					TargetType = PropertyTargetType.Object
					};
				if (parenAt > 0) { // method arguments
					start = parenAt + 1;
					access.Arguments = ParseFunctionArguments (ref start, end);
				}
				return new PropertyAccessExpression () { Access = access };
			}
			if (colonsAt < 0 || colonsAt < dotAt) {
				// property access with member specification
				int mstart = dotAt + 1;
				int parenAt = source.IndexOf ('(', mstart, end - mstart);
				string name = parenAt < 0 ? source.Substring (mstart, end - mstart) : source.Substring (mstart, parenAt - mstart);
				var access = new PropertyAccess () {
					Name = new NameToken () { Name = name },
					TargetType = PropertyTargetType.Object,
					Target = dotAt < 0 ? null : Parse (start, dotAt).FirstOrDefault () 
				};
				if (parenAt > 0) { // method arguments
					start = parenAt + 1;
					access.Arguments = ParseFunctionArguments (ref start, end);
				}
				return new PropertyAccessExpression () { Access = access };
			} else {
				// static type access
				string type = source.Substring (start, colonsAt - start);
				if (type.Length < 2 || type [0] != '[' || type [type.Length - 1] != ']')
					throw new InvalidProjectFileException (string.Format ("Static function call misses appropriate type name surrounded by '[' and ']' at {0} in \"{1}\"", start, source));
				type = type.Substring (1, type.Length - 2);
				start = colonsAt + 2;
				int parenAt = source.IndexOf ('(', start, end - start);
				string member = parenAt < 0 ? source.Substring (start, end - start) : source.Substring (start, parenAt - start);
				if (member.Length == 0)
					throw new InvalidProjectFileException ("Static member name is missing");
				var access = new PropertyAccess () {
					Name = new NameToken () { Name = member },
					TargetType = PropertyTargetType.Type,
					Target = new StringLiteral () { Value = new NameToken () { Name = type } }
				};
				if (parenAt > 0) { // method arguments
					start = parenAt + 1;
					access.Arguments = ParseFunctionArguments (ref start, end);
				}
				return new PropertyAccessExpression () { Access = access };
			}
		}