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 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 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 CSProperty CompileProperty(string propertyName, CSUsingPackages packs, SwiftType swiftPropertyType, bool hasGetter, bool hasSetter,
CSMethodKind methodKind)
{
propertyName = typeMap.SanitizeIdentifier(propertyName);
NetTypeBundle propertyType = typeMap.MapType(swiftPropertyType, false);
if (!(swiftPropertyType is SwiftGenericArgReferenceType))
{
AddUsingBlock(packs, propertyType);
}
ICodeElement [] uselessLine = new ICodeElement [] { CSReturn.ReturnLine(new CSIdentifier("useless")) };
CSCodeBlock getterBlock = null;
if (hasGetter)
{
getterBlock = new CSCodeBlock(uselessLine);
}
CSCodeBlock setterBlock = null;
if (hasSetter)
{
setterBlock = new CSCodeBlock(uselessLine);
}
CSProperty theProp = new CSProperty(propertyType.ToCSType(packs), methodKind,
new CSIdentifier(propertyName), CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock);
if (getterBlock != null)
{
getterBlock.Clear();
}
if (setterBlock != null)
{
setterBlock.Clear();
}
return(theProp);
}
public static string MethodKindToString(CSMethodKind kind)
{
switch (kind)
{
case CSMethodKind.None:
case CSMethodKind.Interface:
return("");
case CSMethodKind.Extern:
return("extern");
case CSMethodKind.New:
return("new");
case CSMethodKind.Override:
return("override");
case CSMethodKind.Static:
return("static");
case CSMethodKind.StaticExtern:
return("static extern");
case CSMethodKind.StaticNew:
return("static new");
case CSMethodKind.Virtual:
return("virtual");
case CSMethodKind.Abstract:
return("abstract");
default:
throw new ArgumentOutOfRangeException(nameof(kind));
}
}
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 CSProperty(CSType type, CSMethodKind kind, CSIdentifier name,
CSVisibility getVis, CSCodeBlock getter,
CSVisibility setVis, CSCodeBlock setter)
: this(type, kind, name, getVis, getter, setVis, setter, null)
{
}
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 static CSMethod PublicMethod(CSMethodKind kind, CSType type, string name, CSParameterList parms, CSCodeBlock body)
{
return(new CSMethod(CSVisibility.Public, kind, type, new CSIdentifier(name), parms, Exceptions.ThrowOnNull(body, "body")));
}
public CSMethod(CSVisibility vis, CSMethodKind kind, CSType type, CSIdentifier name, CSParameterList parms, CSCodeBlock body)
: this(vis, kind, type, name, parms, null, false, body)
{
}
public CSProperty CompileProperty(CSUsingPackages packs, string propertyName,
FunctionDeclaration getter, FunctionDeclaration setter, CSMethodKind methodKind = CSMethodKind.None)
{
var swiftPropertyType = GetPropertyType(getter, setter);
NetTypeBundle propertyType = null;
if (TypeMapper.IsCompoundProtocolListType(swiftPropertyType))
{
propertyType = new NetTypeBundle("System", "object", false, false, EntityType.ProtocolList);
}
else
{
propertyType = typeMap.MapType(getter, swiftPropertyType, false, true);
}
propertyName = propertyName ?? typeMap.SanitizeIdentifier(getter != null ? getter.PropertyName : setter.PropertyName);
bool isSubscript = getter != null ? getter.IsSubscript :
setter.IsSubscript;
if (!getter.IsTypeSpecGeneric(swiftPropertyType))
{
AddUsingBlock(packs, propertyType);
}
var uselessLine = new ICodeElement [] { CSReturn.ReturnLine(new CSIdentifier("useless")) };
CSCodeBlock getterBlock = null;
if (getter != null)
{
getterBlock = new CSCodeBlock(uselessLine);
}
CSCodeBlock setterBlock = null;
if (setter != null)
{
setterBlock = new CSCodeBlock(uselessLine);
}
CSProperty theProp = null;
if (isSubscript)
{
List <ParameterItem> swiftParms = null;
if (getter != null)
{
swiftParms = getter.ParameterLists [1];
}
else
{
swiftParms = setter.ParameterLists [1].Skip(1).ToList();
}
var args = typeMap.MapParameterList(getter, swiftParms, false, false, null, null);
args.ForEach(a => AddUsingBlock(packs, a.Type));
var csParams =
new CSParameterList(
args.Select(a =>
new CSParameter(a.Type.ToCSType(packs),
new CSIdentifier(a.Name), a.Type.IsReference ? CSParameterKind.Ref : CSParameterKind.None, null)));
theProp = new CSProperty(propertyType.ToCSType(packs), methodKind, CSVisibility.Public, getterBlock,
CSVisibility.Public, setterBlock, csParams);
}
else
{
theProp = new CSProperty(propertyType.ToCSType(packs), methodKind,
new CSIdentifier(propertyName), CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock);
}
if (getterBlock != null)
{
getterBlock.Clear();
}
if (setterBlock != null)
{
setterBlock.Clear();
}
return(theProp);
}