public void VisitFieldRef(FieldRef fieldRef)
{
InstructionDependency[] preds;
switch (_litMode)
{
case ELiteralAcceptMode.Read:
preds = _storesInCurBB.Get(fieldRef)
.Select(_ => new OrderDependency(_, OrderDependency.EKind.BeginAfter))
.ToArray();
_readsInCurBB.Add(fieldRef, NextInstructionIndex);
Emit(ISet.LoadVar(fieldRef), _curExpr, preds, 0, fieldRef.Type);
break;
case ELiteralAcceptMode.Write:
{
preds = _storesInCurBB.Get(fieldRef)
.Union(_readsInCurBB.Get(fieldRef))
.Select(_ => new OrderDependency(_, OrderDependency.EKind.BeginAfter))
.ToArray();
if (preds.Any())
{
int idx = NextInstructionIndex;
Emit(DefaultInstructionSet.Instance.Nop(0), _curExpr, preds, 0);
preds = new InstructionDependency[] { new OrderDependency(idx, OrderDependency.EKind.BeginAfter) };
}
_storesInCurBB.Add(fieldRef, NextInstructionIndex);
Emit(ISet.StoreVar(fieldRef), _curExpr, preds, 1);
}
break;
}
}
static void Prefix(PlayerMissionUICtr __instance)
{
FieldRef <OtherConfig, int> playerMissionMaxCount = FieldRefAccess <OtherConfig, int>("playerMissionMaxCount");
playerMissionMaxCount(OtherConfig.Self) = settings.MaxMissions;
__instance.GetType().GetMethod("FreshNumAccept", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { });
}
private static void DoAddRelationship(Actor ao, string animName)
{
if (settings.LimitRelationshipPointGain)
{
var mBehavior = FieldRefAccess <Actor, BehaviorTree>(ao, "mBehavior");
var mITActions = mBehavior.FindTasks <ITDecorator>();
if (mITActions != null && mITActions.Count > 0)
{
for (int i = 0; i < mITActions.Count; i++)
{
Dbgl($"{animName} interact id: {mITActions[i].iid.Value}");
if (mITActions[i] != null && mITActions[i].iid.Value == InteractIds[animName])
{
FieldRef <ITDecorator, int> mCurTimesRef = FieldRefAccess <ITDecorator, int>("mCurTimes");
if (mCurTimesRef(mITActions[i]) < InteractiveData.GetTimes(mITActions[i].iid.Value))
{
mCurTimesRef(mITActions[i])++;
Module <FavorManager> .Self.GainFavorValue(ao.InstanceId,
InteractiveData.GetFavorValue(InteractIds[animName]), true, true);
}
return;
}
}
}
}
Module <FavorManager> .Self.GainFavorValue(ao.InstanceId, InteractiveData.GetFavorValue(InteractIds[animName]), true, true);
}
public FieldSymbol(string name, TypeProxy type, FieldGetter getter = null, FieldSetter setter = null, FieldRef getref = null)
: base(name, type)
{
this.getter = getter;
this.setter = setter;
this.getref = getref;
}
private static void UpdateFieldRef(List siteList, Guid fieldId, FieldRef fieldRef)
{
// find the field in the list
var listField = siteList.Fields.GetById(fieldId);
siteList.Context.Load(listField, f => f.Title, f => f.Hidden, f => f.Required);
siteList.Context.ExecuteQueryRetry();
var isDirty = false;
if (!string.IsNullOrEmpty(fieldRef.DisplayName) && fieldRef.DisplayName != listField.Title)
{
listField.Title = fieldRef.DisplayName;
isDirty = true;
}
if (fieldRef.Hidden != listField.Hidden)
{
listField.Hidden = fieldRef.Hidden;
isDirty = true;
}
if (fieldRef.Required != listField.Required)
{
listField.Required = fieldRef.Required;
isDirty = true;
}
if (isDirty)
{
listField.UpdateAndPushChanges(true);
siteList.Context.ExecuteQueryRetry();
}
}
public static void registerNatives(Type thread)
{
_nativeData = new FieldRef <Data>(thread, "__nativeData");
_run = new MethodRef <Action>(thread, "run");
var clrThread = Thread.CurrentThread;
_sysThreadGroup = (ThreadGroup)Activator.CreateInstance(typeof(ThreadGroup), true);
var mainThread = (java.lang.Thread)FormatterServices.GetUninitializedObject(thread);
//_isIniting = true;
//var mainThread = Activator.CreateInstance(_javaLangThread, _sysThreadGroup, null, "MainThread", 0L);
lock (_javaThreads)
{
_javaThreads.Add(clrThread.ManagedThreadId, mainThread);
}
//_isIniting = false;
mainThread.SetField("name", "Main Thread".ToCharArray());
mainThread.SetField("group", _sysThreadGroup);
mainThread.SetField("daemon", false);
mainThread.SetField("priority", 5);
mainThread.SetField("threadStatus", 0);
_nativeData[mainThread] = new Data {
ClrThread = Thread.CurrentThread, JavaThread = mainThread
};
//_javaLangThread.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
// .Single(x => x.Name == "init" && x.GetParameters().Length == 4)
// .Invoke(mainThread, new object[] { _sysThreadGroup, null, "Main Thread", 0L });
}
/// <summary>
/// Add a FieldRef
/// </summary>
/// <param name="name"></param>
/// <param name="ascending">true, for ascending</param>
/// <returns>Fluent <see cref="OrderBy"/></returns>
public OrderBy AddFieldRef(string name, bool ascending)
{
var field = new FieldRef(name);
field.AddAttribute("Ascending", ascending ? "TRUE" : "FALSE");
Childs.Add(field);
return(this);
}
protected SingleFieldMultipleValueOperator(string operatorName, string fieldName, IEnumerable <Value <T> > values)
: base(operatorName, values)
{
FieldRef = new FieldRef()
{
Name = fieldName
};
}
protected SingleFieldMultipleValueOperator(string operatorName, Guid fieldId, IEnumerable <T> values, SPFieldType type)
: base(operatorName, values, type)
{
FieldRef = new FieldRef()
{
FieldId = fieldId
};
}
public static RestField FromFieldRef(FieldRef field, object value, RestFieldParser parser)
{
var restField = new RestField();
restField.Field = parser.Parse(field);
restField.Value = parser.ParseValue(value);
return(restField);
}
public FieldValue(string fieldName, object fieldValue) : base()
{
Field = new FieldRef()
{
Name = fieldName
};
Value = fieldValue;
}
protected SingleFieldValueOperator(string operatorName, Guid fieldId, Value <T> value)
: base(operatorName, value)
{
FieldRef = new FieldRef()
{
FieldId = fieldId
};
}
protected SingleFieldValueOperator(string operatorName, Guid fieldId, T value, SPFieldType type)
: base(operatorName, value, type)
{
FieldRef = new FieldRef()
{
FieldId = fieldId
};
}
protected SingleFieldValueOperator(string operatorName, string fieldName, Value <T> value)
: base(operatorName, value)
{
FieldRef = new FieldRef()
{
Name = fieldName
};
}
protected SingleFieldValueOperator(string operatorName, string fieldName, T value, SPFieldType type)
: base(operatorName, value, type)
{
FieldRef = new FieldRef()
{
Name = fieldName
};
}
protected override void OnParsing(XElement existingSingleFieldValueOperator)
{
XElement existingFieldRef = existingSingleFieldValueOperator.Elements().SingleOrDefault(el => string.Equals(el.Name.LocalName, "FieldRef", StringComparison.InvariantCultureIgnoreCase));
if (existingFieldRef != null)
{
FieldRef = new FieldRef(existingFieldRef);
}
}
/// <summary>
/// Get the document builder to insert a REF field, reference a bookmark with it, and add text before and after
/// </summary>
private FieldRef InsertFieldRef(DocumentBuilder builder, string bookmarkName, string textBefore, string textAfter)
{
builder.Write(textBefore);
FieldRef field = (FieldRef)builder.InsertField(FieldType.FieldRef, true);
field.BookmarkName = bookmarkName;
builder.Write(textAfter);
return(field);
}
protected override void OnParsing(XElement existingSingleFieldValueOperator)
{
XElement existingFieldRef = existingSingleFieldValueOperator.Elements().SingleOrDefault(el => string.Equals(el.Name.LocalName, "FieldRef", StringComparison.InvariantCultureIgnoreCase));
if (existingFieldRef != null)
{
FieldRef = new FieldRef(existingFieldRef);
}
}
/// <summary>
/// Add a <FieldRef>-Attribute
/// </summary>
/// <param name="this"></param>
/// <param name="name"></param>
/// <param name="action"></param>
/// <returns></returns>
public static T AddFieldRef <T>(this T @this, string name, Action <FieldRef> action)
where T : BaseCoreCompareElement <T>
{
var fieldRef = new FieldRef(name);
action(fieldRef);
@this.Childs.Add(fieldRef);
return(@this);
}
public void CanUpdateCalculatedFieldRefInListInstance()
{
var template = new ProvisioningTemplate();
template.SiteFields.Add(new Core.Framework.Provisioning.Model.Field()
{
SchemaXml = ElementSchema
});
template.SiteFields.Add(new Core.Framework.Provisioning.Model.Field()
{
SchemaXml = TokenizedCalculatedFieldElementSchema
});
var listInstance = new ListInstance();
listInstance.Url = string.Format("lists/{0}", listName);
listInstance.Title = listName;
listInstance.TemplateType = (int)ListTemplateType.GenericList;
var referencedField = new FieldRef();
referencedField.Id = fieldId;
listInstance.FieldRefs.Add(referencedField);
var calculatedFieldRef = new FieldRef();
calculatedFieldRef.Id = calculatedFieldId;
listInstance.FieldRefs.Add(calculatedFieldRef);
template.Lists.Add(listInstance);
using (var ctx = TestCommon.CreateClientContext())
{
var parser = new TokenParser(ctx.Web, template);
new ObjectField().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
new ObjectListInstance().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
var list = ctx.Web.GetListByUrl(listInstance.Url);
Assert.IsNotNull(list);
var rf = list.GetFieldById <FieldText>(fieldId);
var f1 = list.GetFieldById <FieldCalculated>(calculatedFieldId);
Assert.IsNotNull(rf, "Referenced field not added");
Assert.IsNotNull(f1);
Assert.IsInstanceOfType(f1, typeof(FieldCalculated));
Assert.IsFalse(f1.Formula.Contains('#') || f1.Formula.Contains('?'), "Calculated field was not provisioned properly the first time");
new ObjectListInstance().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
var f2 = list.GetFieldById <FieldCalculated>(calculatedFieldId);
Assert.IsNotNull(f2);
Assert.IsInstanceOfType(f2, typeof(FieldCalculated));
Assert.IsFalse(f2.Formula.Contains('#') || f2.Formula.Contains('?'), "Calculated field was not provisioned properly the second time");
}
}
public override void VisitFieldRef(FieldRef fieldRef)
{
if (fieldRef.HasAttribute <LocalizeField>())
{
SetCurrentLiteral(_f2loc[fieldRef]);
}
else
{
SetCurrentLiteral(fieldRef);
}
}
public override void Build()
{
ns("MyNameSpace");
declClass(TypePublic, "MyClasss");
declMethod(MemPublic, "System.Void", "MyMethod");
FieldRef testField = new FieldRef(my(), "TestField");
enter(testField);
}
static void Prefix(PlayerItemBarCtr __instance)
{
if (!enabled)
{
return;
}
if (KeyDown(settings.ItemBarSwitchKey))
{
for (int index = 0; index < 8; index++)
{
ItemObject itemObject = Module <Player> .Self.bag.itemBar.itemBarItems[index];
ItemObject itemObj = Module <Player> .Self.bag.GetItems(0).GetItemObj(index);
Module <Player> .Self.bag.BagExchangeItemBar(index, index, 0);
}
MethodInfo dynMethod = __instance.GetType().GetMethod("Unequip", BindingFlags.NonPublic | BindingFlags.Instance);
dynMethod.Invoke(__instance, new object[] { });
}
else if (KeyDown(settings.OpenStorageKey) && UIStateMgr.Instance.currentState.type == UIStateMgr.StateType.Play)
{
StorageViewer sv = new StorageViewer();
FieldRef <StorageViewer, StorageUnit> suRef = FieldRefAccess <StorageViewer, StorageUnit>("storageUnit");
suRef(sv) = StorageUnit.GetStorageByGlobalIndex(lastStorageIndex);
MethodInfo dynMethod = sv.GetType().GetMethod("InteractStorage", BindingFlags.NonPublic | BindingFlags.Instance);
dynMethod.Invoke(sv, new object[] { });
}
else if (KeyDown(settings.OpenFactoryKey) && UIStateMgr.Instance.currentState.type == UIStateMgr.StateType.Play)
{
FarmFactory[] factorys = Module <FarmFactoryMgr> .Self.GetAllFactorys();
if (factorys.Length == 0)
{
return;
}
FarmFactory factory = factorys[0];
Action <List <IdCount> > action = delegate(List <IdCount> ls)
{
factory.SetMatList(ls);
};
UIStateMgr.Instance.ChangeStateByType(UIStateMgr.StateType.PackageExchangeState, true, new object[]
{
factory.MatList,
TextMgr.GetStr(103440, -1),
true,
action,
103521,
300
});
}
}
protected void Write(FieldRef fieldRef)
{
using (this.Trace("FieldRef"))
{
this.writer.Write(!fieldRef.IsEmpty);
if (!fieldRef.IsEmpty)
{
this.Write(fieldRef.DeclaringType);
this.WriteCompressedMetadataToken(fieldRef.MetadataToken, MetadataTokenType.Field);
}
}
}
protected void Write(FieldRef fieldRef)
{
using (this.Trace(nameof(FieldRef)))
{
if (this.TryPrepareSerializeReusableObject(fieldRef))
{
this.Write(fieldRef.DeclaringType);
this.WriteCompressedMetadataToken(fieldRef.MetadataToken, MetadataTokenType.Field);
this.Write(fieldRef.Name);
}
}
}
private FieldRef Scramble(FieldRef fieldRef)
{
if (fieldRef.IsEmpty)
{
return(default(FieldRef));
}
return(new FieldRef(
this.Scramble(fieldRef.DeclaringType),
this.GetScrambledMetadataToken(fieldRef.MetadataToken),
fieldRef.Name));
}
private static void Postfix(ref Actor __instance, ref SkinnedMeshRenderer ___skinnedMeshRenderer)
{
FieldRef <Actor, SkinnedMeshRenderer> rendererByRef = FieldRefAccess <Actor, SkinnedMeshRenderer>("skinnedMeshRenderer");
if (__instance.InstanceId == 4000050)
{
if (___skinnedMeshRenderer != null)
{
___skinnedMeshRenderer.sharedMesh = rendererByRef(ActorMgr.Self.Get(4000011)).sharedMesh;
}
}
}
/// <summary>
/// THIS is the method that needs to be what each
/// thread executes--streams the text to a file.
/// </summary>
public static void StreamToFile()
{
// buffer size for file IO
const int BUFFER_SIZE = 5000;
while (!_writeJobs.IsCompleted)
{
WriteJob op;
bool success = _writeJobs.TryTake(out op);
if (!success)
{
Thread.Sleep(100);
continue;
}
// stream
// create ref to object
var relativityObj = new RelativityObjectRef
{
ArtifactID = op.DocumentId
};
// create ref to field
var longTextFieldRef = new FieldRef
{
ArtifactID = op.LongTextFieldId
};
// instantiate object manager service
using (IObjectManager objMgr = ServiceFactory.CreateProxy <IObjectManager>())
using (IKeplerStream ks = objMgr.StreamLongTextAsync(
op.WorkspaceId, relativityObj, longTextFieldRef).Result)
using (Stream s = ks.GetStreamAsync().Result)
using (var reader = new StreamReader(s))
using (var writer = new StreamWriter(op.Path, append: false))
{
char[] buffer = new char[BUFFER_SIZE];
int copied;
do
{
copied = reader.Read(buffer, 0, BUFFER_SIZE);
writer.Write(
copied == BUFFER_SIZE
? buffer
: buffer.Take(copied).ToArray());
writer.Flush();
} while (copied > 0);
}
}
}
public void CanExtractCalculatedFieldFromListInstance()
{
var template = new ProvisioningTemplate();
var listInstance = new ListInstance();
template.SiteFields.Add(new Core.Framework.Provisioning.Model.Field()
{
SchemaXml = ElementSchema
});
listInstance.Url = string.Format("lists/{0}", listName);
listInstance.Title = listName;
listInstance.TemplateType = (int)ListTemplateType.GenericList;
var referencedField = new FieldRef();
referencedField.Id = fieldId;
listInstance.FieldRefs.Add(referencedField);
var calculatedField = new Core.Framework.Provisioning.Model.Field();
calculatedField.SchemaXml = TokenizedCalculatedFieldElementSchema;
listInstance.Fields.Add(calculatedField);
template.Lists.Add(listInstance);
using (var ctx = TestCommon.CreateClientContext())
{
var parser = new TokenParser(ctx.Web, template);
new ObjectField().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
new ObjectListInstance().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
var list = ctx.Web.GetListByUrl(listInstance.Url);
Assert.IsNotNull(list);
var rf = list.GetFieldById <FieldText>(fieldId);
var f = list.GetFieldById <FieldCalculated>(calculatedFieldId);
Assert.IsNotNull(rf, "Referenced field not added");
Assert.IsNotNull(f);
Assert.IsInstanceOfType(f, typeof(FieldCalculated));
Assert.IsFalse(f.Formula.Contains('#') || f.Formula.Contains('?'), "Calculated field was not provisioned properly");
var extractedTemplate = new ProvisioningTemplate();
var provisioningTemplateCreationInformation = new ProvisioningTemplateCreationInformation(ctx.Web);
new ObjectListInstance().ExtractObjects(ctx.Web, extractedTemplate, provisioningTemplateCreationInformation);
XElement fieldElement = XElement.Parse(extractedTemplate.Lists.First(l => l.Title == listName).Fields.First(cf => Guid.Parse(XElement.Parse(cf.SchemaXml).Attribute("ID").Value).Equals(calculatedFieldId)).SchemaXml);
var formula = fieldElement.Descendants("Formula").FirstOrDefault();
Assert.AreEqual(@"=[{fieldtitle:DemoField}]&""DemoField""", formula.Value, true, "Calculated field formula is not extracted properly");
}
}
private static FieldValuePair ToFieldPair(FieldValue fieldValue)
{
var pair = new FieldValuePair();
pair.Value = ParseFieldValueValue(fieldValue.Value);
var field = new FieldRef();
field.Guids = fieldValue.Guids?.ToList() ?? new List <Guid>();
field.ArtifactId = fieldValue.ArtifactID;
field.Name = fieldValue.Name;
pair.Field = field;
return(pair);
}
private Variable CreateVariableForField(FieldRef fref)
{
Variable var = new Variable(fref.Type)
{
Name = fref.Name,
LocalIndex = _nextLocIndex++,
InitialValue = fref.FieldDesc.ConstantValue
};
var.AddAttribute(fref);
foreach (var attr in fref.Attributes)
var.AddAttribute(attr);
DeclareLocal(var);
return var;
}
public override void Build()
{
ns("MyNameSpace");
uses("System");
FieldRef TestParam = new FieldRef(my(), "TestParameter");
MethodRef ThisMethod = new MethodRef(my(), "ThisMethod");
declClass(TypePublic, "Class1");
declMethod(MemPublic, "System.Void", "ClassMethod");
enter(ex(ThisMethod, refp(TestParam)));
}
public void CanExtractCalculatedFieldFromListInstance()
{
var template = new ProvisioningTemplate();
var listInstance = new ListInstance();
template.SiteFields.Add(new Core.Framework.Provisioning.Model.Field() { SchemaXml = ElementSchema });
listInstance.Url = string.Format("lists/{0}", listName);
listInstance.Title = listName;
listInstance.TemplateType = (int)ListTemplateType.GenericList;
var referencedField = new FieldRef();
referencedField.Id = fieldId;
listInstance.FieldRefs.Add(referencedField);
var calculatedField = new Core.Framework.Provisioning.Model.Field();
calculatedField.SchemaXml = TokenizedCalculatedFieldElementSchema;
listInstance.Fields.Add(calculatedField);
template.Lists.Add(listInstance);
using (var ctx = TestCommon.CreateClientContext())
{
var parser = new TokenParser(ctx.Web, template);
new ObjectField().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
new ObjectListInstance().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
var list = ctx.Web.GetListByUrl(listInstance.Url);
Assert.IsNotNull(list);
var rf = list.GetFieldById<FieldText>(fieldId);
var f = list.GetFieldById<FieldCalculated>(calculatedFieldId);
Assert.IsNotNull(rf, "Referenced field not added");
Assert.IsNotNull(f);
Assert.IsInstanceOfType(f, typeof(FieldCalculated));
Assert.IsFalse(f.Formula.Contains('#') || f.Formula.Contains('?'), "Calculated field was not provisioned properly");
var extractedTemplate = new ProvisioningTemplate();
var provisioningTemplateCreationInformation = new ProvisioningTemplateCreationInformation(ctx.Web);
new ObjectListInstance().ExtractObjects(ctx.Web, extractedTemplate, provisioningTemplateCreationInformation);
XElement fieldElement = XElement.Parse(extractedTemplate.Lists.First(l => l.Title == listName).Fields.First(cf => Guid.Parse(XElement.Parse(cf.SchemaXml).Attribute("ID").Value).Equals(calculatedFieldId)).SchemaXml);
var formula = fieldElement.Descendants("Formula").FirstOrDefault();
Assert.AreEqual(@"=[{fieldtitle:DemoField}]&""DemoField""", formula.Value, true, "Calculated field formula is not extracted properly");
}
}
/// <summary>
/// Visits a field reference literal. The default implementation saves it to <c>_tlit</c>.
/// </summary>
/// <param name="fieldRef">field reference literal</param>
public virtual void VisitFieldRef(FieldRef fieldRef)
{
_tlit = fieldRef;
}
private FieldInfo ResolveField(Cci.IFieldReference fieldRef)
{
var fieldDef = fieldRef.GetResolvedField(_context);
if (fieldDef != null && IsLocal(fieldRef.GetContainingType(_context)))
{
return _fieldBuilders[fieldDef];
}
FieldInfo result;
if (_fieldRefs.TryGetValue(fieldRef, out result))
{
return result;
}
Type declaringType = ResolveType(fieldRef.GetContainingType(_context));
Cci.ISpecializedFieldReference specializedRef = fieldRef.AsSpecializedFieldReference;
if (specializedRef != null)
{
if (IsLocal(specializedRef.UnspecializedVersion.GetContainingType(_context)))
{
// declaring type is TypeBuilder or TypeBuilderInstantiation since it's defined in the module being built:
FieldBuilder fieldBuilder = _fieldBuilders[(Cci.IFieldDefinition)specializedRef.UnspecializedVersion.AsDefinition(_context)];
result = TypeBuilder.GetField(declaringType, fieldBuilder);
}
else
{
FieldInfo unspecializedDefinition = ResolveField(specializedRef.UnspecializedVersion);
result = new FieldRef(declaringType, fieldRef.Name, unspecializedDefinition.FieldType);
}
}
else
{
GenericContext genericContext;
if (declaringType.IsGenericTypeDefinition)
{
genericContext = new GenericContext(declaringType.GetGenericArguments(), Type.EmptyTypes);
}
else
{
genericContext = default(GenericContext);
}
// TODO: modifiers?
Type fieldType = ResolveType(fieldRef.GetType(_context), genericContext);
result = new FieldRef(declaringType, fieldRef.Name, fieldType);
}
_fieldRefs.Add(fieldRef, result);
return result;
}
public GroupBy(Guid fieldId, bool collapse)
: base("GroupBy")
{
FieldRefs = new FieldRef[] { new FieldRef() { FieldId = fieldId } };
Collapse = collapse;
}
protected SingleFieldOperator(string operatorName, FieldRef fieldRef)
: base(operatorName)
{
FieldRef = fieldRef;
}
private CustomAttributeBuilder CreateCustomAttributeBuilder(Cci.ICustomAttribute attribute)
{
// TODO (tomat): Use CCI to build the blob?
// TODO (tomat): The CustomAttributeBuilder has problems with application of an attribute on itself
// and other dependencies on unbaked types.
// e.g. [My]class MyAttribute : Attribute { }
var ctor = ResolveConstructor(attribute.Constructor(_context));
var attributeType = ctor.DeclaringType;
object[] argValues = new object[attribute.ArgumentCount];
ArrayBuilder<object> propertyValues = null;
ArrayBuilder<object> fieldValues = null;
ArrayBuilder<FieldInfo> fields = null;
ArrayBuilder<PropertyInfo> properties = null;
try
{
int i = 0;
foreach (Cci.IMetadataExpression arg in attribute.GetArguments(_context))
{
argValues[i++] = GetMetadataExpressionValue(arg);
}
foreach (Cci.IMetadataNamedArgument namedArg in attribute.GetNamedArguments(_context))
{
object value = GetMetadataExpressionValue(namedArg.ArgumentValue);
string name = namedArg.ArgumentName;
Type type = ResolveType(namedArg.Type);
if (namedArg.IsField)
{
if (fields == null)
{
fields = ArrayBuilder<FieldInfo>.GetInstance();
fieldValues = ArrayBuilder<object>.GetInstance();
}
var field = new FieldRef(attributeType, name, type);
fields.Add(field);
fieldValues.Add(value);
}
else
{
if (properties == null)
{
properties = ArrayBuilder<PropertyInfo>.GetInstance();
propertyValues = ArrayBuilder<object>.GetInstance();
}
var property = new CustomAttributeProperty(attributeType, name, type);
properties.Add(property);
propertyValues.Add(value);
}
}
try
{
return new CustomAttributeBuilder(
ctor as ConstructorInfo ?? new ConstructorRef(ctor),
argValues,
(properties != null) ? properties.ToArray() : SpecializedCollections.EmptyArray<PropertyInfo>(),
(properties != null) ? propertyValues.ToArray() : SpecializedCollections.EmptyArray<object>(),
(fields != null) ? fields.ToArray() : SpecializedCollections.EmptyArray<FieldInfo>(),
(fields != null) ? fieldValues.ToArray() : SpecializedCollections.EmptyArray<object>());
}
catch (ArgumentException)
{
throw new NotSupportedException("Ref.Emit limitation");
}
}
finally
{
if (properties != null)
{
properties.Free();
propertyValues.Free();
}
if (fields != null)
{
fields.Free();
fieldValues.Free();
}
}
}
public override void VisitFieldRef(FieldRef fieldRef)
{
if (fieldRef.HasAttribute<LocalizeField>())
SetCurrentLiteral(_f2loc[fieldRef]);
else
SetCurrentLiteral(fieldRef);
}
private static Field CreateFieldRef(ListInfo listInfo, Field field, FieldRef fieldRef)
{
field.EnsureProperty(f => f.SchemaXmlWithResourceTokens);
XElement element = XElement.Parse(field.SchemaXmlWithResourceTokens);
element.SetAttributeValue("AllowDeletion", "TRUE");
field.SchemaXml = element.ToString();
var createdField = listInfo.SiteList.Fields.Add(field);
createdField.Context.Load(createdField, cf => cf.Id, cf => cf.Title, cf => cf.Hidden, cf => cf.Required);
createdField.Context.ExecuteQueryRetry();
var isDirty = false;
if (!string.IsNullOrEmpty(fieldRef.DisplayName) && createdField.Title != fieldRef.DisplayName)
{
createdField.Title = fieldRef.DisplayName;
isDirty = true;
}
if (createdField.Hidden != fieldRef.Hidden)
{
createdField.Hidden = fieldRef.Hidden;
isDirty = true;
}
if (createdField.Required != fieldRef.Required)
{
createdField.Required = fieldRef.Required;
isDirty = true;
}
if (isDirty)
{
createdField.Update();
createdField.Context.ExecuteQueryRetry();
}
return createdField;
}
internal static void ReadMember(PEReader buff, TableRow[] members)
{
Contract.Requires(buff != null);
Contract.Requires(members != null);
for (int i = 0; i < members.Length; i++)
{
uint parenIx = buff.GetCodedIndex(CIx.MemberRefParent);
string memName = buff.GetString();
uint sigIx = buff.GetBlobIx();
if (buff.FirstBlobByte(sigIx) == Field.FieldTag) // got a field
members[i] = new FieldRef(parenIx, memName, sigIx);
else
members[i] = new MethodRef(parenIx, memName, sigIx);
}
}
private static void UpdateFieldRef(List siteList, Guid fieldId, FieldRef fieldRef)
{
// find the field in the list
var listField = siteList.Fields.GetById(fieldId);
siteList.Context.Load(listField, f => f.Title, f => f.Hidden, f => f.Required);
siteList.Context.ExecuteQueryRetry();
var isDirty = false;
if (!string.IsNullOrEmpty(fieldRef.DisplayName) && fieldRef.DisplayName != listField.Title)
{
listField.Title = fieldRef.DisplayName;
isDirty = true;
}
if (fieldRef.Hidden != listField.Hidden)
{
listField.Hidden = fieldRef.Hidden;
isDirty = true;
}
if (fieldRef.Required != listField.Required)
{
listField.Required = fieldRef.Required;
isDirty = true;
}
if (isDirty)
{
listField.UpdateAndPushChanges(true);
siteList.Context.ExecuteQueryRetry();
}
}
private static void CreateFieldRef(ListInfo listInfo, Field field, FieldRef fieldRef)
{
XElement element = XElement.Parse(field.SchemaXml);
element.SetAttributeValue("AllowDeletion", "TRUE");
field.SchemaXml = element.ToString();
var createdField = listInfo.SiteList.Fields.Add(field);
if (!string.IsNullOrEmpty(fieldRef.DisplayName))
{
createdField.Title = fieldRef.DisplayName;
}
createdField.Hidden = fieldRef.Hidden;
createdField.Required = fieldRef.Required;
createdField.Update();
createdField.Context.ExecuteQueryRetry();
}
private static Field UpdateFieldRef(List siteList, Guid fieldId, FieldRef fieldRef)
{
// find the field in the list
var listField = siteList.Fields.GetById(fieldId);
siteList.Context.Load(listField, f => f.Id, f => f.Title, f => f.Hidden, f => f.Required);
siteList.Context.ExecuteQueryRetry();
var isDirty = false;
if (!string.IsNullOrEmpty(fieldRef.DisplayName) && fieldRef.DisplayName != listField.Title)
{
listField.Title = fieldRef.DisplayName;
isDirty = true;
}
// We cannot configure Hidden property for Phonetic fields
if (!(siteList.BaseTemplate == (int)ListTemplateType.Contacts &&
(fieldRef.Name.Equals("LastNamePhonetic", StringComparison.InvariantCultureIgnoreCase) ||
fieldRef.Name.Equals("FirstNamePhonetic", StringComparison.InvariantCultureIgnoreCase) ||
fieldRef.Name.Equals("CompanyPhonetic", StringComparison.InvariantCultureIgnoreCase))))
{
if (fieldRef.Hidden != listField.Hidden)
{
listField.Hidden = fieldRef.Hidden;
isDirty = true;
}
}
if (fieldRef.Required != listField.Required)
{
listField.Required = fieldRef.Required;
isDirty = true;
}
if (isDirty)
{
listField.UpdateAndPushChanges(true);
siteList.Context.ExecuteQueryRetry();
}
return listField;
}
public void CanProvisionCalculatedFieldInListInstance()
{
var template = new ProvisioningTemplate();
var listInstance = new ListInstance();
template.SiteFields.Add(new Core.Framework.Provisioning.Model.Field() { SchemaXml = ElementSchema });
listInstance.Url = string.Format("lists/{0}", listName);
listInstance.Title = listName;
listInstance.TemplateType = (int)ListTemplateType.GenericList;
var referencedField = new FieldRef();
referencedField.Id = fieldId;
listInstance.FieldRefs.Add(referencedField);
var calculatedField = new Core.Framework.Provisioning.Model.Field();
calculatedField.SchemaXml = TokenizedCalculatedFieldElementSchema;
listInstance.Fields.Add(calculatedField);
template.Lists.Add(listInstance);
using (var ctx = TestCommon.CreateClientContext())
{
var parser = new TokenParser(ctx.Web, template);
new ObjectField().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
new ObjectListInstance().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
var list = ctx.Web.GetListByUrl(listInstance.Url);
Assert.IsNotNull(list);
var rf = list.GetFieldById<FieldText>(fieldId);
var f = list.GetFieldById<FieldCalculated>(calculatedFieldId);
Assert.IsNotNull(rf, "Referenced field not added");
Assert.IsNotNull(f);
Assert.IsInstanceOfType(f, typeof(FieldCalculated));
Assert.IsFalse(f.Formula.Contains('#') || f.Formula.Contains('?'), "Calculated field was not provisioned properly");
}
}