public CSProperty(CSType type, CSMethodKind kind,
CSVisibility getVis, CSCodeBlock getter,
CSVisibility setVis, CSCodeBlock setter, CSParameterList parms)
: this(type, kind, new CSIdentifier("this"), getVis, getter, setVis, setter,
Exceptions.ThrowOnNull(parms, nameof(parms)))
{
}
public CSDelegateTypeDecl(CSVisibility vis, CSType type, CSIdentifier name, CSParameterList parms)
{
Visibility = vis;
Type = type != null ? type : CSSimpleType.Void;
Name = Exceptions.ThrowOnNull(name, "name");
Parameters = parms;
}
public CSEnum(CSVisibility vis, CSIdentifier name, CSType optionalType)
{
Values = new List <CSBinding> ();
Name = Exceptions.ThrowOnNull(name, "name");
OptionalType = optionalType;
Visibility = vis;
}
public ForElement(CSType type, CSIdentifier ident, CSBaseExpression expr)
: base()
{
Type = type;
Ident = ident;
Expr = expr;
}
static CSProperty PublicGetPubPrivSetBacking(CSType type, string name, bool declareField, bool setIsPublic, string backingFieldName = null)
{
if (!declareField && backingFieldName == null)
{
throw new ArgumentException("declareField must be true if there is no supplied field name", nameof(declareField));
}
backingFieldName = backingFieldName ?? MassageName(Exceptions.ThrowOnNull(name, nameof(name)));
CSIdentifier backingIdent = new CSIdentifier(backingFieldName);
LineCodeElementCollection <ICodeElement> getCode =
new LineCodeElementCollection <ICodeElement> (new ICodeElement [] { CSReturn.ReturnLine(backingIdent) }, false, true);
LineCodeElementCollection <ICodeElement> setCode =
new LineCodeElementCollection <ICodeElement> (
new ICodeElement [] {
CSAssignment.Assign(backingFieldName, new CSIdentifier("value"))
}, false, true);
CSProperty prop = new CSProperty(type, CSMethodKind.None, new CSIdentifier(name), CSVisibility.Public,
new CSCodeBlock(getCode),
(setIsPublic ? CSVisibility.Public : CSVisibility.Private), new CSCodeBlock(setCode));
if (declareField)
{
prop.Insert(0, CSFieldDeclaration.FieldLine(type, backingFieldName));
}
return(prop);
}
public static CSProperty PublicGetBacking(CSType type, string name, string backingFieldName, bool includeBackingFieldDeclaration = false)
{
return(PublicGetBacking(type,
new CSIdentifier(Exceptions.ThrowOnNull(name, nameof(name))),
new CSIdentifier(Exceptions.ThrowOnNull(backingFieldName, nameof(backingFieldName))),
includeBackingFieldDeclaration));
}
public CSFixedCodeBlock(CSType type, CSIdentifier ident, CSBaseExpression expr, IEnumerable <ICodeElement> body)
: base(body)
{
Type = Exceptions.ThrowOnNull(type, "type");
Identifier = Exceptions.ThrowOnNull(ident, "ident");
Expr = Exceptions.ThrowOnNull(expr, "expr");
}
public CSProperty(CSType type, CSMethodKind kind, CSIdentifier name,
CSVisibility getVis, IEnumerable <ICodeElement> getter,
CSVisibility setVis, IEnumerable <ICodeElement> setter)
: this(type, kind, name,
getVis, getter != null ? new CSCodeBlock(getter) : null,
setVis, setter != null ? new CSCodeBlock(setter) : null)
{
}
public CSVariableDeclaration(CSType type, IEnumerable <CSBinding> bindings)
: base(null, false, true)
{
Type = Exceptions.ThrowOnNull(type, "type");
And(Type).And(SimpleElememt.Spacer);
Bindings = new CommaListElementCollection <CSBinding> (Exceptions.ThrowOnNull(bindings, "bindings"));
Add(Bindings);
}
public static CSMethod PInvoke(CSVisibility vis, CSType type, string name, CSBaseExpression dllName, string externName, CSParameterList parms)
{
CSMethod method = new CSMethod(vis, CSMethodKind.StaticExtern, Exceptions.ThrowOnNull(type, "type"),
new CSIdentifier(name), parms, null);
CSAttribute.DllImport(dllName, externName).AttachBefore(method);
return(method);
}
public CSForEach(CSType type, CSIdentifier ident, CSBaseExpression expr, CSCodeBlock body)
{
Type = type;
Ident = Exceptions.ThrowOnNull(ident, nameof(ident));
Expr = Exceptions.ThrowOnNull(expr, nameof(expr));
Body = body ?? new CSCodeBlock();
Add(new ForElement(type, ident, expr));
Add(Body);
}
public CSParameter(CSType type, CSIdentifier name,
CSParameterKind parameterKind = CSParameterKind.None,
CSConstant defaultValue = null)
{
CSType = Exceptions.ThrowOnNull(type, nameof(type));
Name = Exceptions.ThrowOnNull(name, nameof(name));
ParameterKind = parameterKind;
DefaultValue = defaultValue;
}
public CSMethod(CSVisibility vis, CSMethodKind kind, CSType type, CSIdentifier name,
CSParameterList parms, CSBaseExpression[] baseOrThisCallParms, bool callsBase, CSCodeBlock body, bool isSealed = false)
{
GenericParameters = new CSGenericTypeDeclarationCollection();
GenericConstraints = new CSGenericConstraintCollection();
Visibility = vis;
Kind = kind;
Type = type; // no throw on null - could be constructor
Name = Exceptions.ThrowOnNull(name, nameof(name));
Parameters = Exceptions.ThrowOnNull(parms, nameof(parms));
CallsBase = callsBase;
BaseOrThisCallParameters = baseOrThisCallParms;
Body = body; // can be null
IsSealed = isSealed;
LineCodeElementCollection <ICodeElement> lc = new LineCodeElementCollection <ICodeElement> (new ICodeElement [0], false, true);
if (vis != CSVisibility.None)
{
lc.And(new SimpleElememt(VisibilityToString(vis))).And(SimpleElememt.Spacer);
}
if (isSealed)
{
lc.And(new SimpleElememt("sealed")).And(SimpleElememt.Spacer);
}
lc.And(new SimpleElememt(MethodKindToString(kind))).And(SimpleElememt.Spacer);
if (type != null)
{
lc.And(type).And(SimpleElememt.Spacer);
}
lc.And(name).And(GenericParameters).And(new SimpleElememt("(")).And(parms).And(new SimpleElememt(")")).And(GenericConstraints);
if (body == null)
{
if (!(kind == CSMethodKind.StaticExtern || kind == CSMethodKind.Interface))
{
throw new ArgumentException("Method body is only optional when method kind kind is either StaticExtern or Interface",
nameof(body));
}
lc.Add(new SimpleElememt(";"));
}
Add(lc);
if (BaseOrThisCallParameters != null)
{
Add(new CSFunctionCall(CallsBase ? ": base" : ": this", false, BaseOrThisCallParameters));
}
if (body != null)
{
Add(body);
}
}
public static CSProperty PublicGetBacking(CSType type, CSIdentifier name, CSIdentifier backingFieldName,
bool includeBackingFieldDeclaration = false, CSMethodKind methodKind = CSMethodKind.None)
{
LineCodeElementCollection <ICodeElement> getCode =
new LineCodeElementCollection <ICodeElement> (
new ICodeElement [] {
CSReturn.ReturnLine(Exceptions.ThrowOnNull(backingFieldName, nameof(backingFieldName)))
}, false, true);
CSProperty prop = new CSProperty(type, methodKind, Exceptions.ThrowOnNull(name, nameof(name)),
CSVisibility.Public, new CSCodeBlock(getCode),
CSVisibility.Public, null);
if (includeBackingFieldDeclaration)
{
prop.Insert(0, CSFieldDeclaration.FieldLine(type, backingFieldName));
}
return(prop);
}
public CSFieldDeclaration(CSType type, IEnumerable <CSBinding> bindings, CSVisibility vis = CSVisibility.None, bool isStatic = false, bool isReadonly = false)
: base(type, bindings)
{
Visibilty = vis;
IsStatic = isStatic;
if (isReadonly)
{
this.Insert(0, new SimpleElememt("readonly"));
this.Insert(1, SimpleElememt.Spacer);
}
if (isStatic)
{
this.Insert(0, new SimpleElememt("static"));
this.Insert(1, SimpleElememt.Spacer);
}
if (vis != CSVisibility.None)
{
this.Insert(0, new SimpleElememt(CSMethod.VisibilityToString(vis)));
this.Insert(1, SimpleElememt.Spacer);
}
}
public static CSLine VarLine(CSType type, string name, ICSExpression value = null)
{
return(new CSLine(new CSVariableDeclaration(type, name, value)));
}
public CSVariableDeclaration(CSType type, CSIdentifier name, ICSExpression value = null)
: this(type, new CSBinding [] { new CSBinding(name, value) })
{
}
public CSVariableDeclaration(CSType type, string name, ICSExpression value = null)
: this(type, new CSIdentifier(name), value)
{
}
public CSListInitialized(CSType type, params CSBaseExpression [] parameters)
: this(type, new CommaListElementCollection <CSBaseExpression> (parameters))
{
}
CSProperty(CSType type, CSMethodKind kind, CSIdentifier name,
CSVisibility getVis, CSCodeBlock getter,
CSVisibility setVis, CSCodeBlock setter, CSParameterList parms)
{
bool unifiedVis = getVis == setVis;
IndexerParameters = parms;
LineCodeElementCollection <ICodeElement> decl = new LineCodeElementCollection <ICodeElement> (null, false, true);
GetterVisibility = getVis;
SetterVisibility = setVis;
CSVisibility bestVis = (CSVisibility)Math.Min((int)getVis, (int)setVis);
decl.And(new SimpleElememt(CSMethod.VisibilityToString(bestVis))).And(SimpleElememt.Spacer);
if (kind != CSMethodKind.None)
{
decl.And(new SimpleElememt(CSMethod.MethodKindToString(kind))).And(SimpleElememt.Spacer);
}
PropType = type;
Name = name;
decl.And(Exceptions.ThrowOnNull(type, "type")).And(SimpleElememt.Spacer)
.And(Exceptions.ThrowOnNull(name, nameof(name)));
if (parms != null)
{
decl.And(new SimpleElememt("[", true)).And(parms).And(new SimpleElememt("]"));
}
Add(decl);
CSCodeBlock cb = new CSCodeBlock(null);
if (getter != null)
{
Getter = getter;
LineCodeElementCollection <ICodeElement> getLine = MakeEtter(getVis, "get", unifiedVis, getVis > setVis);
cb.Add(getLine);
if (getter.Count() == 0)
{
getLine.Add(new SimpleElememt(";"));
}
else
{
cb.Add(getter);
}
}
if (setter != null)
{
Setter = setter;
LineCodeElementCollection <ICodeElement> setLine = MakeEtter(setVis, "set", unifiedVis, setVis > getVis);
cb.Add(setLine);
if (setter.Count() == 0)
{
setLine.Add(new SimpleElememt(";"));
}
else
{
cb.Add(setter);
}
}
Add(cb);
}
public CSFieldDeclaration(CSType type, CSIdentifier name, ICSExpression value = null, CSVisibility vis = CSVisibility.None, bool isStatic = false, bool isReadOnly = false)
: this(type, new CSBinding [] { new CSBinding(name, value) }, vis, isStatic, isReadOnly)
{
}
public static CSProperty PublicGetPrivateSet(CSType type, string name)
{
return(new CSProperty(type, CSMethodKind.None, new CSIdentifier(name),
CSVisibility.Public, new CSCodeBlock(), CSVisibility.Private, new CSCodeBlock()));
}
public CSForEach(CSType type, string ident, CSBaseExpression expr, CSCodeBlock body)
: this(type, new CSIdentifier(ident), expr, body)
{
}
public static CSProperty PublicGetPrivateSetBacking(CSType type, string name, bool declareField, string backingFieldName = null)
{
return(PublicGetPubPrivSetBacking(type, name, false, declareField, backingFieldName));
}
public CSEnum(CSVisibility vis, string name, CSType optionalType)
: this(vis, new CSIdentifier(name), optionalType)
{
}
public CSParameter(CSType type, string name,
CSParameterKind parameterKind = CSParameterKind.None,
CSConstant defaultValue = null)
: this(type, new CSIdentifier(name), parameterKind, defaultValue)
{
}
public CSFieldDeclaration(CSType type, string name, ICSExpression value = null, CSVisibility vis = CSVisibility.None, bool isSatic = false, bool isReadonly = false)
: this(type, new CSIdentifier(name), value, vis, isSatic, isReadonly)
{
}
public CSListInitialized(CSType type, CommaListElementCollection <CSBaseExpression> initializers)
{
Type = Exceptions.ThrowOnNull(type, "type");
Parameters = Exceptions.ThrowOnNull(initializers, "initializers");
}
public static CSLine FieldLine(CSType type, CSIdentifier name, ICSExpression value = null, CSVisibility vis = CSVisibility.None, bool isStatic = false)
{
return(new CSLine(new CSFieldDeclaration(type, name, value, vis, isStatic)));
}
public CSProperty(CSType type, CSMethodKind kind, CSIdentifier name,
CSVisibility getVis, CSCodeBlock getter,
CSVisibility setVis, CSCodeBlock setter)
: this(type, kind, name, getVis, getter, setVis, setter, null)
{
}