public FieldDeclaration AddField(string name)
 {
     FieldDeclaration fd = new FieldDeclaration(
         Conformer.ToCapitalized(name),
         this,
         new TypeTypeDeclaration(typeof(int))
         );
     fd.Attributes = MemberAttributes.Public;
     this.fields.Add(fd);
     return fd;
 }
 public PropertyDeclaration AddProperty(
     FieldDeclaration f,
     bool hasGet,
     bool hasSet,
     bool checkNonNull
     )
 {
     return this.AddProperty(f, f.Name, hasGet, hasSet, checkNonNull);
 }
        public PropertyDeclaration AddProperty(
            FieldDeclaration f,
            string name,
            bool hasGet,
            bool hasSet,
            bool checkNonNull
            )
        {
            PropertyDeclaration p = this.AddProperty(
                f.Type,
                name);
            if (hasGet)
            {
                p.Get.Return(Expr.This.Field(f));
            }
            if (hasSet)
            {
                if (checkNonNull)
                {
                    ConditionStatement ifnull = Stm.If(Expr.Value.Identity(Expr.Null));
                    p.Set.Add(ifnull);
                    ifnull.TrueStatements.Add(
                        Stm.Throw(typeof(ArgumentNullException))
                        );
                    p.SetExceptions.Add(new ThrowedExceptionDeclaration(
                        typeof(ArgumentNullException),
                        "value is a null reference"
                        ));
                }
                p.Set.Add(
                    Stm.Assign(
                    Expr.This.Field(f),
                    Expr.Value
                    )
                    );
            }

            return p;
        }
        public FieldDeclaration AddField(ITypeDeclaration type, string name)
        {
            if (type==null)
                throw new ArgumentNullException("type");
            if (name==null)
                throw new ArgumentNullException("name");
            if (this.fields.Contains(name))
                throw new ArgumentException("field already existing in class");

            FieldDeclaration f = new FieldDeclaration(this.Conformer.ToCamel(name),this,type);
            this.fields.Add(f);
            return f;
        }
 /// <summary>
 /// Determines whether this StringFieldDeclarationDictionary contains a specific value.
 /// </summary>
 /// <param name="value">
 /// The FieldDeclaration value to locate in this StringFieldDeclarationDictionary.
 /// </param>
 /// <returns>
 /// true if this StringFieldDeclarationDictionary contains an element with the specified value;
 /// otherwise, false.
 /// </returns>
 public virtual bool ContainsValue(FieldDeclaration value)
 {
     return ContainsKey(value.Name);
 }
 /// <summary>
 /// Adds an element with the specified key and value to this StringFieldDeclarationDictionary.
 /// </summary>
 /// <param name="key">
 /// The String key of the element to add.
 /// </param>
 /// <param name="value">
 /// The FieldDeclaration value of the element to add.
 /// </param>
 public virtual void Add(FieldDeclaration value)
 {
     this.Dictionary.Add(value.Name, value);
 }
Beispiel #7
0
        private void AddEnumerator(ClassDeclaration c, FieldDeclaration data, MethodDeclaration close)
        {
            c.Interfaces.Add(typeof(IEnumerable));
            // create subclass
            ClassDeclaration en = c.AddClass("Enumerator");
            // add wrapped field
            FieldDeclaration wrapped = en.AddField(
                c,"wrapped"
                );

            ITypeDeclaration enumeratorType = new TypeTypeDeclaration(typeof(IEnumerator));
            ITypeDeclaration disposableType = new TypeTypeDeclaration(typeof(IDisposable));

            // add IEnumerator
            en.Interfaces.Add(enumeratorType);
            en.Interfaces.Add(disposableType);

            // add constructor
            ConstructorDeclaration cs = en.AddConstructor();
            ParameterDeclaration collection = cs.Signature.Parameters.Add(c,"collection",true);
            cs.Body.AddAssign(Expr.This.Field(wrapped),Expr.Arg(collection));

            // add current
            PropertyDeclaration current = en.AddProperty(data.Type,"Current");
            current.Get.Return(
                Expr.This.Field(wrapped).Prop("Data")
                );

            // add explicit interface implementation
            PropertyDeclaration currentEn = en.AddProperty(typeof(Object),"Current");
            currentEn.Get.Return(Expr.This.Prop(current));
            currentEn.PrivateImplementationType = enumeratorType;

            // add reset
            MethodDeclaration reset = en.AddMethod("Reset");
            reset.ImplementationTypes.Add( wrapped.Type );
            reset.Body.Add( Stm.Throw(typeof(InvalidOperationException),Expr.Prim("Not supported")));

            // add movenext
            MethodDeclaration movenext = en.AddMethod("MoveNext");
            movenext.ImplementationTypes.Add(wrapped.Type );
            movenext.Signature.ReturnType = new TypeTypeDeclaration(typeof(bool));
            movenext.Body.Return( Expr.This.Field(wrapped).Method("Read").Invoke());

            // add dispose
            MethodDeclaration disposeEn  = en.AddMethod("Dispose");
            disposeEn.ImplementationTypes.Add( disposableType );
            disposeEn.Body.Add(
                Expr.This.Field(wrapped).Method(close).Invoke()
                );
            disposeEn.Body.AddAssign( Expr.This.Field(wrapped),Expr.Null );

            // add get enuemrator
            MethodDeclaration geten = c.AddMethod("GetEnumerator");
            geten.Signature.ReturnType = en;
            geten.Body.Return(Expr.New(en,Expr.This));

            MethodDeclaration igeten = c.AddMethod("GetEnumerator");
            igeten.PrivateImplementationType = new TypeTypeDeclaration(typeof(IEnumerable));
            igeten.Signature.ReturnType = new TypeTypeDeclaration(typeof(IEnumerator));
            igeten.Body.Return(Expr.This.Method("GetEnumerator").Invoke());
        }