public int Post([FromBody] NewObject newobject)
{
SqlConnection myConnection = new SqlConnection(WebConfigurationManager.ConnectionStrings["myConnectionString"].ConnectionString);
SqlCommand ObjectsqlCmd = new SqlCommand();
ObjectsqlCmd.CommandType = CommandType.StoredProcedure;
ObjectsqlCmd.CommandText = "ObjectInsert";
ObjectsqlCmd.Parameters.Add(new SqlParameter("@ParentID", newobject.ParentId));
ObjectsqlCmd.Parameters.Add(new SqlParameter("@ClassID", newobject.ClassId));
ObjectsqlCmd.Parameters.Add(new SqlParameter("@ObjectName", newobject.Name));
SqlParameter outputParam = ObjectsqlCmd.Parameters.Add("@ObjectId", SqlDbType.Int);
outputParam.Direction = ParameterDirection.Output;
ObjectsqlCmd.Connection = myConnection;
myConnection.Open();
using (SqlDataReader reader = ObjectsqlCmd.ExecuteReader()) {}
int ObjectId = Convert.ToInt32(outputParam.Value);
foreach (NewAttribute ObjAttr in newobject.Attributes)
{
SqlCommand AttrsqlCmd = new SqlCommand();
AttrsqlCmd.CommandType = CommandType.StoredProcedure;
AttrsqlCmd.CommandText = "ObjectValuesInsert";
AttrsqlCmd.Parameters.Add(new SqlParameter("@ObjectId", ObjectId));
AttrsqlCmd.Parameters.Add(new SqlParameter("@AttributId", ObjAttr.Id));
AttrsqlCmd.Parameters.Add(new SqlParameter("@AttributValue", ObjAttr.Value));
AttrsqlCmd.Connection = myConnection;
AttrsqlCmd.ExecuteNonQuery();
}
myConnection.Close();
return(ObjectId);
}
public void NoClassToCreateObjectTest()
{
String noClassLabel = "No class: Test";
NewObject newObjectStatement = new NewObject();
Mock <ClassName> className = new Mock <ClassName>();
QueryDTO dto = new QueryDTO
{
Result = new DTOQueryResult
{
QueryResultType = ResultType.StringResult,
StringOutput = noClassLabel
},
QueryClass = new Class
{
ClassId = new ClassId {
Id = 1, Name = "Test"
},
Name = "Test"
}
};
className.Setup(cn => cn.Execute(It.IsAny <QueryParameters>())).Returns(dto);
newObjectStatement.Add(className.Object);
QueryParameters parameters = new QueryParameters();
var result = newObjectStatement.Execute(parameters);
Assert.AreEqual(ResultType.StringResult, result.Result.QueryResultType);
Assert.AreEqual(noClassLabel, result.Result.StringOutput);
}
public SemanticAtom Visit(NewObject n)
{
var t = new UtilizedType(n.Name, n.Location);
AddToGlobalUtilization(t, null);
return(null);
}
public static Operand New(Type type, params Operand[] args)
{
ApplicableFunction ctor = OverloadResolver.Resolve(TypeInfo.GetConstructors(type), args);
if (ctor == null)
{
if (args != null && args.Length > 0 && args[0] is TypeLiteral)
{
return(New((args[0] as TypeLiteral).ConstantValue as Type, args.ShiftLeft(1)));
}
Type tt;
if (type.IsGenericType && args.Length == 0)
{
if (Sprixel.Grammar.GenericTypeDefinitionsByGenericTypeNames.TryGetValue(type.FullName, out tt))
{
//var al = new List<IMemberInfo>();
var cc = TypeBuilder.GetConstructor(type, tt.GetConstructor(new Type[0])) as ConstructorInfo;
//al.Add(cc); // todo make this match the types of args
//ctor = OverloadResolver.Resolve(al, args);
var no = new NewObject(ctor, args);
no.OverriddenConstructorInfo = true;
no.ConstructorInfo = cc;
return(no);
}
}
throw new MissingMethodException("Cannot find constructor");
}
return(new NewObject(ctor, args));
}
public void CantCreateObjectOfInterfaceTest()
{
NewObject newObjectStatement = new NewObject();
Mock <ClassName> className = new Mock <ClassName>();
QueryDTO dto = new QueryDTO
{
QueryClass = new Class
{
ClassId = new ClassId {
Id = 1, Name = "Test"
},
Name = "Test",
Interface = true
},
};
className.Setup(cn => cn.Execute(It.IsAny <QueryParameters>())).Returns(dto);
newObjectStatement.Add(className.Object);
QueryParameters parameters = new QueryParameters();
var result = newObjectStatement.Execute(parameters);
Assert.AreEqual(ResultType.StringResult, result.Result.QueryResultType);
Assert.AreEqual(NewObject.cantCreateObjectLabel, result.Result.StringOutput);
}
protected override void VisitNewObject(NewObject node, object data)
{
ParameterValues paramVals =
state.Stack.Perform_CreateObject(node.Constructor);
Exception exc = null;
if (holder.ContainsMethodBody(paramVals.Method))
{
InterpretMethod(holder, holder[paramVals.Method], paramVals, out exc, indent + " ");
}
else
{
paramVals.Invoke(out exc);
}
if (exc == null)
{
AddTask(node.Next);
}
else
{
HandleException(node, exc);
}
}
protected internal override void VisitNewObject(NewObject node, object data)
{
StackTypes stack = data as StackTypes;
Verifier.ProcessCallOrNewobj(node.CtorWithParams, stack, true);
AddTask(node.Next, stack);
}
public void Callback(Node node)
{
if (node is ITypedNode)
{
ITypedNode theNode = node as ITypedNode;
theNode.Type = mapper.Map(theNode.Type);
}
if (node is ManageField)
{
ManageField theNode = node as ManageField;
theNode.Field = mapper.Map(theNode.Field);
}
if (node is MethodBodyBlock)
{
MethodBodyBlock body = node as MethodBodyBlock;
foreach (Variable var in body.Variables)
{
var.Type = mapper.Map(var.Type);
}
body.ReturnType = mapper.Map(body.ReturnType);
}
if (node is CallMethod)
{
CallMethod call = node as CallMethod;
ResidualMethod id = Specialization.GetResidualMethod(call);
if (id != null)
{
MethodBodyBlock mbb = mapper.Holder[id];
node.Options["HasPseudoParameter"] = mapper.HasPseudoParameter(mbb);
call.MethodWithParams = new MethodInfoExtention(mapper.Map(mbb), call.IsVirtCall, mapper.Map(GetParamTypes(mbb, id.IsConstructor)));
}
else
{
call.MethodWithParams = mapper.Map(call.MethodWithParams);
}
}
if (node is NewObject)
{
NewObject newObj = node as NewObject;
ResidualMethod id = Specialization.GetResidualMethod(node);
if (id != null)
{
MethodBodyBlock mbb = mapper.Holder[id];
newObj.CtorWithParams = new MethodInfoExtention(mapper.Map(mbb), false, mapper.Map(GetParamTypes(mbb, id.IsConstructor)));
node.Options["HasPseudoParameter"] = mapper.HasPseudoParameter(mbb);
}
else
{
newObj.CtorWithParams = mapper.Map(newObj.CtorWithParams);
}
}
if (node is CreateDelegate)
{
CreateDelegate crDel = node as CreateDelegate;
//Andrew TODO: Map this node...
}
// Graph should be verified AFTER the metadata is resolved
}
public override AstNode VisitNewObject(NewObject ast)
{
var ctor = GetClrCtor(ast.Type.Type);
m_ilgen.Emit(OpCodes.Newobj, ctor);
return(ast);
}
public static string ToTestString(this NewObject newObject)
{
var targetCall = newObject.Variable?.ToTestString()
?? newObject.FieldAccess?.ToTestString()
?? throw new ArgumentOutOfRangeException(nameof(newObject));
return($"{targetCall} := new {newObject.Type}");
}
private void CreateCircle_Click(object sender, RoutedEventArgs e)
{
NewObject circle = new NewObject(new DrawCircle());
circle.draw(list_txb);
count++;
Console_Txb.Text = "Count of object: " + count.ToString();
}
private void CreateRect_Click(object sender, RoutedEventArgs e)
{
NewObject rect = new NewObject(new DrawRect());
rect.draw(list_txb);
count++;
Console_Txb.Text = "Count of object: " + count.ToString();
}
private void UpdateWorldState(WorldState oldState, WorldState newState)
{
CurrentState = newState;
Update?.Invoke(newState);
foreach (var worldStateObject in DetectNewObjects(oldState, newState))
{
NewObject?.Invoke(worldStateObject);
}
}
CustomAttributeBuilder CreateAttributeBuilder(NewObject s)
{
var args = new object[s.Arguments.Length];
for (int i = 0; i < s.Arguments.Length; i++)
{
args[i] = s.Arguments[i].ConstantValue;
}
return(new CustomAttributeBuilder(_linker.GetConstructor(s.Constructor), args));
}
public override RegisterLabelContext Visit(NewObject newObject)
{
string nextRegister1 = _state.NewRegister, nextRegister2 = _state.NewRegister;
var @class = _globalState.NameToClass[newObject.Type.GetText()];
_llvmGenerator.Emit($"{nextRegister1} = call i8* @mmalloc(i32 {new ClassHelper().GetClassSize(@class)})");
_llvmGenerator.Emit($"{nextRegister2} = bitcast i8* {nextRegister1} to %{newObject.Type.GetText()}*");
_llvmGenerator.Emit(
$"call void @g_{newObject.Type.GetText()}_construct(%{newObject.Type.GetText()}* {nextRegister2})");
return(new RegisterLabelContext(nextRegister2, _state.CurrentLabel, newObject.Type));
}
static void Main(string[] args)
{
dynamic newObject = new NewObject();
var objectToCopy = new ObjectToCopy();
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile<MyProfile>();
});
var mapper = config.CreateMapper();
mapper.Map(objectToCopy, newObject);
// newObject.LU_Ignore = "Original value"
// newObject.DoNotIgnore = "New value"
}
// Update is called once per frame
void Update()
{
FollowCamera();
raio = new Ray(transform.position, transform.forward);//O Raio vai ir na direção em que a câmera aponta.
RaycastHit hit;
if (Physics.Raycast(raio, out hit, 8f))
{
Debug.DrawLine(raio.origin, hit.point);
//Aqui eu começo passando o objeto para uma das variaveis
NewObject = hit.collider.gameObject;
if (NewObject != null)
{
Color _tempC = NewObject.GetComponent <Renderer>().material.color;
if (_tempC.a == 1f)
{
NewObject.GetComponent <Renderer>().material.color = new Color(_tempC.r, _tempC.g, _tempC.b, 0.5f);
}
}
if (LastObject != null)
{
//Caso o objeto que eu estou vendo, seja diferente do objeto que eu estava vendo...
if (LastObject != NewObject)
{
Color _tempC = NewObject.GetComponent <Renderer>().material.color;
if (_tempC.a == 0.5f)
{
NewObject.GetComponent <Renderer>().material.color = new Color(_tempC.r, _tempC.g, _tempC.b, 1f);
}
}
}
LastObject = NewObject;
}
else
{
//Caso eu não detecte nenhum objeto na frente da câmera, eu venho para cá.
if (LastObject != null)
{
//print("Não Colidiu com nada");
Color _tempC = NewObject.GetComponent <Renderer>().material.color;
if (_tempC.a == 0.5f)
{
NewObject.GetComponent <Renderer>().material.color = new Color(_tempC.r, _tempC.g, _tempC.b, 1f);
}
//Se o ultimo Objeto pertencer a Layer Paredes, eu reabilito(?) a mesh.
}
}
}
/// <summary>
/// Stopping this tool will remove the temporary <see cref="P:Northwoods.Go.GoToolCreating.NewObject" /> from
/// the view, if it had not yet been added to the document.
/// </summary>
/// <remarks>
/// This also calls <see cref="M:Northwoods.Go.GoTool.StopTransaction" /> if
/// <see cref="P:Northwoods.Go.GoToolCreating.Modal" /> is false or if <see cref="P:Northwoods.Go.GoToolCreating.OneShot" /> is true.
/// </remarks>
public override void Stop()
{
if (NewObject != null && NewObject.IsInView)
{
NewObject.Remove();
}
NewObject = null;
base.View.StopAutoScroll();
base.View.CursorName = "default";
Active = false;
if (!Modal || OneShot)
{
StopTransaction();
}
}
public void Visit(NewObject n)
{
Globals.Builder.Start($"new {n.RealizedType.Name} [{n.Location.StartLine}, {n.Location.StartColumn}]");
var numToAllocate = (n.RealizedType as Class).NumProperties() + 1;
// Allocate space.
Globals.Builder.AllocateMemory(numToAllocate.ToString(), 8.ToString(), n.Location);
// Move the vtablePointer into the object.
Globals.Builder.WriteBinaryOp("lea", "r10", $"{(n.RealizedType as Class).ClassTableName}");
Globals.Builder.WriteBinaryOp("mov", "[rax]", "r10");
Globals.Builder.End($"new {n.RealizedType.Name} [{n.Location.EndLine}, {n.Location.EndColumn}]");
}
/// <summary>
/// If <see cref="P:Northwoods.Go.GoToolCreating.Modal" /> and not <see cref="P:Northwoods.Go.GoToolCreating.OneShot" />, the current
/// <see cref="P:Northwoods.Go.GoToolCreating.NewObject" /> is removed but this tool remains active to allow
/// further object creations; otherwise this tool is stopped.
/// </summary>
public override void DoCancelMouse()
{
if (Active && Modal && !OneShot)
{
if (NewObject != null && NewObject.IsInView)
{
NewObject.Remove();
}
NewObject = null;
}
else
{
StopTool();
}
}
public override IQueryElement VisitNew_object([NotNull] QueryGrammarParser.New_objectContext context)
{
NewObject newObject = new NewObject();
IQueryElement className = Visit(context.class_name());
newObject.Add(className);
foreach (var element in context.object_initialization_attributes_list().object_initialization_element())
{
IQueryElement objectElement = Visit(element);
newObject.Add(objectElement);
}
return(newObject);
}
public static NewObject[] Copy(this NewObject[] attributes, CopyState state)
{
if (attributes == null)
{
return(null);
}
var result = new NewObject[attributes.Length];
for (int i = 0; i < result.Length; i++)
{
result[i] = (NewObject)attributes[i].CopyExpression(state);
}
return(result);
}
public NewPage(EntityTypes entity, DatabaseWrapper o = null)
{
if (entity == EntityTypes.TitleCompany)
{
Text = "New Title Company";
}
else
{
Text = "New " + entity;
}
TextTitle = Text;
NewObject ctl = new NewObject(entity, o)
{
Dock = System.Windows.Forms.DockStyle.Fill
};
switch (entity)
{
case EntityTypes.Client:
{
ImageSmall = Resources.client_16x16;
ImageLarge = Resources.client;
break;
}
case EntityTypes.Realtor:
{
ImageSmall = Resources.realtor_16x16;
ImageLarge = Resources.realtor;
break;
}
case EntityTypes.TitleCompany:
{
ImageSmall = Resources.title_company_16x16;
ImageLarge = Resources.title_company;
break;
}
}
ctl.StatusUpdate += UpdateMainFormStatus;
Controls.Add(ctl);
}
protected override void VisitNewObject(NewObject downNode, object o)
{
PointerToNode ptrUpNode = (o as Data).PointerToNode;
AnnotatedMethod method = Annotation.GetAnnotatedMethod(downNode);
Node upNode;
ArrayList list = new ArrayList();
for (int i = method.ParamVals.Count - 1; i > 0; i--)
{
if (Annotation.GetValueBTType(method.ParamVals[i].Val) == BTType.Static)
{
list.Add(this.state.Stack.Pop());
}
}
if (Annotation.GetValueBTType(method.ParamVals[0].Val) == BTType.Static)
{
Type objtype = downNode.Constructor.DeclaringType;
ObjectReferenceValue obj = new ObjectReferenceValue(FormatterServices.GetUninitializedObject(objtype));
FieldInfo[] fldInfos = ReflectionUtils.GetAllFields(objtype);
BTType[] btTypes = Annotation.GetObjectFieldBTTypes(downNode);
for (int i = 0; i < fldInfos.Length; i++)
{
if (btTypes[i] == BTType.Dynamic)
{
Variable varUp = this.mbbUp.Variables.CreateVar(fldInfos[i].FieldType, VariableKind.Local);
this.varsHash[new PointerToObjectFieldValue(obj.Obj, fldInfos[i])] = varUp;
ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
}
}
list.Add(obj);
this.state.Stack.Push(obj);
upNode = new CallMethod(downNode.Constructor, false, false);
}
else
{
upNode = new NewObject(downNode.Constructor);
}
list.Reverse();
Value[] args = list.ToArray(typeof(Value)) as Value[];
this.callMethod(downNode, method, ptrUpNode, upNode, args);
}
private string SerializeNewObject(NewObject newObject)
{
string target;
switch (newObject.TargetCase)
{
case NewObject.TargetOneofCase.Variable:
target = SerializeVariable(newObject.Variable);
break;
case NewObject.TargetOneofCase.FieldAccess:
target = SerializeFieldAccess(newObject.FieldAccess);
break;
default:
throw new NotSupportedException(newObject.TargetCase.ToString());
}
return($"{target} := new {newObject.Type}");
}
public static Expression TransformSwizzleToNewObject(this Swizzle s, Namescope scope)
{
// a.XYZ -> (temp = a, new T(temp.X, temp.Y, temp.Z))
// OR new T(a.X, a.Y, a.Z)
var obj = s.Object;
var ind = TryCreateIndirection(scope, ref obj);
var args = new Expression[s.Fields.Length];
for (int i = 0; i < s.Fields.Length; i++)
{
args[i] = new LoadField(s.Source, obj, s.Fields[i]);
}
var result = new NewObject(s.Source, s.Constructor, args);
return(ind != null
? (Expression) new SequenceOp(ind, result)
: result);
}
public DeserializerTransform(
Expression <Func <R, int, object> > deferredDeserialize,
bool inlineNested = true,
Expression <Func <Type, Type, object> > createObject = null,
Expression <Func <Type, Type, int, object> > createContainer = null)
{
this.deferredDeserialize = deferredDeserialize;
if (createObject != null)
{
newObject = (t1, t2) =>
Expression.Convert(
Expression.Invoke(
createObject,
Expression.Constant(t1),
Expression.Constant(t2)),
t1);
}
else
{
newObject = (t1, t2) => New(t1, t2);
}
if (createContainer != null)
{
newContainer = (t1, t2, count) =>
Expression.Convert(
Expression.Invoke(
createContainer,
Expression.Constant(t1),
Expression.Constant(t2),
count),
t1);
}
else
{
newContainer = (t1, t2, count) => New(t1, t2, count);
}
this.inlineNested = inlineNested;
}
public static bool ExpandFilenames(this Compiler compiler, NewObject attribute, PathFlags flags)
{
var result = true;
for (int i = 0; i < attribute.Arguments.Length; i++)
{
if (attribute.Constructor.Parameters[i].HasAttribute(compiler.Essentials.FilenameAttribute))
{
var c = attribute.Arguments[i] as Constant;
if (c == null)
{
result = false;
continue;
}
var filename = c.Value as string;
result = compiler.Disk.GetFullPath(attribute.Arguments[i].Source, ref filename, flags) && result;
c.Value = filename;
}
}
return(result);
}
void CreateFromFile()
{
GameObject NewObject;
for (int i = 0; i < level.editorObjects.Count; i++)
{
if (level.editorObjects[i].objectType == EditorObject.ObjectType.Platform)
{
NewObject = Instantiate(Platform, level.editorObjects[i].pos, Quaternion.identity);
NewObject.layer = 9;
EditorObject eo = NewObject.AddComponent <EditorObject>();
eo.data.pos = NewObject.transform.position;
eo.data.objectType = EditorObject.ObjectType.Platform;
}
else if (level.editorObjects[i].objectType == EditorObject.ObjectType.Coin)
{
NewObject = Instantiate(Coin, level.editorObjects[i].pos, Quaternion.identity);
NewObject.layer = 9;
EditorObject eo = NewObject.AddComponent <EditorObject>();
eo.data.pos = NewObject.transform.position;
eo.data.objectType = EditorObject.ObjectType.Coin;
}
else if (level.editorObjects[i].objectType == EditorObject.ObjectType.Player)
{
NewObject = Instantiate(Player, level.editorObjects[i].pos, Quaternion.identity);
NewObject.layer = 9; // set to Spawned Objects layer
PlayerPlaced = true;
EditorObject eo = NewObject.AddComponent <EditorObject>();
eo.data.pos = NewObject.transform.position;
eo.data.objectType = EditorObject.ObjectType.Player;
}
else if (level.editorObjects[i].objectType == EditorObject.ObjectType.StartPos)
{
NewObject = Instantiate(StartPos, level.editorObjects[i].pos, Quaternion.identity);
NewObject.layer = 9; // set to Spawned Objects layer
StartpointPresent = true;
EditorObject eo = NewObject.AddComponent <EditorObject>();
eo.data.pos = NewObject.transform.position;
eo.data.objectType = EditorObject.ObjectType.StartPos;
}
else if (level.editorObjects[i].objectType == EditorObject.ObjectType.EndPos)
{
NewObject = Instantiate(EndPos, level.editorObjects[i].pos, Quaternion.identity);
NewObject.layer = 9; // set to Spawned Objects layer
EndPointPlaced = true;
EditorObject eo = NewObject.AddComponent <EditorObject>();
eo.data.pos = NewObject.transform.position;
eo.data.objectType = EditorObject.ObjectType.EndPos;
}
}
LoadlevelName.text = "";
LoadlevelName.DeactivateInputField();
SaveLoadMessage.text = " Level Loading done";
}
public override AstNode VisitNewObject(NewObject ast)
{
var ctor = GetClrCtor(ast.Type.Type);
m_ilgen.Emit(OpCodes.Newobj, ctor);
return ast;
}
public override AstNode VisitNewObject(NewObject ast)
{
ast.ExpressionType = ResolveTypeRef(ast.Type);
return(ast);
}
public override AstNode VisitNewObject(NewObject ast)
{
ast.ExpressionType = ResolveTypeRef(ast.Type);
return ast;
}
