/// <summary>
/// For a root variable we create a special variable which holds onto the initial value, and
/// also will get loaded at the correct time.
/// </summary>
/// <param name="expr"></param>
/// <param name="codeEnv"></param>
/// <returns></returns>
public IValue ProcessConstantReference(ConstantExpression expr, IGeneratedQueryCode codeEnv, CompositionContainer container)
{
///
/// The value is a reference that will do the loading.
///
var rootObject = expr.Value as ROOTNET.Interface.NTNamed;
if (rootObject == null)
{
throw new ArgumentException("the object to be stored must derive from NTNamed! It is of type '" + expr.Value.GetType().Name + "' which does not appear to derive from TNamed.");
}
//
// Queue this object for transfer, get a "unique" name back. This will also double check
// to see if the object is already up there read to be queued.
//
var varNameForTransport = codeEnv.QueueForTransfer(rootObject);
//
// Now, we need to generate an IValue for the object that can be used in our expression parsing.
// When in the middle of a tight loop, since finding the object is a "slow" linear lookup, we will cache it in a static
// variable. This isn't so pretty when there is a one-time initialization, but it shouldn't add too much.
//
var staticCache = new ROOTObjectStaticHolder(rootObject.GetType(), rootObject);
staticCache.DeclareAsStatic = true;
staticCache.InitialValue = new ValSimple("nullptr", staticCache.Type);
codeEnv.Add(staticCache);
codeEnv.Add(new Statements.StatementFilter(new ValSimple($"{staticCache.RawValue} == nullptr", typeof(bool), new IDeclaredParameter[] { staticCache })));
var CPPType = rootObject.GetType().AsCPPType();
var val = new ROOTObjectCopiedValue(varNameForTransport, rootObject.GetType(), CPPType, rootObject.Name, rootObject.Title);
codeEnv.Add(new Statements.StatementAssign(staticCache, val));
codeEnv.Pop();
// And the rest of the code should use the static cache.
return(staticCache);
}