protected override object ImportFromNumber(ImportContext context, JsonReader reader)
{
double num;
object obj2;
string text = reader.Text;
try
{
num = Convert.ToDouble(text, CultureInfo.InvariantCulture);
}
catch (FormatException exception)
{
throw NumberError(exception, text);
}
catch (OverflowException exception2)
{
throw NumberError(exception2, text);
}
try
{
obj2 = ImporterBase.ReadReturning(reader, UnixTime.ToDateTime(num));
}
catch (ArgumentException exception3)
{
throw NumberError(exception3, text);
}
return obj2;
}
protected override object ImportFromString(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
return ReadReturning(reader, reader.Text);
}
protected override object ImportFromObject(ImportContext context, JsonReader reader)
{
reader.Read();
object target = Activator.CreateInstance(base.OutputType);
INonObjectMemberImporter importer = target as INonObjectMemberImporter;
while (reader.TokenClass != JsonTokenClass.EndObject)
{
string name = reader.ReadMember();
PropertyDescriptor descriptor = this._properties.Find(name, true);
if ((descriptor == null) || descriptor.IsReadOnly)
{
if ((importer == null) || !importer.Import(context, name, reader))
{
reader.Skip();
}
}
else
{
if (this._importers != null)
{
int index = this._properties.IndexOf(descriptor);
IObjectMemberImporter importer2 = this._importers[index];
if (importer2 != null)
{
importer2.Import(context, reader, target);
continue;
}
}
descriptor.SetValue(target, context.Import(descriptor.PropertyType, reader));
}
}
return ImporterBase.ReadReturning(reader, target);
}
protected override object ImportFromString(ImportContext context, JsonReader reader)
{
object obj2;
try
{
Match match = Regex.Match(reader.Text, @"\A \/ Date \( ([0-9]+) \) \/ \z", RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase);
if (match.Success)
{
DateTime time;
try
{
time = UnixTime.ToDateTime((double) (((double) long.Parse(match.Groups[1].Value, NumberStyles.None, CultureInfo.InvariantCulture)) / 1000.0));
}
catch (OverflowException exception)
{
throw StringError(exception);
}
return ImporterBase.ReadReturning(reader, time);
}
obj2 = ImporterBase.ReadReturning(reader, XmlConvert.ToDateTime(reader.Text, XmlDateTimeSerializationMode.Local));
}
catch (FormatException exception2)
{
throw StringError(exception2);
}
return obj2;
}
private object ImportScalarAsArray(ImportContext context, JsonReader reader)
{
Type elementType = base.OutputType.GetElementType();
Array array = Array.CreateInstance(elementType, 1);
array.SetValue(context.Import(elementType, reader), 0);
return array;
}
protected override object ImportFromNumber(ImportContext context, JsonReader reader)
{
object obj2;
if (context == null)
{
throw new ArgumentNullException("context");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
string text = reader.Text;
try
{
obj2 = ImporterBase.ReadReturning(reader, this.ConvertFromString(text));
}
catch (FormatException exception)
{
throw this.NumberError(exception, text);
}
catch (OverflowException exception2)
{
throw this.NumberError(exception2, text);
}
return obj2;
}
protected override object ImportValue(ImportContext context, JsonReader reader)
{
if (context == null)
throw new ArgumentNullException("reader");
if (reader == null)
throw new ArgumentNullException("reader");
if (reader.TokenClass != JsonTokenClass.Number && reader.TokenClass != JsonTokenClass.String)
throw new JsonException(string.Format("Found {0} where expecting a number.", reader.TokenClass));
string text = reader.Text;
try
{
return ConvertFromString(text);
}
catch (FormatException e)
{
throw NumberError(e, text);
}
catch (OverflowException e)
{
throw NumberError(e, text);
}
}
protected override object ImportValue(ImportContext context, JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
bool value;
if (reader.TokenClass == JsonTokenClass.Number)
{
try
{
value = Convert.ToInt64(reader.Text, CultureInfo.InvariantCulture) != 0;
}
catch (FormatException e)
{
throw new JsonException(string.Format("The JSON Number {0} must be an integer to be convertible to System.Boolean.", reader.Text), e);
}
}
else if (reader.TokenClass == JsonTokenClass.Boolean)
{
value = reader.Text == JsonBoolean.TrueText;
}
else
{
throw new JsonException(string.Format("Found {0} where expecting a JSON Boolean.", reader.TokenClass));
}
return value ? BooleanObject.True : BooleanObject.False;
}
protected override object ImportFromNumber(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
string text = reader.Text;
double time;
try
{
time = Convert.ToDouble(text, CultureInfo.InvariantCulture);
}
catch (FormatException e)
{
throw NumberError(e, text);
}
catch (OverflowException e)
{
throw NumberError(e, text);
}
try
{
return ReadReturning(reader, UnixTime.ToDateTime(time));
}
catch (ArgumentException e)
{
throw NumberError(e, text);
}
}
protected override object ImportFromBoolean(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
return BooleanObject.Box(reader.ReadBoolean());
}
public void Execute()
{
this.result.CloseWindow = false;
this.result.DataChanged = true;
ImportContext context = new ImportContext(this);
if (this.EnsureFileLoaded())
{
this.actionIndex = 0;
foreach (var action in this.actions)
{
try
{
action.DoImport(this.objectSet, context);
}
catch (Exception ex)
{
this.log.AppendFormat("发生错误:{0} 已终止了操作,堆栈:\r\n{1}\r\n", ex.Message, ex.StackTrace);
break;
}
this.actionIndex++;
}
}
this.log.AppendLine("导入操作结束");
this.status.CurrentStep = this.status.MaxStep;
this.status.StatusText = "结束";
this.status.Response();
this.result.ProcessLog = this.log.ToString();
}
protected override object ImportFromObject(ImportContext context, JsonReader reader)
{
if (context == null)
throw new ArgumentNullException("context");
if (reader == null)
throw new ArgumentNullException("reader");
//
// Reader must be sitting on an object.
//
if (reader.TokenClass != JsonTokenClass.Object)
throw new JsonException("Expecting object.");
reader.Read();
//
// Create the NameValueCollection object being deserialized.
// If a hint was supplied, then that's what we will create
// here because it could be that the caller wants to
// return a subtype of NameValueCollection.
//
NameValueCollection collection = CreateCollection();
//
// Loop through all members of the object.
//
while (reader.TokenClass != JsonTokenClass.EndObject)
{
string name = reader.ReadMember();
//
// If the value is an array, then it's a multi-value
// entry otherwise a single-value one.
//
if (reader.TokenClass == JsonTokenClass.Array)
{
reader.Read();
while (reader.TokenClass != JsonTokenClass.EndArray)
{
collection.Add(name, GetValueAsString(reader));
reader.Read();
}
}
else
{
collection.Add(name, GetValueAsString(reader));
}
reader.Read(); // EndArray/String
}
return ReadReturning(reader, collection);
}
public void CreateObject()
{
ObjectSurrogateConstructor ctor = new ObjectSurrogateConstructor(typeof(Surrogate));
ImportContext context = new ImportContext();
ObjectConstructionResult result = ctor.CreateObject(context, JsonText.CreateReader("{y:2000,m:12,d:4}"));
Assert.IsNotNull(result);
Assert.AreEqual(new DateTime(2000, 12, 4), result.Object);
}
protected override object ImportFromObject(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
reader.Read();
object obj = Activator.CreateInstance(OutputType);
INonObjectMemberImporter otherImporter = obj as INonObjectMemberImporter;
while (reader.TokenClass != JsonTokenClass.EndObject)
{
string memberName = reader.ReadMember();
PropertyDescriptor property = _properties.Find(memberName, true);
//
// Skip over the member value and continue with reading if
// the property was not found or if the property found cannot
// be set.
//
if (property == null || property.IsReadOnly)
{
if (otherImporter == null || !otherImporter.Import(context, memberName, reader))
reader.Skip();
continue;
}
//
// Check if the property defines a custom import scheme.
// If yes, ask it to import the value into the property
// and then continue with the next.
//
if (_importers != null)
{
int index = _properties.IndexOf(property);
IObjectMemberImporter importer = _importers[index];
if (importer != null)
{
importer.Import(context, reader, obj);
continue;
}
}
//
// Import from reader based on the property type and
// then set the value of the property.
//
property.SetValue(obj, context.Import(property.PropertyType, reader));
}
return ReadReturning(reader, obj);
}
private static void AssertImport(object expected, string input)
{
JsonTextReader reader = new JsonTextReader(new StringReader(input));
Type expectedType = expected.GetType();
ImportContext context = new ImportContext();
object o = context.Import(expectedType, reader);
Assert.IsInstanceOfType(expectedType, o);
Assert.AreEqual(expected, o);
}
public virtual object Import(ImportContext context, JsonReader reader)
{
if (context == null)
throw new ArgumentNullException("context");
if (reader == null)
throw new ArgumentNullException("reader");
return JsonBuffer.From(reader);
}
protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
{
if (String.IsNullOrEmpty(fieldNode.InnerXml))
{
this.SetData(null);
return;
}
this.SetData(ConvertTo(new object[] { fieldNode.InnerXml }));
}
protected override object ImportFromArray(ImportContext context, JsonReader reader)
{
if (_single)
return _importer(context, reader);
reader.Read();
var result = _importer(context, reader);
reader.ReadToken(JsonTokenClass.EndArray);
return result;
}
protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
{
if (String.IsNullOrEmpty(fieldNode.InnerXml))
{
this.SetData(ActiveSchema.DateTimeMinValue);
return;
}
DateTime value = Convert.ToDateTime(fieldNode.InnerXml);
this.SetData(value < ActiveSchema.DateTimeMinValue ? ActiveSchema.DateTimeMinValue : value);
}
protected override object ImportFromArray(ImportContext context, JsonReader reader)
{
reader.Read();
MemoryStream stream = new MemoryStream();
Type type = typeof(byte);
while (reader.TokenClass != JsonTokenClass.EndArray)
{
stream.WriteByte((byte) context.Import(type, reader));
}
return ImporterBase.ReadReturning(reader, stream.ToArray());
}
private object ImportValue(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
return reader.TokenClass == JsonTokenClass.Object
? ImportFromObject(context, reader)
: reader.TokenClass == JsonTokenClass.Array
? ImportArray(context, reader)
: context.Import(AnyType.Value, reader);
}
protected override object ImportFromArray(ImportContext context, JsonReader reader)
{
reader.Read();
ArrayList list = new ArrayList();
Type elementType = base.OutputType.GetElementType();
while (reader.TokenClass != JsonTokenClass.EndArray)
{
list.Add(context.Import(elementType, reader));
}
return ImporterBase.ReadReturning(reader, list.ToArray(elementType));
}
public void CreateObject()
{
object obj = new object();
Surrogate surrogate = new Surrogate(obj);
ImportContext context = new ImportContext();
ObjectConstructionResult result = surrogate.CreateObject(context);
Assert.AreSame(obj, result.Object);
JsonReader tail = result.TailReader;
tail.ReadToken(JsonTokenClass.Object);
tail.ReadToken(JsonTokenClass.EndObject);
}
protected override object ImportFromString(ImportContext context, JsonReader reader)
{
try
{
return Convert.FromBase64String(reader.ReadString());
}
catch (FormatException e)
{
throw new JsonException("Error converting JSON String containing base64-encode data to " + OutputType.FullName + ".", e);
}
}
private object ImportArray(ImportContext context, JsonReader reader)
{
reader.ReadToken(JsonTokenClass.Array);
List<object> list = new List<object>();
while (reader.TokenClass != JsonTokenClass.EndArray)
{
list.Add(this.ImportValue(context, reader));
}
reader.Read();
return new ReadOnlyCollection<object>(list);
}
protected override object ImportValue(ImportContext context, JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (reader.TokenClass != JsonTokenClass.String &&
reader.TokenClass != JsonTokenClass.Number &&
reader.TokenClass != JsonTokenClass.Boolean)
throw new JsonException(string.Format("Found {0} where expecting a JSON String.", reader.TokenClass));
return reader.Text;
}
public void Import()
{
JsonRecorder writer = new JsonRecorder();
writer.WriteStartArray();
writer.WriteString("foo");
writer.WriteString("bar");
writer.WriteEndArray();
JsonReader reader = writer.CreatePlayer();
ImportContext context = new ImportContext();
IList list = (IList) context.Import(typeof(IList), reader);
Assert.AreEqual(new object[] { "foo", "bar" }, CollectionHelper.ToArray(list));
}
protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
{
string value = fieldNode.InnerXml;
if (value.Trim() == String.Empty)
return;
var values = new List<string>(value.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries));
// dobsonl: this causes problem when importing choicefield values if option value starts with " "
// -> corresponding option value cannot be found if field value is trimmed
//for (int i = 0; i < values.Count; i++)
// values[i] = values[i].Trim();
SetData(values);
}
private object ImportArray(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
reader.ReadToken(JsonTokenClass.Array);
var list = new List<object>();
while (reader.TokenClass != JsonTokenClass.EndArray)
list.Add(ImportValue(context, reader));
reader.Read();
return new ReadOnlyCollection<object>(list);
}
protected override object ImportFromObject(ImportContext context, JsonReader reader)
{
if (context == null) throw new ArgumentNullException("context");
if (reader == null) throw new ArgumentNullException("reader");
reader.ReadToken(JsonTokenClass.Object);
var expando = (IDictionary<string, object>) new ExpandoObject();
while (reader.TokenClass != JsonTokenClass.EndObject)
expando[reader.ReadMember()] = ImportValue(context, reader);
reader.Read();
return expando;
}
protected override object ImportFromNumber(ImportContext context, JsonReader reader)
{
return(ReflectImport(context, reader));
}
protected virtual object ImportFromArray(ImportContext context, JsonReader reader)
{
return(ThrowNotSupported(JsonTokenClass.Array));
}
protected override object ImportFromString(ImportContext context, JsonReader reader)
{
return(ImportScalarAsArray(context, reader));
}
private object ImportUnderlyingType(ImportContext context, JsonReader reader)
{
Debug.Assert(context != null);
Debug.Assert(reader != null);
return(context.Import(_underlyingType, reader));
}
public XmlSchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, System.CodeDom.Compiler.CodeDomProvider codeProvider, ImportContext context)
{
}
//static bool ContainsMeshesRecursive( Node node )
//{
// if( node.HasMeshes )
// return true;
// foreach( var child in node.Children )
// {
// if( ContainsMeshesRecursive( child ) )
// return true;
// }
// return false;
//}
public static void DoImport(Settings settings, out string error)
{
error = "(NO ERROR MESSAGE)";
LoadNativeLibrary();
FbxManager manager = null;
FbxIOSettings setting = null;
FbxImporter importer = null;
FbxScene scene = null;
try
{
manager = FbxManager.Create();
setting = FbxIOSettings.Create(manager, "IOSRoot");
manager.SetIOSettings(setting);
importer = FbxImporter.Create(manager, "");
var realFileName = VirtualPathUtility.GetRealPathByVirtual(settings.virtualFileName);
//VirtualFileStream stream = null;
//ToDo : FromStream
bool status;
if (!string.IsNullOrEmpty(realFileName) && File.Exists(realFileName))
{
status = importer.Initialize(realFileName, -1, setting);
}
else
{
error = "File is not exists.";
return;
//throw new NotImplementedException();
//ToDo : ....
//stream = VirtualFile.Open( settings.virtualFileName );
//FbxStream fbxStream = null;
//SWIGTYPE_p_void streamData = null;
//status = impoter.Initialize( fbxStream, streamData, -1, setting );
}
if (!status)
{
return;
}
scene = FbxScene.Create(manager, "scene1");
status = importer.Import(scene);
if (!status)
{
return;
}
error = "";
var importContext = new ImportContext();
importContext.manager = manager;
importContext.scene = scene;
importContext.settings = settings;
importContext.directoryName = Path.GetDirectoryName(settings.virtualFileName);
ImportScene(importContext);
////create meshes (Scene mode)
//if( settings.component.Mode.Value == Component_Import3D.ModeEnum.Scene /*&& scene.HasMeshes && scene.MeshCount != 0 */)
//{
// importContext.meshesGroup = settings.component.GetComponentByName( "Meshes" ) as Component_Mesh;
// if( importContext.meshesGroup == null )
// {
// importContext.meshesGroup = settings.component.CreateComponent<Component>( -1, false );
// importContext.meshesGroup.Name = "Meshes";
// }
// else
// importContext.meshesGroup.Enabled = false;
//}
////enable groups
//if( importContext.meshesGroup != null )
// importContext.meshesGroup.Enabled = true;
//if( importContext.sceneObjectsGroup != null )
// importContext.sceneObjectsGroup.Enabled = true;
//stream?.Dispose();
}
finally
{
//Особенности удаления.
//Создается через функцию: impoter = FbxImporter.Create(manager, "");
//В таких случаях(создание не через конструктор, а возврат указателя из функции) SWIG задает флажок что объект не владеет ссылкой, поэтому Dispose ничего не делает.
//Хотя в SWIG можно задать в конфигурации: %newobject FbxImporter::Create; Тогда объект будет владеть ссылкой. Но все равно в С++ наследники FbxObject не имеют public destructor
//поэтому в Dispose вставлен: throw new MethodAccessException("C++ destructor does not have public access"). Поэтому удалять только через Destroy.
try { scene?.Destroy(); } catch { }
try { importer?.Destroy(); } catch { }
try { setting?.Destroy(); } catch { }
try { manager?.Destroy(); } catch { }
}
}
protected override Task <StageResult> GetResultAsyncInternal(ImportContext context)
{
base.Action();
return(Task.FromResult(new StageResult(null)));
}
protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
{
this.SetData(new List <string>(new string[] { fieldNode.InnerXml }));
}
static void Run()
{
var impctx = new ImportContext();
//
// Import a strongly-typed collection of integers...
//
impctx.Register(new ListImporter <int>());
var numbers = (List <int>)impctx.Import(typeof(List <int>),
JsonText.CreateReader("[ 1, 2, 3 ]"));
numbers.ForEach(Console.WriteLine);
Console.WriteLine();
//
// Import a Shape object containing a strongly-typed collection of
// Point objects.
//
impctx.Register(new ListImporter <Point>());
var shape = (Shape)impctx.Import(typeof(Shape), JsonText.CreateReader(@"{
name: 'square',
points: [
{ x: 10, y: 10 },
{ x: 20, y: 10 },
{ x: 20, y: 20 },
{ x: 10, y: 20 }
]
}"));
JsonConvert.Export(shape, CreatePrettyWriter(Console.Out));
Console.WriteLine();
//
// Import CookieCollection using duck-typing. In other words,
// as long as CookieCollection walks and quacks like a
// collection of Cookie elements then it's good enough for
// DuckCollectionImporter. DuckCollectionImporter can infer
// that CookieCollection contains Cookie elements.
//
impctx.Register(new DuckCollectionImporter(typeof(CookieCollection)));
const string cookiesText = @"[
{ name: 'one', value: 1, expires: '2099-01-02' },
{ name: 'two', value: 2, expires: '2088-03-04' },
{ name: 'three', value: 3, expires: '2077-05-06' }
]";
var cookies = (CookieCollection)impctx.Import(typeof(CookieCollection), JsonText.CreateReader(cookiesText));
JsonConvert.Export(cookies, CreatePrettyWriter(Console.Out));
Console.WriteLine();
//
// Now repeat, but replace with a new CookieCollection importer
// that is identical in behavior but based on generics. Here,
// the difference is that DuckCollectionImporter<,> does not
// have to guess the element type as it is provided as a type
// argument.
//
impctx.Register(new DuckCollectionImporter <CookieCollection, Cookie>());
cookies = (CookieCollection)impctx.Import(typeof(CookieCollection), JsonText.CreateReader(cookiesText));
JsonConvert.Export(cookies, CreatePrettyWriter(Console.Out));
Console.WriteLine();
//
// Those Cookie objects have a lot of properties. Say our JSON
// text only needs a subset. Here, we register an exporter that
// provides a custom view of the type. We only expose the name,
// value and expiration time. What's more, we rename the
// Expires property so that it appears as "expiration" in JSON.
//
var expctx = new ExportContext();
JsonType.
BuildFor(typeof(Cookie)).
AddProperty("Name").
AddProperty("Value").
AddProperty("Expires").As("expiration").
Register(expctx);
expctx.Export(cookies, CreatePrettyWriter(Console.Out));
Console.WriteLine();
}
/// <summary>
///
/// </summary>
/// <param name="xsdFilename"></param>
/// <param name="targetNamespace"></param>
/// <returns></returns>
public static CodeNamespace Process(string xsdFilename, string targetNamespace)
{
XmlReaderSettings settings = new XmlReaderSettings
{
};
XmlSchema xsd;
using (var reader = XmlReader.Create(xsdFilename))
{
xsd = XmlSchema.Read(reader, MyValidationEventHandler);
}
XmlSchemas schemas = new XmlSchemas(); // Internal class
int elementCount = xsd.Elements.Count; // 0 Elements is a post-schema-compilation property
int indexOf = schemas.Add(xsd); // Method will only add (to end) if it does not exists, and return the one stored internally
elementCount = xsd.Elements.Count; // 1 OOOPS! Looks like Add do some magic to added XmlSchema
schemas.Compile(MyValidationEventHandler, true); // What is fullCompile?
//var appinfos = xsd.Items.OfType<XmlSchemaAnnotation>().SelectMany(a => a.Items.OfType<XmlSchemaAppInfo>().SelectMany(m => m.Markup)).ToList();
//foreach (var attr in xsd.UnhandledAttributes)
//{
// Console.WriteLine("UnhandledAttribute: " + attr.LocalName);
//}
// Create the importer for these schemas.
CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("CSharp"); // shared import & export
CodeGenerationOptions options = CodeGenerationOptions.GenerateProperties; // shared import & export
CodeIdentifiers typeIdentifiers = new CodeIdentifiers();
ImportContext context = new ImportContext(typeIdentifiers, true); // true=share custom types amongst schemas
XmlSchemaImporter importer = new XmlSchemaImporter(schemas, options, context);
// System.CodeDom namespace for the XmlCodeExporter to put classes in.
CodeNamespace ns = new CodeNamespace(targetNamespace);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
Hashtable mappings = new Hashtable();
XmlCodeExporter exporter = new XmlCodeExporter(ns, codeCompileUnit, options, mappings);
// Test identifier uniqueness
string s = "FirstName";
var ustr = typeIdentifiers.MakeUnique(s); // FirstName
ustr = typeIdentifiers.MakeUnique(s); // FirstName
typeIdentifiers.Add(s, s);
ustr = typeIdentifiers.MakeUnique(s); // FirstName1
typeIdentifiers.Remove(s);
ustr = typeIdentifiers.MakeUnique(s); // FirstName
typeIdentifiers.Add(s, s);
// Iterate schema top-level elements and export code for each.
foreach (XmlSchemaElement element in xsd.Elements.Values)
{
//var appinfos = element.Annotation.Items.OfType<XmlSchemaAppInfo>().ToArray();
// Import the mapping first.
var ss = typeIdentifiers.ToArray(typeof(string)); // 1
XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
ss = typeIdentifiers.ToArray(typeof(string)); // 2
// Export the code finally.
int count = mappings.Count; // 0
exporter.ExportTypeMapping(mapping);
count = mappings.Count; // 5
}
foreach (var schemaType in xsd.SchemaTypes.Values.Cast <XmlSchemaType>())
{
var map2 = importer.ImportSchemaType(schemaType.QualifiedName);
string s2 = map2.TypeFullName;
}
return(ns);
}
public MethodReference ImportMethodReference(MethodReference method, ImportContext context)
{
return(method);
}
public FieldReference ImportFieldReference(FieldReference field, ImportContext context)
{
return(field);
}
protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
{
throw new NotSupportedException("The ImportData operation is not supported on LockField.");
}
protected override object ImportFromObject(ImportContext context, JsonReader reader)
{
return(ImportUnderlyingType(context, reader));
}
protected void btnImport_Click(object sender, EventArgs e)
{
if (!fileUploadAirportList.HasFile)
{
return;
}
if (!ckShowAllUserAirports.Checked)
{
gvMyAirports.DataSource = null;
gvMyAirports.DataBind();
}
ImportContext ic = new ImportContext();
using (CSVReader csvReader = new CSVReader(fileUploadAirportList.FileContent))
{
try
{
ic.InitFromHeader(csvReader.GetCSVLine(true));
}
catch (CSVReaderInvalidCSVException ex)
{
lblUploadErr.Text = ex.Message;
return;
}
catch (MyFlightbookException ex)
{
lblUploadErr.Text = ex.Message;
return;
}
List <airportImportCandidate> lst = ImportedAirportCandidates;
lst.Clear();
string[] rgCols = null;
while ((rgCols = csvReader.GetCSVLine()) != null)
{
airportImportCandidate aic = new airportImportCandidate();
aic.FAA = GetCol(rgCols, ic.iColFAA).Replace("-", "");
aic.IATA = GetCol(rgCols, ic.iColIATA).Replace("-", "");
aic.ICAO = GetCol(rgCols, ic.iColICAO).Replace("-", "");
aic.Name = GetCol(rgCols, ic.iColName);
aic.FacilityTypeCode = GetCol(rgCols, ic.iColType);
if (String.IsNullOrEmpty(aic.FacilityTypeCode))
{
aic.FacilityTypeCode = "A"; // default to airport
}
aic.Name = GetCol(rgCols, ic.iColName);
aic.Code = "(TBD)";
string szLat = GetCol(rgCols, ic.iColLatitude);
string szLon = GetCol(rgCols, ic.iColLongitude);
string szLatLong = GetCol(rgCols, ic.iColLatLong);
aic.LatLong = null;
if (!String.IsNullOrEmpty(szLatLong))
{
// see if it is decimal; if so, we'll fall through.
if (Regex.IsMatch(szLatLong, "[NEWS]", RegexOptions.IgnoreCase))
{
aic.LatLong = DMSAngle.LatLonFromDMSString(GetCol(rgCols, ic.iColLatLong));
}
else
{
string[] rgsz = szLatLong.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (rgsz.Length == 2)
{
szLat = rgsz[0];
szLon = rgsz[1];
}
}
}
if (aic.LatLong == null)
{
aic.LatLong = new LatLong();
double d;
if (double.TryParse(szLat, out d))
{
aic.LatLong.Latitude = d;
}
else
{
aic.LatLong.Latitude = new DMSAngle(szLat).Value;
}
if (double.TryParse(szLon, out d))
{
aic.LatLong.Longitude = d;
}
else
{
aic.LatLong.Longitude = new DMSAngle(szLon).Value;
}
}
lst.Add(aic);
}
UpdateCandidateStatus(lst);
bool fHideKHack = util.GetIntParam(Request, "khack", 0) == 0;
lst.RemoveAll(aic => aic.IsOK || (fHideKHack && aic.IsKHack));
gvImportResults.DataSource = lst;
gvImportResults.DataBind();
pnlImportResults.Visible = true;
}
}
protected override object ImportFromBoolean(ImportContext context, JsonReader reader)
{
return(BooleanObject.Box(reader.ReadBoolean()));
}
protected override object ImportFromString(ImportContext context, JsonReader reader)
{
return(reader.ReadString());
}
static void ImportScene(ImportContext context)
{
var settings = context.settings;
var scene = context.scene;
if (context.settings.component.ForceFrontXAxis)
{
//Через такой конструктор не получится создать такие же оси как EPreDefinedAxisSystem.eMax - Front Axis имеет обратное направление, а направление задать нельзя.
//new FbxAxisSystem( FbxAxisSystem.EUpVector.eZAxis, FbxAxisSystem.EFrontVector.eParityOdd, FbxAxisSystem.ECoordSystem.eRightHanded );
//FromFBX Docs:
//The enum values ParityEven and ParityOdd denote the first one and the second one of the remain two axes in addition to the up axis.
//For example if the up axis is X, the remain two axes will be Y And Z, so the ParityEven is Y, and the ParityOdd is Z ;
//We desire to convert the scene from Y-Up to Z-Up. Using the predefined axis system: Max (UpVector = +Z, FrontVector = -Y, CoordSystem = +X (RightHanded))
var maxAxisSystem = new FbxAxisSystem(FbxAxisSystem.EPreDefinedAxisSystem.eMax);
if (!scene.GetGlobalSettings().GetAxisSystem().eq(maxAxisSystem))
{
maxAxisSystem.ConvertScene(scene); //No conversion will take place if the scene current axis system is equal to the new one. So condition can be removed.
}
}
//convert units
if (!scene.GetGlobalSettings().GetSystemUnit().eq(FbxSystemUnit.m))
{
FbxSystemUnit.m.ConvertScene(scene);
}
//get materials data
var materialsData = GetMaterialsData(context);
//create Materials group
context.materialsGroup = context.settings.component.GetComponent("Materials");
if (context.materialsGroup == null && materialsData.Count != 0 && settings.updateMaterials)
{
context.materialsGroup = context.settings.component.CreateComponent <Component>();
context.materialsGroup.Name = "Materials";
}
//create materials
foreach (var data in materialsData)
{
Component_Material material = null;
if (context.settings.updateMaterials)
{
material = CreateMaterial(context.materialsGroup, data);
}
else
{
if (context.materialsGroup != null)
{
material = context.materialsGroup.GetComponent(data.Name) as Component_Material;
}
}
if (material != null)
{
context.materialByIndex.Add(data.Index, material);
}
}
//-------------------------
var additionalTransform = new Matrix4(settings.component.Rotation.Value.ToMatrix3() * Matrix3.FromScale(settings.component.Scale), settings.component.Position);
var options = new ImportOptions
{
NormalsOptions = NormalsAndTangentsLoadOptions.FromFileIfPresentOrCalculate,
TangentsOptions = NormalsAndTangentsLoadOptions.FromFileIfPresentOrCalculate,
ImportPostProcessFlags = ImportPostProcessFlags.FixInfacingNormals
};
options.ImportPostProcessFlags |= ImportPostProcessFlags.SmoothNormals | ImportPostProcessFlags.SmoothTangents;
if (context.settings.component.FlipUVs)
{
options.ImportPostProcessFlags |= ImportPostProcessFlags.FlipUVs;
}
var sceneLoader = new SceneLoader();
var mode = settings.component.Mode.Value;
if (mode == Component_Import3D.ModeEnum.Auto)
{
mode = Component_Import3D.ModeEnum.OneMesh;
}
//create one mesh (OneMesh mode)
if (mode == Component_Import3D.ModeEnum.OneMesh && settings.updateMeshes)
{
sceneLoader.Load(scene, context.manager, options, additionalTransform);
Component_Skeleton skeletonComponent = CreateSkeletonComponent(context, sceneLoader.Skeleton, out int[] newIndexFromOldIndex, out SkeletonBone[] oldBoneFromNewIndex, additionalTransform);
protected override object ImportFromNumber(ImportContext context, JsonReader reader)
{
return(reader.ReadNumber());
}
protected override void ImportData(System.Xml.XmlNode fieldNode, ImportContext context)
{
this.SetData(fieldNode.InnerXml);
}
protected override object ImportFromBoolean(ImportContext context, JsonReader reader)
{
return(ImportFromString(context, reader));
}
public override object OnCreateObject(ImportContext context)
{
return(_obj);
}
protected virtual object ImportNull(ImportContext context, JsonReader reader)
{
reader.Read();
return(null);
}
protected virtual object ImportFromBoolean(ImportContext context, JsonReader reader)
{
return(ThrowNotSupported(JsonTokenClass.Boolean));
}
void IObjectMemberImporter.Import(ImportContext context, JsonReader reader, object target)
{
ImportArgs = new[] { context, reader, target };
ImportedValue = context.Import(typeof(object), reader);
_sequence.Add(this);
}
protected override void ImportData(XmlNode fieldNode, ImportContext context)
{
throw new NotImplementedException("The ImportData operation is not implemented on ImageField.");
}
public void YahooNewsSearch()
{
var text = @"
/* Source: http://api.search.yahoo.com/NewsSearchService/V1/newsSearch?appid=YahooDemo&query=yahoo&results=3&language=en&output=json */
{
'ResultSet': {
'totalResultsAvailable': '2393',
'totalResultsReturned': 3,
'firstResultPosition': '1',
'Result': [
{
'Title': 'Yahoo invites its users to shoot ads',
'Summary': ' Yahoo first encouraged consumers to create blogs and photo pages with text and pictures. Now, the Internet portal wants them to make advertisements, too. On Monday, Yahoo touts a new look for its front page by asking people to pull out the video camera, open up the editing software and create 12-second spot for Yahoo.',
'Url': 'http://news.yahoo.com/s/usatoday/20060717/tc_usatoday/yahooinvitesitsuserstoshootads',
'ClickUrl': 'http://news.yahoo.com/s/usatoday/20060717/tc_usatoday/yahooinvitesitsuserstoshootads',
'NewsSource': 'USATODAY.com via Yahoo! News',
'NewsSourceUrl': 'http://news.yahoo.com/',
'Language': 'en',
'PublishDate': '1153133816',
'ModificationDate': '1153134044'
},
{
'Title': 'Yahoo to launch new finance features',
'Summary': ' Yahoo Inc. is beefing up the finance section of its Web site with more interactive stock charts and other features to help it maintain its longtime lead over rival financial information sites.',
'Url': 'http://news.yahoo.com/s/ap/20060717/ap_on_hi_te/yahoo_finance_2',
'ClickUrl': 'http://news.yahoo.com/s/ap/20060717/ap_on_hi_te/yahoo_finance_2',
'NewsSource': 'AP via Yahoo! News',
'NewsSourceUrl': 'http://news.yahoo.com/',
'Language': 'en',
'PublishDate': '1153134777',
'ModificationDate': '1153134920',
'Thumbnail': {
'Url': 'http://us.news2.yimg.com/us.yimg.com/p/ap/20060714/vsthumb.8b1161b66b564adba0a5bbd6339c9379.media_summit_idet125.jpg',
'Height': '82',
'Width': '76'
}
},
{
'Title': 'Yahoo Finance revises charts, chat, other features',
'Summary': ' Yahoo Inc. on Monday will unveil an upgraded version of its top-ranked financial information site that features new stock charting tools, improved investor chat rooms and financial video news.',
'Url': 'http://news.yahoo.com/s/nm/20060717/wr_nm/media_yahoo_finance_dc_2',
'ClickUrl': 'http://news.yahoo.com/s/nm/20060717/wr_nm/media_yahoo_finance_dc_2',
'NewsSource': 'Reuters via Yahoo! News',
'NewsSourceUrl': 'http://news.yahoo.com/',
'Language': 'en',
'PublishDate': '1153113288',
'ModificationDate': '1153113674'
}
]
}
}";
var reader = new JsonTextReader(new StringReader(text));
var context = new ImportContext();
var response = (YahooResponse)context.Import(typeof(YahooResponse), reader);
Assert.IsNotNull(response);
var resultSet = response.ResultSet;
Assert.IsNotNull(resultSet);
Assert.AreEqual(2393, resultSet.totalResultsAvailable);
Assert.AreEqual(3, resultSet.totalResultsReturned);
Assert.AreEqual(1, resultSet.firstResultPosition);
Assert.AreEqual(3, resultSet.Result.Length);
var result = resultSet.Result[0];
Assert.IsNotNull(result);
Assert.AreEqual("Yahoo invites its users to shoot ads", result.Title);
Assert.AreEqual(" Yahoo first encouraged consumers to create blogs and photo pages with text and pictures. Now, the Internet portal wants them to make advertisements, too. On Monday, Yahoo touts a new look for its front page by asking people to pull out the video camera, open up the editing software and create 12-second spot for Yahoo.", result.Summary);
Assert.AreEqual("http://news.yahoo.com/s/usatoday/20060717/tc_usatoday/yahooinvitesitsuserstoshootads", result.Url);
Assert.AreEqual("http://news.yahoo.com/s/usatoday/20060717/tc_usatoday/yahooinvitesitsuserstoshootads", result.ClickUrl);
Assert.AreEqual("USATODAY.com via Yahoo! News", result.NewsSource);
Assert.AreEqual("http://news.yahoo.com/", result.NewsSourceUrl);
Assert.AreEqual("en", result.Language);
Assert.AreEqual(1153133816, result.PublishDate);
Assert.AreEqual(1153134044, result.ModificationDate);
result = resultSet.Result[1];
Assert.AreEqual("Yahoo to launch new finance features", result.Title);
Assert.AreEqual(" Yahoo Inc. is beefing up the finance section of its Web site with more interactive stock charts and other features to help it maintain its longtime lead over rival financial information sites.", result.Summary);
Assert.AreEqual("http://news.yahoo.com/s/ap/20060717/ap_on_hi_te/yahoo_finance_2", result.Url);
Assert.AreEqual("http://news.yahoo.com/s/ap/20060717/ap_on_hi_te/yahoo_finance_2", result.ClickUrl);
Assert.AreEqual("AP via Yahoo! News", result.NewsSource);
Assert.AreEqual("http://news.yahoo.com/", result.NewsSourceUrl);
Assert.AreEqual("en", result.Language);
Assert.AreEqual(1153134777, result.PublishDate);
Assert.AreEqual(1153134920, result.ModificationDate);
Assert.AreEqual("http://us.news2.yimg.com/us.yimg.com/p/ap/20060714/vsthumb.8b1161b66b564adba0a5bbd6339c9379.media_summit_idet125.jpg", result.Thumbnail.Url);
Assert.AreEqual(82, result.Thumbnail.Height);
Assert.AreEqual(76, result.Thumbnail.Width);
result = resultSet.Result[2];
Assert.AreEqual("Yahoo Finance revises charts, chat, other features", result.Title);
Assert.AreEqual(" Yahoo Inc. on Monday will unveil an upgraded version of its top-ranked financial information site that features new stock charting tools, improved investor chat rooms and financial video news.", result.Summary);
Assert.AreEqual("http://news.yahoo.com/s/nm/20060717/wr_nm/media_yahoo_finance_dc_2", result.Url);
Assert.AreEqual("http://news.yahoo.com/s/nm/20060717/wr_nm/media_yahoo_finance_dc_2", result.ClickUrl);
Assert.AreEqual("Reuters via Yahoo! News", result.NewsSource);
Assert.AreEqual("http://news.yahoo.com/", result.NewsSourceUrl);
Assert.AreEqual("en", result.Language);
Assert.AreEqual(1153113288, result.PublishDate);
Assert.AreEqual(1153113674, result.ModificationDate);
}
void IJsonImportable.Import(ImportContext context, JsonReader reader)
{
Import(context, reader);
}
public TypeReference ImportTypeReference(TypeReference type, ImportContext context)
{
return(type);
}
static void Main(string[] args)
{
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.ReferencedAssemblies.AddRange(new[] { "System", "System.Xml.Serialization" });
var schemaSet = new XmlSchemaSet(); // reprocess and compile as much as we want
schemaSet.Add(null, @"xsd/mystatus.xsd"); // will add the others
schemaSet.Compile();
var mybaseSchema = schemaSet.Schemas("http://tempuri.org/mybase.xsd").OfType <XmlSchema>().Single();
var myderivedSchema = schemaSet.Schemas("http://tempuri.org/myderived.xsd").OfType <XmlSchema>().Single();
var mystatusSchema = schemaSet.Schemas("http://tempuri.org/mystatus.xsd").OfType <XmlSchema>().Single();
//ReplaceBaseWithBasesBase(myderivedSchema);
schemaSet.Reprocess(myderivedSchema);
schemaSet.Compile();
var xmlSysImport = new CodeNamespaceImport("System");
var xmlNsImport = new CodeNamespaceImport("System.Xml.Serialization");
var mybaseNs = new CodeNamespace("MyBase");
var myDerivedNs = new CodeNamespace("MyDerived")
{
Imports = { xmlSysImport, xmlNsImport, new CodeNamespaceImport(mybaseNs.Name) }
};
var myStatusNs = new CodeNamespace("MyStatus")
{
Imports = { xmlSysImport, xmlNsImport, new CodeNamespaceImport(myDerivedNs.Name) }
};
ccu.Namespaces.AddRange(new[] { mybaseNs, myDerivedNs, myStatusNs });
var schemas = new XmlSchemas();
foreach (XmlSchema schema in schemaSet.Schemas())
{
schemas.Add(schema);
}
//schemas.Compile(ValidationEventHandler, true); // can't change model after compile! XmlSchamaSet.Reprocess handle this!
schemas.Compile(ValidationEventHandler, true);
CodeIdentifiers typeIdentifiers = new CodeIdentifiers(true);
ImportContext context = new ImportContext(typeIdentifiers, shareTypes: false);
CodeGenerationOptions options = CodeGenerationOptions.GenerateOrder;
var providerOptions = new Dictionary <string, string>();
var provider = new CSharpCodeProvider(providerOptions);
XmlSchemaImporter importer = new XmlSchemaImporter(schemas, options, provider, context); // for xml schemas
importer.Extensions.Clear();
//importer.Extensions.Add(new MyImporterExtension());
Hashtable mappings = new Hashtable();
MapTypes(mybaseSchema, importer, mybaseNs, ccu, provider, options, mappings);
MapTypes(myderivedSchema, importer, myDerivedNs, ccu, provider, options, mappings);
MapTypes(mystatusSchema, importer, myStatusNs, ccu, provider, options, mappings);
//XmlCodeExporter exporter = new XmlCodeExporter(myStatusNs, ccu, CodeGenerationOptions.GenerateOrder);
//foreach (XmlSchemaElement element in mystatusSchema.Elements.Values)
//{
// XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
// exporter.ExportTypeMapping(mapping);
//}
using (StreamWriter writer = File.CreateText(@"..\..\..\TestGeneratedCode\status.cs"))
{
//globalNs.Comments.Clear();
//globalNs.Name = "MyGlobal";
provider.GenerateCodeFromCompileUnit(ccu, writer, new CodeGeneratorOptions {
BracingStyle = "C", BlankLinesBetweenMembers = false
});
}
Console.WriteLine("Press enter");
Console.ReadLine();
}
