void ModifySimpleInstanceRecord(InstanceSimple aInstance, String EntityName)
{
aInstance.Record = AddSimpleRecord(aInstance, EntityName);
// Check SemiColon
Token aToken = Lexer.Tokenizer(DataStream);
if (aToken.TokenTypeValue != TokenType.SEMICOLON)
{
Console.WriteLine("Syntax Error at the end of instance #" + aInstance.EntityInstanceName.ToString());
}
}
public ParamEntity(uint value, InstanceDB DataSet)
: base(SParamType.ENTITY)
{
// this fucntion only works with SimpleInstance Populations
if (DataSet.DataList.ContainsKey(value))
{ EntityInstance = DataSet.DataList[value]; }
else
{
EntityInstance = new InstanceSimple(value);
DataSet.DataList.Add((uint)value, EntityInstance);
}
}
public static void TestWriter()
{
var instanceDB = new InstanceDB();
var simpleRecord = new SimpleRecord("IFCORGANIZATION", instanceDB);
simpleRecord.ParameterList.Add(new ParamNullValue());
simpleRecord.ParameterList.Add(new ParamString("Georgia Tech"));
simpleRecord.ParameterList.Add(new ParamNullValue());
simpleRecord.ParameterList.Add(new ParamNullValue());
simpleRecord.ParameterList.Add(new ParamNullValue());
var instanceSimple = new InstanceSimple(10);
instanceSimple.Record = simpleRecord;
instanceDB.DataList.Add(instanceSimple.EntityInstanceName, instanceSimple);
}
InstanceSimple AddSimpleInstance(uint EntityInstanceName, String EntityName)
{
InstanceSimple aInstance = new InstanceSimple(EntityInstanceName);
aInstance.Record = AddSimpleRecord(aInstance, EntityName);
// new SimpleInstance(EntityInstanceName, AddSimpleRecord(EntityName));
// Check SemiColon
Token aToken = Lexer.Tokenizer(DataStream);
if (aToken.TokenTypeValue != TokenType.SEMICOLON)
{
Console.WriteLine("Syntax Error at the end of instance #" + EntityInstanceName.ToString());
}
return(aInstance);
}
void ModifySimpleInstanceRecord(InstanceSimple aInstance, String EntityName)
{
aInstance.Record = AddSimpleRecord(aInstance, EntityName);
// Check SemiColon
Token aToken = Lexer.Tokenizer(DataStream);
if (aToken.TokenTypeValue != TokenType.SEMICOLON)
{
Console.WriteLine("Syntax Error at the end of instance #" + aInstance.EntityInstanceName.ToString());
}
}
InstanceSimple AddSimpleInstance(uint EntityInstanceName, String EntityName)
{
InstanceSimple aInstance = new InstanceSimple(EntityInstanceName);
aInstance.Record = AddSimpleRecord(aInstance, EntityName);
// new SimpleInstance(EntityInstanceName, AddSimpleRecord(EntityName));
// Check SemiColon
Token aToken = Lexer.Tokenizer(DataStream);
if (aToken.TokenTypeValue != TokenType.SEMICOLON)
{
Console.WriteLine("Syntax Error at the end of instance #" + EntityInstanceName.ToString());
}
return aInstance;
}
public static void TestWriter()
{
var instanceDB = new InstanceDB();
var simpleRecord = new SimpleRecord("IFCORGANIZATION", instanceDB);
simpleRecord.ParameterList.Add(new ParamNullValue());
simpleRecord.ParameterList.Add(new ParamString("Georgia Tech"));
simpleRecord.ParameterList.Add(new ParamNullValue());
simpleRecord.ParameterList.Add(new ParamNullValue());
simpleRecord.ParameterList.Add(new ParamNullValue());
var instanceSimple = new InstanceSimple(10);
instanceSimple.Record = simpleRecord;
instanceDB.DataList.Add(instanceSimple.EntityInstanceName, instanceSimple);
}
private void AddSimpleDef(InstanceSimple instanceSimple, SEntity sEntity)
{
var j = 0;
foreach (var t in sEntity.FlatList)
{
if (t is SAttributeInverse) continue;
var parameter = instanceSimple.AttributeList[j];
var sAttribute = t;
AddAttributeDef(parameter, sAttribute);
j++;
}
}
/// <summary>
/// check syntax of instance
/// associate
/// </summary>
/// <param name="logFileName"></param>
private void AssignEntityDefToInstance(string logFileName)
{
using (StreamWriter sWriter = new StreamWriter(logFileName))
{
foreach (KeyValuePair <uint, Instance> kvp in DataList)
{
if (kvp.Value is InstanceSimple)
{
// assign schema entity information to instance
InstanceSimple sInstance = (InstanceSimple)kvp.Value;
SEntity sEntity;
try
{
//p_schemaModel.EntityList.ContainsKey()
sEntity = p_schemaModel.EntityList[sInstance.Keyword];
for (int i = 0; i < sEntity.FlatList.Count; i++)
{
SAttribute sAtt = sEntity.FlatList[i];
sInstance.AttributeList[i].SchemaAttDef = sAtt;
if (sInstance.AttributeList[i].ParameterType == SParamType.SET)
{
var sparam = sAtt.Type as SParamCollection;
var pList = sInstance.AttributeList[i] as ParamList;
foreach (var item in pList.ParameterList)
{
if (sparam != null)
{
item.SchemaAttDef = new SAttribute(null, sparam.ParamReference);
}
else
{
}
}
sInstance.AttributeList[i].updateParameterType(sAtt.Type.ParamType);
}
//{ sInstance.AttributeList[i].updateParameterType(SAttribType.LIST); }
//else if (sAtt.AttributeValue.AttTypeAtSchema == SAttribType.ARRAY)
//{ sInstance.AttributeList[i].updateParameterType(SAttribType.ARRAY); }
//else if (sAtt.AttributeValue.AttTypeAtSchema == SAttribType.BAG)
//{ sInstance.AttributeList[i].updateParameterType(SAttribType.BAG); }
//else if (sAtt.AttributeValue.AttTypeAtSchema == SAttribType.SET)
//{ sInstance.AttributeList[i].updateParameterType(SAttribType.SET); }
//if (sAtt.AttributeValue.AttTypeAtSchema == AttribType.LIST ||
// sAtt.AttributeValue.AttTypeAtSchema == AttribType.ARRAY ||
// sAtt.AttributeValue.AttTypeAtSchema == AttribType.BAG ||
// sAtt.AttributeValue.AttTypeAtSchema == AttribType.SET)
// if (sInstance.AttributeList[i] is ParamList)
// {
// ParamList pList = (ParamList)sInstance.AttributeList[i];
// if (sAtt.AttributeValue is SParamCollection)
// {
// SParamCollection sP = (SParamCollection)sAtt.AttributeValue;
// foreach (Parameter p in pList.ParameterList)
// {
// p.SchemaAttDef = new SAttribute(sP.AttTypeAtSchemaName, sP.CollectionItem);
// }
// }
// else
// {
// SParamNamed spn = (SParamNamed)sAtt.AttributeValue;
// if (spn.NamedAttribute is STypeArray)
// { }
// }
// }
}
}
catch (ArgumentOutOfRangeException)
{
sWriter.WriteLine(
string.Format(
"Instance Syntax error : #{0} = {1}",
sInstance.EntityInstanceName,
sInstance.Keyword));
}
catch (KeyNotFoundException)
{
sWriter.WriteLine(
string.Format(
"Included schema doesn't have definition of {0}",
sInstance.Keyword));
}
}
else if (kvp.Value is InstanceComplex)
{
// need to implement
}
else
{
throw new InvalidDataException(
string.Format("Undefined instantiation of instance at {0} : {1}",
kvp.Value.EntityInstanceName, kvp.Value.Keyword));
}
}
}
}
/// <summary>
/// Process Token
/// </summary>
/// <param name="TokenToAdd"></param>
/// <param name="InstanceData"></param>
/// <param name="DataStream"></param>
void ProcessToken(Token TokenToAdd)
{
switch (TokenToAdd.TokenTypeValue)
{
case TokenType.ISO1030321:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.ISO;
break;
case TokenType.ISO1030321END:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.READY;
break;
case TokenType.HEADER:
Lexer.Tokenizer(DataStream);
//InstanceData.aHeaderSection = new HeaderSection();
currStatus = ParserStatus.HEADER;
break;
case TokenType.ENDSEC:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.ISO;
break;
case TokenType.ENTITYINSTANCENAME:
switch (currStatus)
{
case ParserStatus.DATA:
Token oneToken = Lexer.Tokenizer(DataStream);
if (oneToken.TokenTypeValue != TokenType.EQUAL)
{
Console.WriteLine("Syntax Error in Entity Instance : #" + TokenToAdd.IntegerValue.ToString());
return;
}
oneToken = Lexer.Tokenizer(DataStream);
if (oneToken.TokenTypeValue == TokenType.KEYWORD)
{
SortedDictionary <uint, Instance> toAdd = DataList;
if (toAdd.ContainsKey((uint)TokenToAdd.IntegerValue))
{
// when instance is already created by other caller
//P21Instance a = toAdd[(uint)TokenToAdd.IntegerValue];
InstanceSimple aSimpleInstance = (InstanceSimple)toAdd[(uint)TokenToAdd.IntegerValue];
ModifySimpleInstanceRecord(aSimpleInstance, oneToken.StringValue);
}
else
{
// when it is the first time of parsing entity instance name #???
InstanceSimple aSimpleInstance = AddSimpleInstance((uint)TokenToAdd.IntegerValue, oneToken.StringValue);
toAdd.Add((uint)TokenToAdd.IntegerValue, aSimpleInstance);
}
// adding instances to instanceByType according to instance type
if (InstanceByType.ContainsKey(oneToken.StringValue))
{
List <uint> existingList = InstanceByType[oneToken.StringValue];
existingList.Add((uint)TokenToAdd.IntegerValue);
}
else
{
List <uint> newList = new List <uint>();
newList.Add((uint)TokenToAdd.IntegerValue);
InstanceByType.Add(oneToken.StringValue, newList);
}
}
else if (oneToken.TokenTypeValue == TokenType.LEFTPARENTHESIS)
{
// need update for complex type
SortedDictionary <uint, Instance> toAdd = DataList;
InstanceComplex aComplexInstance = AddComplexInstance((uint)TokenToAdd.IntegerValue);
if (toAdd.ContainsKey((uint)TokenToAdd.IntegerValue))
{
toAdd[(uint)TokenToAdd.IntegerValue] = aComplexInstance;
}
else
{
toAdd.Add((uint)TokenToAdd.IntegerValue, aComplexInstance);
}
}
else
{
Console.WriteLine("Syntax Error at value defintion in Entity Instance : #" + TokenToAdd.IntegerValue.ToString());
return;
}
break;
default:
Console.WriteLine("Parser Error : Not defined parsing condition in Entity Instance Name : " + currStatus);
break;
}
break;
case TokenType.KEYWORD:
switch (currStatus)
{
case ParserStatus.HEADER:
SimpleRecord aSimpleRecord = AddSimpleRecord(null, TokenToAdd.StringValue);
HeaderList.Add(aSimpleRecord);
Lexer.Tokenizer(DataStream); // cleans semicolon at the end of header instance
break;
case ParserStatus.DATA:
Console.WriteLine("Syntax Error : Instance without Entity Instance Name");
break;
default:
Console.WriteLine("Parser Error : Not defined parsing condition in Keyword");
break;
}
break;
case TokenType.DATA:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.DATA;
//theDataSet.aDataSectionList.Add(new DataSection());
break;
default:
Console.WriteLine("not defined condition : " + TokenToAdd.TokenTypeValue.ToString());
break;
}
}
