public void Submit(FBApi api, Mapping target)
{
Log.Verbose(LogCategory, "Submitting new or updated error information to server", null);
// Start by looking for the fingerprint to decide whether we need
// to create an new case or update an existing one.
Dictionary<string, string> args = new Dictionary<string, string>
{
{"sScoutDescription", Error.Fingerprint},
};
string results = api.Cmd("listScoutCase", args);
XmlDocument xml = new XmlDocument();
xml.LoadXml(results);
XmlNode caseNode = xml.SelectSingleNode("/response/case/ixBug");
if (caseNode == null)
{
Log.Information(LogCategory, "Submitting as new issue because no existing Scout Case could be found with the fingerprint", "Fingerprint: {0}\r\n\r\nRaw Result:\r\n{1}", Error.Fingerprint, results);
SubmitNew(api, target);
}
else
{
Log.Information(LogCategory, "Submitting as an update because an existing Scout Case matched the fingerprint", "Fingerprint: {0}\r\n\r\nRaw Result:\r\n{1}", Error.Fingerprint, results);
SubmitUpdate(api, caseNode.InnerText);
}
}
public PocoComponentTuplizer(Mapping.Component component) : base(component)
{
componentClass = component.ComponentClass;
var parentProperty = component.ParentProperty;
if (parentProperty == null)
{
parentSetter = null;
parentGetter = null;
}
else
{
parentSetter = parentProperty.GetSetter(componentClass);
parentGetter = parentProperty.GetGetter(componentClass);
}
if (hasCustomAccessors || !Cfg.Environment.UseReflectionOptimizer)
{
optimizer = null;
}
else
{
optimizer = Cfg.Environment.BytecodeProvider.GetReflectionOptimizer(componentClass, getters, setters);
}
}
public Interface(Mapping.Interface iface, DataCenter[] dataCenters = null, IpAddress[] ips = null)
{
this.Id = iface.Id;
this.DataCenterId = iface.DataCenterId;
if (dataCenters != null)
this.DataCenter = dataCenters.SingleOrDefault(d => d.Id == iface.DataCenterId);
this.Created = iface.Created;
this.LastUpdated = iface.LastUpdated;
if (iface.Num != null)
this.Index = Convert.ToInt32(iface.Num);
this.Status = Converter.ToInterfaceStatus(iface.State);
this.Bandwidth = iface.Bandwidth;
this.Type = Converter.ToInterfaceType(iface.Type);
if (iface.VirtualMachineId != null)
this.VirtualMachineId = Convert.ToInt32(iface.VirtualMachineId);
this.VirtualMachine = null;
this.IpAddressIds = iface.IpAddressIds;
if (ips != null)
{
List<IpAddress> ipList = new List<IpAddress>();
foreach (int ipId in iface.IpAddressIds)
{
IpAddress ipAddress = ips.SingleOrDefault(i => i.Id == ipId);
if (ipAddress.Interface == null)
ipAddress.Interface = this;
ipList.Add(ipAddress);
}
this.IpAddresses = ipList.ToArray();
}
}
public MappingEntry(Mapping mapping, ExcelWorksheet sourceWorksheet, int index)
{
var contentMapping = mapping as ContentMapping;
var movableMapping = mapping as MovableMapping;
var cellMapping = mapping as CellMapping;
var formulaMapping = mapping as FormulaMapping;
if (contentMapping != null)
Value = contentMapping.GetValue();
else if (movableMapping != null)
Value = movableMapping.GetValue(index, sourceWorksheet);
else if (cellMapping != null)
Value = cellMapping.GetValue(sourceWorksheet);
else if (formulaMapping != null)
{
IsFormula = true;
Value = formulaMapping.GetValue();
}
else
throw new InvalidOperationException("Nieznany rodzaj próbki.");
Mapping = mapping;
if (mapping.IsDateColumnMapping() && Value != null)
Value = ExcelHelper.ToDate(Value, Mapping.Sample.Card.DateFormats.ToArray());
}
public OneToManyPersister(Mapping.Collection collection, ICacheConcurrencyStrategy cache, Configuration cfg, ISessionFactoryImplementor factory)
: base(collection, cache, cfg, factory)
{
_cascadeDeleteEnabled = collection.Key.IsCascadeDeleteEnabled && factory.Dialect.SupportsCascadeDelete;
_keyIsNullable = collection.Key.IsNullable;
_keyIsUpdateable = collection.Key.IsUpdateable;
}
public BasicCollectionPersister(
Mapping.Collection collection,
ICacheConcurrencyStrategy cache,
ISessionFactoryImplementor factory)
: base(collection, cache, factory)
{
}
public bool Execute(string directory, Mapping mapToRun, BuildData buildData)
{
try
{
DeploymentHost host = new DeploymentHost();
Runspace space = RunspaceFactory.CreateRunspace(host);
space.Open();
this.PopulateVariables(space, mapToRun, buildData);
string command = this.GeneratePipelineCommand(directory, mapToRun);
this._scriptRun = command;
this.EnsureExecutionPolicy(space);
Pipeline pipeline = space.CreatePipeline(command);
Collection<PSObject> outputObjects = pipeline.Invoke();
if (pipeline.PipelineStateInfo.State != PipelineState.Failed)
{
this._errorOccured = false;
}
string output = this.GenerateOutputFromObjects(outputObjects);
this._output = output;
space.Close();
}
catch (Exception ex)
{
this._errorOccured = true;
this._output = ex.ToString();
}
return this.ErrorOccured;
}
public void RegisterMapping(ICompilerInputContract contract, ICompilerInputContractMapping dataRowContractMapping)
{
var properties = contract.Properties.Select(p => new CompilerInputContractProperty(p)).ToList();
var fieldMappings = dataRowContractMapping.Mapping.ToList();
var ixPropertyNames = new HashSet<string>(this.m_columnInfos.Select(c => c.ColumnName), StringComparer.OrdinalIgnoreCase);
//if (fieldMappings.Count > properties.Count)
//{
// m_compilerOutputBuilder.AddError(
// m_compilerNotificationMessageBuilder.TooFewTableTypeInterfaceMappingItems(m_fullName, contract.InterfaceName, properties.Count, fieldMappings.Count));
//}
var unexpectedColumnMappingNames = fieldMappings.Where(m => !(this.m_ixColumnNames.Contains(m.DataFieldName)));
var mapping = new Mapping<DataColumnInfo, CompilerInputContractProperty>(
dataRowContractMapping
.Mapping
.ToDictionary(m => m.DataFieldName, m => m.ContractPropertyName, StringComparer.Ordinal));
var pairs = mapping.Map(this.m_columnInfos, properties);
foreach (var pair in pairs)
{
this.m_interfaceMappings.Add(
new CompilerOutputInterfacePropertyMapping
{
InterfaceName = dataRowContractMapping.InterfaceName,
ColumnName = pair.Source.ColumnName,
PropertyName = pair.Target.PropertyName,
PropertyType = pair.Target.PropertyType
});
}
}
public DialogResult EditMapping(Dictionary<string, List<String>> productsAndApplications,
Dictionary<string, List<String>> projectsAndAreas,
Dictionary<int, string> priorities,
Mapping existingMapping)
{
Text = EditMappingTitle;
m_ProductsAndApplications = productsAndApplications;
m_ProjectsAndAreas = projectsAndAreas;
m_Priorities = priorities;
DisplayProductsAndApplications();
DisplayPriorities();
DisplayProjectsAndAreas();
//display the current mapping values
ProductSelection.Text = existingMapping.Product;
ApplicationSelection.Text = existingMapping.Application;
txtVersions.Text = existingMapping.Versions;
ProjectSelection.SelectedItem = existingMapping.Project;
AreaSelection.SelectedItem = existingMapping.Area;
PrioritySelection.SelectedValue = existingMapping.Priority;
DialogResult result = ShowDialog();
if (result == DialogResult.OK)
{
UpdateData(existingMapping);
}
return result;
}
/// <summary>
/// Generates a VersionProperty representation for an entity mapping given its
/// version mapping Property.
/// </summary>
/// <param name="property">The version mapping Property.</param>
/// <param name="lazyAvailable">Is property lazy loading currently available.</param>
/// <returns>The appropriate VersionProperty definition.</returns>
public static VersionProperty BuildVersionProperty(Mapping.Property property, bool lazyAvailable)
{
String mappedUnsavedValue = ((IKeyValue) property.Value).NullValue;
VersionValue unsavedValue = UnsavedValueFactory.GetUnsavedVersionValue(
mappedUnsavedValue,
GetGetter(property),
(IVersionType) property.Type,
GetConstructor(property.PersistentClass)
);
bool lazy = lazyAvailable && property.IsLazy;
return new VersionProperty(
property.Name,
property.NodeName,
property.Value.Type,
lazy,
property.IsInsertable,
property.IsUpdateable,
property.Generation == PropertyGeneration.Insert || property.Generation == PropertyGeneration.Always,
property.Generation == PropertyGeneration.Always,
property.IsOptional,
property.IsUpdateable && !lazy,
property.IsOptimisticLocked,
property.CascadeStyle,
unsavedValue
);
}
public DialogResult AddMapping(Dictionary<string, List<String>> productsAndApplications,
Dictionary<string, List<String>> projectsAndAreas,
Dictionary<int, string> priorities,
out Mapping newMapping)
{
Text = AddMappingTitle;
m_ProductsAndApplications = productsAndApplications;
m_ProjectsAndAreas = projectsAndAreas;
m_Priorities = priorities;
newMapping = null;
DisplayProductsAndApplications();
DisplayPriorities();
DisplayProjectsAndAreas();
DialogResult result = ShowDialog();
if (result == DialogResult.OK)
{
newMapping = new Mapping();
UpdateData(newMapping);
}
return result;
}
public SqlMapperTransformer(Mapping mapping, Evaluant.Uss.Models.Model model)
{
_Mapping = mapping;
_Model = model;
_ExprLevel = new Stack();
_AliasColumnMapping = new Hashtable();
_IsAliasColumnComputed = false;
// Add "Type" and "Id" field. Avoid duplicated field if mapping model contains these two keyword fields.
// _AliasColumnMapping.Add("Type", "Type");
foreach (EntityMapping em in mapping.Entities)
{
if (em.DiscriminatorField == null || em.DiscriminatorField == string.Empty)
continue;
if (_AliasColumnMapping.ContainsKey(em.DiscriminatorField))
continue;
_AliasColumnMapping.Add(em.DiscriminatorField, em.DiscriminatorField);
}
//_AliasColumnMapping.Add("Id", "Id");
}
public void mappings_can_be_added()
{
var converter = new MapConverter();
var mapping = new Mapping("from", "to");
converter.Mappings.Add(mapping);
Assert.True(converter.Mappings.Contains(mapping));
}
protected override string BuildTableScript(Mapping.IEntityMapping mapping)
{
var tableName = GetTableName(mapping);
var sb = new StringBuilder(512);
sb.Append("CREATE TABLE ").Append(tableName).Append("(");
int num = 0;
foreach (var f in mapping.Members.Where(p => !p.IsRelationship && !p.IsComputed))
{
if (num > 0)
sb.Append(",");
sb.AppendLine();
sb.Append("\t").Append(Dialect.Quote(f.ColumnName));
var sqlType = f.SqlType;
sb.Append(" ").Append(GetDbType(f.SqlType));
if (sqlType.Required || f.IsPrimaryKey)
sb.Append(" NOT NULL");
if (f.IsGenerated)
sb.Append(GetDefaultValue(f, sqlType));
num++;
}
sb.AppendLine()
.Append(")");
sb.AppendLine("");
return sb.ToString();
}
/// <summary>
/// Add a specific resource.
/// </summary>
/// <param name="path">Path (Uri) requested by clients</param>
/// <param name="assembly">Assembly that the resources exist in</param>
/// <param name="rootNameSpace">Name space to root folder under (all name spaces below the specified one are considered as folders)</param>
/// <param name="fullResourceName">Name space and name of resource.</param>
/// <example>
/// <code>
/// Add("/", Assembly.GetExecutingAssembly(), "MyApplication.Files", "Myapplication.Files.Images.MyImage.png");
/// </code>
/// </example>
public void Add(string path, Assembly assembly, string rootNameSpace, string fullResourceName)
{
if (!path.EndsWith("/"))
path += "/";
var mapping = new Mapping { Assembly = assembly, FullResourceName = fullResourceName };
string filePath = fullResourceName.Remove(0, rootNameSpace.Length + 1);
int extensionPos = filePath.LastIndexOf(".", StringComparison.Ordinal);
if (extensionPos == -1)
return;
int nextPos = filePath.LastIndexOf(".", extensionPos - 1, StringComparison.Ordinal);
if (nextPos != -1)
{
string typeExtension = filePath.Substring(nextPos + 1, extensionPos - nextPos - 1);
if (typeExtension == "xml" || typeExtension == "json" || typeExtension == "js")
mapping.TypeExtension = typeExtension;
}
if (string.IsNullOrEmpty(mapping.TypeExtension))
nextPos = extensionPos;
// TODO: next thing is to set the language. But not today.
// /users/list.1053.xml.spark <--- language 1053, view for xml, spark is the view engine.
filePath = filePath.Substring(0, nextPos).Replace(".", "/") + filePath.Substring(extensionPos);
mapping.FileName = Path.GetFileName(filePath).ToLower();
mapping.UriPath = (path + filePath).Replace('\\', '/').ToLower();
_logger.Trace("Adding mapping '" + path + filePath + "' to resource '" + fullResourceName + "' assembly '" + assembly + "'.");
_mappings.Add(path.ToLower() + filePath.ToLower(), mapping);
}
static void Init()
{
string[] wrk = "C,D,E,F,G,H,I,J,K,L,M,N,O.P,Q,R,S,T,U,V,W,X,Y,Z,C1,D1,E1,F1,G1,H1,I1,J1,K1,L1,M1,N1,O.P1,Q1,R1,S1,T1,U1,V1,W1,X1,Y1,Z1,".Split(new char[] {','});
mFS = new Mapping[wrk.Length];
for (int i = 0; i < wrk.Length; i++) mFS[i] = new Mapping(wrk[i]);
doneInit = true;
}
public SqlMapperPersistenceEngine(string connectionString, IDriver driver, DBDialect dialect, Mapping mapping, ArrayList cacheEntries, Models.Model model)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString");
}
if (driver == null)
{
throw new ArgumentNullException("driver");
}
if (dialect == null)
{
throw new ArgumentNullException("dialect");
}
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
this.Driver = driver;
this.Dialect = dialect;
this._Mapping = mapping;
this._Connection = this._Driver.CreateConnection(connectionString);
if (_Connection is Evaluant.Uss.Data.FileClient.FileConnection)
{
((Evaluant.Uss.Data.FileClient.FileConnection)_Connection).Dialect = dialect;
}
base._Model = model;
this._CacheEntries = cacheEntries;
this.Initialize();
}
public string FindMappingFile(string filename, Mapping mapType)
{
var sb = new StringBuilder(Material.TextureNameBufferLength);
this.FindMappingFile(sb, filename, mapType);
return sb.ToString();
}
public static Mapping FromDescriptor(dynamic spec)
{
Mapping mapping = new Mapping();
mapping.Backend = spec.ContainsKey("Backend") ? spec["Backend"] : null;
mapping.Frontend = spec.ContainsKey("Frontend") ? spec["Frontend"] : null;
mapping.Options = spec.ContainsKey("Options") ? spec["Options"] : null;
return mapping;
}
public void Setup()
{
mainPanel = MockRepository.GenerateStub<IMainPanel>();
form = MockRepository.GenerateMock<IMappingForm>();
mapping = MockRepository.GenerateStub<Mapping>();
mapping.MappingSet = new MappingSetImpl();
//presenter = new MappingPresenter(mainPanel, form);
}
public void ctor_that_takes_from_and_to_sets_from_and_to()
{
var from = new object();
var to = new object();
var mapping = new Mapping(from, to);
Assert.Same(from, mapping.From);
Assert.Same(to, mapping.To);
}
public ManyToManyAttribute( Type childType, Mapping.Loading loading, Cascade cascade )
: base()
{
this.ChildReturnType = childType;
this.Linked = true;
this.Loading = loading;
this.Cascade = cascade;
}
/// <summary>
/// Instantiates a new instance of the <see cref="T:ManyToManyAttribute"/> defining a many to many relationship.
/// </summary>
/// <param name="childTable">The table name of the child.</param>
/// <param name="linkingTable">The table name of the linking table between the parent and child.</param>
/// <param name="childType">The <see cref="T:Type"/> of child.</param>
/// <param name="loading">The <see cref="T:Loading"/> behavior to use for this member.</param>
public ManyToManyAttribute( string childTable, string linkingTable, Type childType, Mapping.Loading loading )
: base()
{
this.ChildReturnType = childType;
this.Name = childTable;
this.Linked = true;
this.LinkName = linkingTable;
this.Loading = loading;
}
private void AddCollectionSecondPass(XmlNode node, Mapping.Collection model)
{
mappings.AddSecondPass(delegate(IDictionary<string, PersistentClass> persistentClasses)
{
PreCollectionSecondPass(model);
BindCollectionSecondPass(node, model, persistentClasses);
PostCollectionSecondPass(model);
});
}
public void TestMappings()
{
var stud = POCOFactory.GenerateSingleStudent();
//AutoMapper.Mapper.CreateMap<Student, StudentDTO>();
//var dto = AutoMapper.Mapper.Map<Student, StudentDTO>(stud);
var mapper = new Mapping();
var dto = mapper.MapEntity<StudentDTO, Student>(stud);
Assert.IsNotNull(dto);
}
public void from_assigns_given_value()
{
var mapping = new Mapping();
var from = new object();
mapping.From = from;
Assert.Same(from, mapping.From);
mapping.From = null;
Assert.Null(mapping.From);
}
public void Setup()
{
modification = new UseFieldForAssociationStorage(property => "foo");
mapping = new CustomerMapping();
mapping.HasMany(x => x.Orders);
mapping.HasOne(x => x.Company);
mapping.BelongsTo(x => x.Company);
mapping.HasOne(x => x.Company).Storage("baz");
}
public static void TestMapping(Mapping mapping, ITable table, Entity entity)
{
Assert.That(mapping.FromTable, Is.SameAs(table));
Assert.That(mapping.ToEntity, Is.SameAs(entity));
Assert.That(mapping.FromColumns.Count, Is.EqualTo(1));
Assert.That(mapping.ToProperties.Count, Is.EqualTo(1));
Assert.That(mapping.FromColumns[0], Is.SameAs(table.Columns[0]));
Assert.That(mapping.ToProperties[0], Is.EqualTo(entity.Properties.ElementAt(0)));
}
public InterfaceOperation(Mapping.InterfaceOperation operation, Interface iface, IpAddress ipAddress = null)
: base(operation)
{
this.InterfaceId = operation.InterfaceId;
this.Interface = iface;
this.IpAddressId = operation.IpAddressId;
this.IpAddress = ipAddress;
}
public void to_assigns_given_value()
{
var mapping = new Mapping();
var to = new object();
mapping.To = to;
Assert.Same(to, mapping.To);
mapping.To = null;
Assert.Null(mapping.To);
}
protected virtual void FromViewModelToEntity(TEV viewModel, TSetting entity)
{
Mapping.Map(viewModel, entity);
}
public override string GetVersion(Mapping mapping)
{
return("None");
}
/// <summary>
/// Maps an object to a specific BsonValue type.
/// </summary>
/// <param name="value">An object.</param>
/// <param name="bsonType">The BsonType to map to.</param>
/// <returns>A BsonValue of the desired type (or BsonNull.Value if value is null and bsonType is Null).</returns>
public static BsonValue MapToBsonValue(object value, BsonType bsonType)
{
string message;
if (value == null)
{
if (bsonType == BsonType.Null)
{
return(BsonNull.Value);
}
else
{
message = string.Format("C# null cannot be mapped to BsonType.{0}.", bsonType);
throw new ArgumentException(message, "value");
}
}
// handle subclasses of BsonDocument (like QueryDocument) correctly
if (bsonType == BsonType.Document)
{
var bsonDocument = value as BsonDocument;
if (bsonDocument != null)
{
return(bsonDocument);
}
}
var valueType = value.GetType();
if (valueType.IsEnum)
{
valueType = Enum.GetUnderlyingType(valueType);
switch (Type.GetTypeCode(valueType))
{
case TypeCode.Byte: value = (int)(byte)value; break;
case TypeCode.Int16: value = (int)(short)value; break;
case TypeCode.Int32: value = (int)value; break;
case TypeCode.Int64: value = (long)value; break;
case TypeCode.SByte: value = (int)(sbyte)value; break;
case TypeCode.UInt16: value = (int)(ushort)value; break;
case TypeCode.UInt32: value = (long)(uint)value; break;
case TypeCode.UInt64: value = (long)(ulong)value; break;
}
valueType = value.GetType();
}
Conversion conversion; // the conversion (if it exists) that will convert value to bsonType
if (__fromToMappings.TryGetValue(Mapping.FromTo(valueType, bsonType), out conversion))
{
return(Convert(value, conversion));
}
// these coercions can't be handled by the conversions table (because of the interfaces)
switch (bsonType)
{
case BsonType.Array:
if (value is IEnumerable)
{
return(new BsonArray((IEnumerable)value));
}
break;
case BsonType.Document:
if (value is IDictionary <string, object> )
{
return(new BsonDocument((IDictionary <string, object>)value));
}
if (value is IDictionary)
{
return(new BsonDocument((IDictionary)value));
}
break;
}
message = string.Format(".NET type {0} cannot be mapped to BsonType.{1}.", value.GetType().FullName, bsonType);
throw new ArgumentException(message, "value");
}
public void Delete(GenreDTO genre)
{
_genreRepository.Delete(Mapping.GenreFromBlToDal(genre));
}
public ExistsInDbState WithParameters(Mapping mappings, InboundMessage inboundMessage)
{
_inboundMessage = inboundMessage;
_mappings = mappings;
return(this);
}
private ICSharpCode.Data.EDMDesigner.Core.EDMObjects.MSL.EntityType.PropertyMapping GetBusinessPropertyMapping(EntityType table)
{
return(Mapping.GetSpecificMappingForTable(table).FirstOrDefault(pm => pm.Property == Property));
}
public DeletePortMappingRequestMessage(Mapping mapping)
{
_mapping = mapping;
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as DataElement;
if (dest != null)
{
base.CopyTo(dest);
if (UrlElement != null)
{
dest.UrlElement = (Hl7.Fhir.Model.FhirUri)UrlElement.DeepCopy();
}
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (VersionElement != null)
{
dest.VersionElement = (Hl7.Fhir.Model.FhirString)VersionElement.DeepCopy();
}
if (NameElement != null)
{
dest.NameElement = (Hl7.Fhir.Model.FhirString)NameElement.DeepCopy();
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.ConformanceResourceStatus>)StatusElement.DeepCopy();
}
if (ExperimentalElement != null)
{
dest.ExperimentalElement = (Hl7.Fhir.Model.FhirBoolean)ExperimentalElement.DeepCopy();
}
if (PublisherElement != null)
{
dest.PublisherElement = (Hl7.Fhir.Model.FhirString)PublisherElement.DeepCopy();
}
if (Contact != null)
{
dest.Contact = new List <Hl7.Fhir.Model.DataElement.ContactComponent>(Contact.DeepCopy());
}
if (DateElement != null)
{
dest.DateElement = (Hl7.Fhir.Model.FhirDateTime)DateElement.DeepCopy();
}
if (UseContext != null)
{
dest.UseContext = new List <Hl7.Fhir.Model.CodeableConcept>(UseContext.DeepCopy());
}
if (CopyrightElement != null)
{
dest.CopyrightElement = (Hl7.Fhir.Model.FhirString)CopyrightElement.DeepCopy();
}
if (StringencyElement != null)
{
dest.StringencyElement = (Code <Hl7.Fhir.Model.DataElement.DataElementStringency>)StringencyElement.DeepCopy();
}
if (Mapping != null)
{
dest.Mapping = new List <Hl7.Fhir.Model.DataElement.MappingComponent>(Mapping.DeepCopy());
}
if (Element != null)
{
dest.Element = new List <Hl7.Fhir.Model.ElementDefinition>(Element.DeepCopy());
}
return(dest);
}
else
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
}
public string GetFileExtension(Mapping mapping)
{
return(".ts");
}
protected internal Command(Mapping mapping, NpgsqlCommand command)
{
this.Mapping = mapping;
this.NpgsqlCommand = command;
}
// Called every time a new input report has arrived
protected virtual void On_Report(object sender, EventArgs e)
{
DS4Device device = (DS4Device)sender;
int ind = -1;
for (int i = 0, arlength = DS4_CONTROLLER_COUNT; ind == -1 && i < arlength; i++)
{
DS4Device tempDev = DS4Controllers[i];
if (tempDev != null && device == tempDev)
{
ind = i;
}
}
if (ind != -1)
{
if (getFlushHIDQueue(ind))
{
device.FlushHID();
}
if (!string.IsNullOrEmpty(device.error))
{
LogDebug(device.error);
}
if (inWarnMonitor[ind])
{
int flashWhenLateAt = getFlashWhenLateAt();
if (!lag[ind] && device.Latency >= flashWhenLateAt)
{
lag[ind] = true;
device.getUiContext()?.Post(new SendOrPostCallback(delegate(object state)
{
LagFlashWarning(ind, true);
}), null);
}
else if (lag[ind] && device.Latency < flashWhenLateAt)
{
lag[ind] = false;
device.getUiContext()?.Post(new SendOrPostCallback(delegate(object state)
{
LagFlashWarning(ind, false);
}), null);
}
}
else
{
if (DateTime.UtcNow - device.firstActive > TimeSpan.FromSeconds(5))
{
inWarnMonitor[ind] = true;
}
}
device.getExposedState(ExposedState[ind], CurrentState[ind]);
DS4State cState = CurrentState[ind];
device.getPreviousState(PreviousState[ind]);
DS4State pState = PreviousState[ind];
if (!device.firstReport && device.IsAlive())
{
device.firstReport = true;
device.getUiContext()?.Post(new SendOrPostCallback(delegate(object state)
{
OnDeviceStatusChanged(this, ind);
}), null);
}
else if (pState.Battery != cState.Battery || device.oldCharging != device.isCharging())
{
byte tempBattery = currentBattery[ind] = cState.Battery;
bool tempCharging = charging[ind] = device.isCharging();
device.getUiContext()?.Post(new SendOrPostCallback(delegate(object state)
{
OnBatteryStatusChange(this, ind, tempBattery, tempCharging);
}), null);
}
if (getEnableTouchToggle(ind))
{
CheckForTouchToggle(ind, cState, pState);
}
cState = Mapping.SetCurveAndDeadzone(ind, cState);
if (!recordingMacro && (!string.IsNullOrEmpty(tempprofilename[ind]) ||
containsCustomAction(ind) || containsCustomExtras(ind) ||
getProfileActionCount(ind) > 0))
{
Mapping.MapCustom(ind, cState, MappedState[ind], ExposedState[ind], touchPad[ind], this);
cState = MappedState[ind];
}
if (!useDInputOnly[ind])
{
x360Bus.Parse(cState, processingData[ind].Report, ind);
// We push the translated Xinput state, and simultaneously we
// pull back any possible rumble data coming from Xinput consumers.
if (x360Bus.Report(processingData[ind].Report, processingData[ind].Rumble))
{
byte Big = processingData[ind].Rumble[3];
byte Small = processingData[ind].Rumble[4];
if (processingData[ind].Rumble[1] == 0x08)
{
setRumble(Big, Small, ind);
}
}
}
// Output any synthetic events.
Mapping.Commit(ind);
// Update the GUI/whatever.
DS4LightBar.updateLightBar(device, ind, cState, ExposedState[ind], touchPad[ind]);
}
}
public string GetInputkeys(int ind)
{
DS4State cState = CurrentState[ind];
DS4StateExposed eState = ExposedState[ind];
Mouse tp = touchPad[ind];
string result = "nothing";
if (DS4Controllers[ind] != null)
{
if (Mapping.getBoolButtonMapping(cState.Cross))
{
result = "Cross";
}
else if (Mapping.getBoolButtonMapping(cState.Circle))
{
result = "Circle";
}
else if (Mapping.getBoolButtonMapping(cState.Triangle))
{
result = "Triangle";
}
else if (Mapping.getBoolButtonMapping(cState.Square))
{
result = "Square";
}
else if (Mapping.getBoolButtonMapping(cState.L1))
{
result = "L1";
}
else if (Mapping.getBoolTriggerMapping(cState.L2))
{
result = "L2";
}
else if (Mapping.getBoolButtonMapping(cState.L3))
{
result = "L3";
}
else if (Mapping.getBoolButtonMapping(cState.R1))
{
result = "R1";
}
else if (Mapping.getBoolTriggerMapping(cState.R2))
{
result = "R2";
}
else if (Mapping.getBoolButtonMapping(cState.R3))
{
result = "R3";
}
else if (Mapping.getBoolButtonMapping(cState.DpadUp))
{
result = "Up";
}
else if (Mapping.getBoolButtonMapping(cState.DpadDown))
{
result = "Down";
}
else if (Mapping.getBoolButtonMapping(cState.DpadLeft))
{
result = "Left";
}
else if (Mapping.getBoolButtonMapping(cState.DpadRight))
{
result = "Right";
}
else if (Mapping.getBoolButtonMapping(cState.Share))
{
result = "Share";
}
else if (Mapping.getBoolButtonMapping(cState.Options))
{
result = "Options";
}
else if (Mapping.getBoolButtonMapping(cState.PS))
{
result = "PS";
}
else if (Mapping.getBoolAxisDirMapping(cState.LX, true))
{
result = "LS Right";
}
else if (Mapping.getBoolAxisDirMapping(cState.LX, false))
{
result = "LS Left";
}
else if (Mapping.getBoolAxisDirMapping(cState.LY, true))
{
result = "LS Down";
}
else if (Mapping.getBoolAxisDirMapping(cState.LY, false))
{
result = "LS Up";
}
else if (Mapping.getBoolAxisDirMapping(cState.RX, true))
{
result = "RS Right";
}
else if (Mapping.getBoolAxisDirMapping(cState.RX, false))
{
result = "RS Left";
}
else if (Mapping.getBoolAxisDirMapping(cState.RY, true))
{
result = "RS Down";
}
else if (Mapping.getBoolAxisDirMapping(cState.RY, false))
{
result = "RS Up";
}
else if (Mapping.getBoolTouchMapping(tp.leftDown))
{
result = "Touch Left";
}
else if (Mapping.getBoolTouchMapping(tp.rightDown))
{
result = "Touch Right";
}
else if (Mapping.getBoolTouchMapping(tp.multiDown))
{
result = "Touch Multi";
}
else if (Mapping.getBoolTouchMapping(tp.upperDown))
{
result = "Touch Upper";
}
}
return(result);
}
public void Update(GenreDTO genre)
{
_genreRepository.Update(Mapping.GenreFromBlToDal(genre));
}
public static bool shiftMod(DS4Device device, int deviceNum, DS4State cState, DS4StateExposed eState)
{
bool shift;
switch (Global.getShiftModifier(deviceNum))
{
case 1: shift = Mapping.getBoolMapping(DS4Controls.Cross, cState, eState); break;
case 2: shift = Mapping.getBoolMapping(DS4Controls.Circle, cState, eState); break;
case 3: shift = Mapping.getBoolMapping(DS4Controls.Square, cState, eState); break;
case 4: shift = Mapping.getBoolMapping(DS4Controls.Triangle, cState, eState); break;
case 5: shift = Mapping.getBoolMapping(DS4Controls.Options, cState, eState); break;
case 6: shift = Mapping.getBoolMapping(DS4Controls.Share, cState, eState); break;
case 7: shift = Mapping.getBoolMapping(DS4Controls.DpadUp, cState, eState); break;
case 8: shift = Mapping.getBoolMapping(DS4Controls.DpadDown, cState, eState); break;
case 9: shift = Mapping.getBoolMapping(DS4Controls.DpadLeft, cState, eState); break;
case 10: shift = Mapping.getBoolMapping(DS4Controls.DpadRight, cState, eState); break;
case 11: shift = Mapping.getBoolMapping(DS4Controls.PS, cState, eState); break;
case 12: shift = Mapping.getBoolMapping(DS4Controls.L1, cState, eState); break;
case 13: shift = Mapping.getBoolMapping(DS4Controls.R1, cState, eState); break;
case 14: shift = Mapping.getBoolMapping(DS4Controls.L2, cState, eState); break;
case 15: shift = Mapping.getBoolMapping(DS4Controls.R2, cState, eState); break;
case 16: shift = Mapping.getBoolMapping(DS4Controls.L3, cState, eState); break;
case 17: shift = Mapping.getBoolMapping(DS4Controls.R3, cState, eState); break;
case 18: shift = Mapping.getBoolMapping(DS4Controls.TouchLeft, cState, eState); break;
case 19: shift = Mapping.getBoolMapping(DS4Controls.TouchUpper, cState, eState); break;
case 20: shift = Mapping.getBoolMapping(DS4Controls.TouchMulti, cState, eState); break;
case 21: shift = Mapping.getBoolMapping(DS4Controls.TouchRight, cState, eState); break;
case 22: shift = Mapping.getBoolMapping(DS4Controls.GyroZNeg, cState, eState); break;
case 23: shift = Mapping.getBoolMapping(DS4Controls.GyroZPos, cState, eState); break;
case 24: shift = Mapping.getBoolMapping(DS4Controls.GyroXPos, cState, eState); break;
case 25: shift = Mapping.getBoolMapping(DS4Controls.GyroXNeg, cState, eState); break;
case 26: shift = device.getCurrentState().Touch1; break;
default: shift = false; break;
}
return(shift);
}
public GenreDTO Get(int Id)
{
return(Mapping.GenreFromDalToBl(_genreRepository.Get(Id)));
}
public string Generate(Mapping mapping)
{
if (mapping.IsEnum)
{
return(null);
}
StringBuilder builder = new StringBuilder();
Type type = mapping.Fetch();
string outputTypeName = mapping.Name;
string inputTypeName = $"{Singleton.Instance.InputArgs.ClassPrefix ?? ""}{type.Name}{Singleton.Instance.InputArgs.ClassPostfix ?? ""}";
string methodName = GetRemotePopulatorDTOMethodName(outputTypeName);
builder.AppendLine($"public static {outputTypeName} {methodName} ({inputTypeName} remote, {outputTypeName} local = null) {{");
builder.AppendLine($"\tif (local == null) {{local = new {outputTypeName}();}}");
foreach (var propertyMapping in mapping.Mappings)
{
string localPropertyName = String.IsNullOrWhiteSpace(propertyMapping.TransformName) ? propertyMapping.Name : propertyMapping.TransformName;
string remotePropertyName = propertyMapping.Name;
string localPropertyType = propertyMapping.Type.IsASimpleType() ? propertyMapping.Type : Singleton.Instance.InputArgs.ClassPrefix + propertyMapping.Type + Singleton.Instance.InputArgs.ClassPostfix;
string remotePropertyType = propertyMapping.Type;
if (type.GetProperty(remotePropertyName) == null || type.GetProperty(remotePropertyName).SetMethod == null)
{
continue;
}
if (propertyMapping.IsEnum || type.IsNullableEnum())
{
Type enumType = Helpers.GetUnderlyingType(type);
if (propertyMapping.Type.IsASimpleType())
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = remote.{remotePropertyName}; }}");
}
else if (propertyMapping.IsNullable)
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = ({remotePropertyType}) Enum.Parse(typeof({remotePropertyType}), remote.{remotePropertyName}.ToString() ); }}");
}
else
{
builder.AppendLine($"\tlocal.{localPropertyName} = ({remotePropertyType}) Enum.Parse(typeof({remotePropertyType}), remote.{remotePropertyName}.ToString() );");
}
}
else if (propertyMapping.IsNullable)
{
if (propertyMapping.Type.IsASimpleType())
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = remote.{remotePropertyName}; }}");
}
else
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = { GetRemotePopulatorDTOMethodName(remotePropertyType)} (remote.{remotePropertyName}); }}");
}
}
else if (propertyMapping.IsDictionary)
{
var dictLine = $"\tif (remote.{remotePropertyName} != null && remote.{remotePropertyName}.Any()) {{";
dictLine = dictLine + $"local.{localPropertyName} = remote.{remotePropertyName}.ToDictionary(";
foreach (var dictionaryType in propertyMapping.DictionaryTypes)
{
int index = propertyMapping.DictionaryTypes.IndexOf(dictionaryType);
if (dictionaryType.IsASimpleType())
{
dictLine = dictLine + $"pair=>";
if (index == 0)
{
dictLine = dictLine + $"pair.Key";
}
else
{
dictLine = dictLine + $"pair.Value";
}
}
else
{
dictLine = dictLine + $"pair=>";
if (index == 0)
{
dictLine = dictLine + $"{GetRemotePopulatorDTOMethodName(dictionaryType)}(pair.Key)";
}
else
{
dictLine = dictLine + $"{GetRemotePopulatorDTOMethodName(dictionaryType)}(pair.Value)";
}
}
dictLine = dictLine + $",";
}
if (dictLine.EndsWith(","))
{
dictLine = dictLine.Substring(0, dictLine.Length - 1);
}
dictLine = dictLine + " }";
builder.AppendLine(dictLine);
}
else if (propertyMapping.IsList)
{
if (propertyMapping.Type.IsASimpleType())
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null && remote.{remotePropertyName}.Any()) {{ local.{localPropertyName} = remote.{remotePropertyName}.Select(r=> r ).ToList(); }} ");
}
else
{
var internalMapping = Singleton.Instance.MappingList.FirstOrDefault(r => r.Name == propertyMapping.Type);
if (internalMapping != null && internalMapping.IsAReference)
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null && remote.{remotePropertyName}.Any()) {{ local.{localPropertyName} = remote.{remotePropertyName}.Select(r=> {string.Format(Singleton.Instance.InputArgs.IsAReferenceTypeFormat, localPropertyType, Singleton.Instance.InputArgs.IsAReferenceTypeLookupKey)} ).ToList(); }} ");
}
else
{
builder.AppendLine($"\t if (remote.{remotePropertyName} != null && remote.{remotePropertyName}.Any()) {{ local.{localPropertyName} = remote.{remotePropertyName}.Select(r=> {GetRemotePopulatorDTOMethodName(remotePropertyType)}(r) ).ToList(); }} ");
}
}
}
else
{
if (propertyMapping.Type.IsASimpleType())
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = remote.{remotePropertyName}; }}");
}
else
{
var internalMapping = Singleton.Instance.MappingList.FirstOrDefault(r => r.Name == propertyMapping.Type);
if (internalMapping != null && internalMapping.IsAReference)
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = {string.Format(Singleton.Instance.InputArgs.IsAReferenceTypeFormat, localPropertyType, Singleton.Instance.InputArgs.IsAReferenceTypeLookupKey)}; }}");
}
else
{
builder.AppendLine($"\tif (remote.{remotePropertyName} != null) {{ local.{localPropertyName} = {GetRemotePopulatorDTOMethodName(localPropertyType)} (remote.{remotePropertyName}); }}");
}
}
}
}
builder.AppendLine("\treturn local;");
builder.AppendLine("}");
return(builder.ToString());
}
public GenreDTO Create(GenreDTO genre)
{
var result = _genreRepository.Create(Mapping.GenreFromBlToDal(genre));
return(Mapping.GenreFromDalToBl(result));
}
public override string BuildQueryString()
{
var properties = _entity.GetType().IsAnonymous() ? _entity.GetType().GetProperties() : this.Type.GetProperties().Where(o => !AvoidFields.Contains(o.Name));
var keyFields = KeyFieldCache.Instance.FindKeyFields(this.Type);
this.Fields = properties.Where(o => !keyFields.Contains(o)).Concat(keyFields).Select(o => o.Name).ToList();
//to do
var hasGeometry = properties.Any(o => o.Name == this.GeometryQuery.GeometryField);
if (hasGeometry)
{
// for (int i = 0; i < parameterStrings.Length; i++)
// {
// if (parameterStrings[i] == "?G3E_GEOMETRY")
// {
// parameterStrings[i] = "GeomFromText(?G3E_GEOMETRY)";
// }
// }
}
//var conditionVisitor = new ConditionVisitor(this.Expr);
//key field must be not update field
//foreach (var propertyInfo in keyFields)
//{
// this.Fields.Add(propertyInfo.Name);
//}
var condition = string.Join(" AND ", keyFields.Select(o => string.Format("{0}={1}{0}", o.Name, Seperator)).ToArray());
return(string.Format("UPDATE {0} SET {1} WHERE {2} ", _byView? Mapping.GetUpdateView(Type.Name):Mapping.GetTableName(this.Type.Name),
string.Join(",", properties.Where(o => !keyFields.Contains(o)).Select(o => string.Format("{0}={1}{0}", o.Name, Seperator)).ToArray()),
condition));
}
public virtual void Visit(Mapping mapping)
{
VisitSubNodes(mapping);
}
private void DeployFarmManagedProperty(object modelHost, FarmModelHost farmModelHost, ManagedPropertyDefinition definition)
{
farmModelHost.ShouldUpdateHost = false;
ManagedPropertyCollection properties;
List <CrawledPropertyInfo> crawledProps;
var existingProperty = GetCurrentObject(modelHost, definition, out properties, out crawledProps);
var isNewMapping = existingProperty == null;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingProperty,
ObjectType = typeof(ManagedProperty),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (existingProperty == null)
{
existingProperty = properties.Create(definition.Name, (ManagedDataType)Enum.Parse(typeof(ManagedDataType), definition.ManagedType));
}
existingProperty.Description = definition.Description ?? string.Empty;
if (definition.Searchable.HasValue)
{
existingProperty.HasMultipleValues = definition.Searchable.Value;
}
if (definition.Queryable.HasValue)
{
existingProperty.Queryable = definition.Queryable.Value;
}
if (definition.Retrievable.HasValue)
{
existingProperty.Retrievable = definition.Retrievable.Value;
}
if (definition.HasMultipleValues.HasValue)
{
existingProperty.HasMultipleValues = definition.HasMultipleValues.Value;
}
if (definition.Refinable.HasValue)
{
existingProperty.Refinable = definition.Refinable.Value;
}
if (definition.Sortable.HasValue)
{
existingProperty.Sortable = definition.Sortable.Value;
}
if (definition.SafeForAnonymous.HasValue)
{
existingProperty.SafeForAnonymous = definition.SafeForAnonymous.Value;
}
if (definition.TokenNormalization.HasValue)
{
existingProperty.TokenNormalization = definition.TokenNormalization.Value;
}
//if (isNewMapping)
//{
var mappings = existingProperty.GetMappings();
foreach (var managedPropertyMappping in definition.Mappings)
{
var crawledProp = crawledProps
.FirstOrDefault(p => p.Name.ToUpper() == managedPropertyMappping.CrawledPropertyName.ToUpper());
var mapping = new Mapping
{
CrawledPropertyName = crawledProp.Name,
ManagedPid = existingProperty.PID,
};
if (crawledProp != null)
{
mapping.CrawledPropset = crawledProp.Propset;
}
mappings.Add(mapping);
}
existingProperty.SetMappings(mappings);
//}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = existingProperty,
ObjectType = typeof(ManagedProperty),
ObjectDefinition = definition,
ModelHost = modelHost
});
// Write the changes back
existingProperty.Update();
}
public CreatePortMappingRequestMessage(Mapping mapping)
{
_mapping = mapping;
}
protected virtual void FromEntityToViewModel(TSetting entity, TEV viewModel)
{
Mapping.Map(entity, viewModel);
}
static int Main(string[] args)
{
var opt = new Options();
var optionset = new OptionSet()
{
{ "m|mapping=", "the id of the mapping to generate code for", (int id) => opt.MappingId = id },
{ "u|user="******"your api-map user name", user => opt.UserName = user },
{ "p|password="******"your api-map user's password", pwd => opt.Password = pwd },
{ "o|output=", "output directory for generated code", outdir => opt.OutputDirectory = outdir },
};
List <string> extra;
try
{
extra = optionset.Parse(args);
}
catch (OptionException e)
{
Console.WriteLine($"Error: Unable to read options - {e.Message}");
return(-1);
}
var errors = opt.Validate();
if (errors.Any())
{
foreach (var error in errors)
{
Console.WriteLine(error);
}
return(-1);
}
Mapping mapping = null;
var gateway = new ApiMapGateway();
try
{
var mappingTask = gateway.GetMapping(opt.MappingId.Value, new NetworkCredential(opt.UserName, opt.Password)); // why can't we 'await' here
mappingTask.Wait();
mapping = mappingTask.Result;
}
catch (AggregateException agEx)
{
foreach (var inner in agEx.InnerExceptions)
{
Console.WriteLine($"Error: Unable to retrieve mapping - {inner.Message}");
}
return(-1);
}
catch (Exception ex)
{
Console.WriteLine($"Error: Unable to retrieve mapping - {ex.Message}");
return(-1);
}
if (mapping == null)
{
Console.WriteLine($"Error: Unable to retrieve mapping {opt.MappingId}.");
return(-1);
}
return(GenerateMappint(mapping, opt));
}
public CreatePortMappingMessage(Mapping mapping, IPAddress localIpAddress, UpnpNatRouterDevice device)
: base(device, "AddPortMapping")
{
Mapping = mapping;
LocalIpAddress = localIpAddress;
}
public string SerialiseMapping(Mapping mapping)
{
return(Serialise(writer => SerialiseMappingInternal(mapping, writer)));
}
void MapPort()
{
try
{
Debug.Log("Mapping port...");
udpMapping = new Mapping(Protocol.Udp, Port, Port)
{
Description = "Diluvium (UDP)"
};
natDevice.BeginCreatePortMap(udpMapping, state =>
{
if (state.IsCompleted)
{
Debug.Log("UDP Mapping complete! Testing...");
try
{
var m = natDevice.GetSpecificMapping(Protocol.Udp, Port);
if (m == null)
{
throw new InvalidOperationException("Mapping not found");
}
if (m.PrivatePort != Port || m.PublicPort != Port)
{
throw new InvalidOperationException("Mapping invalid");
}
Debug.Log("Success!");
}
catch (Exception ex)
{
Debug.Log("Failed to validate UDP mapping :\n" + ex.ToString());
}
}
}, null);
tcpMapping = new Mapping(Protocol.Tcp, Port, Port)
{
Description = "Diluvium (TCP)"
};
natDevice.BeginCreatePortMap(tcpMapping, state =>
{
if (state.IsCompleted)
{
Debug.Log("TCP Mapping complete! Testing...");
try
{
var m = natDevice.GetSpecificMapping(Protocol.Tcp, Port);
if (m == null)
{
throw new InvalidOperationException("Mapping not found");
}
if (m.PrivatePort != Port || m.PublicPort != Port)
{
throw new InvalidOperationException("Mapping invalid");
}
Debug.Log("Success!");
}
catch (Exception ex)
{
Debug.Log("Failed to validate TCP mapping :\n" + ex.ToString());
}
}
}, null);
}
catch (Exception ex)
{
Debug.Log("Failed to map port :\n" + ex.ToString());
}
}
public DS4Controls GetActiveInputControl(int ind)
{
DS4State cState = CurrentState[ind];
DS4StateExposed eState = ExposedState[ind];
Mouse tp = touchPad[ind];
DS4Controls result = DS4Controls.None;
if (DS4Controllers[ind] != null)
{
if (Mapping.getBoolButtonMapping(cState.Cross))
{
result = DS4Controls.Cross;
}
else if (Mapping.getBoolButtonMapping(cState.Circle))
{
result = DS4Controls.Circle;
}
else if (Mapping.getBoolButtonMapping(cState.Triangle))
{
result = DS4Controls.Triangle;
}
else if (Mapping.getBoolButtonMapping(cState.Square))
{
result = DS4Controls.Square;
}
else if (Mapping.getBoolButtonMapping(cState.L1))
{
result = DS4Controls.L1;
}
else if (Mapping.getBoolTriggerMapping(cState.L2))
{
result = DS4Controls.L2;
}
else if (Mapping.getBoolButtonMapping(cState.L3))
{
result = DS4Controls.L3;
}
else if (Mapping.getBoolButtonMapping(cState.R1))
{
result = DS4Controls.R1;
}
else if (Mapping.getBoolTriggerMapping(cState.R2))
{
result = DS4Controls.R2;
}
else if (Mapping.getBoolButtonMapping(cState.R3))
{
result = DS4Controls.R3;
}
else if (Mapping.getBoolButtonMapping(cState.DpadUp))
{
result = DS4Controls.DpadUp;
}
else if (Mapping.getBoolButtonMapping(cState.DpadDown))
{
result = DS4Controls.DpadDown;
}
else if (Mapping.getBoolButtonMapping(cState.DpadLeft))
{
result = DS4Controls.DpadLeft;
}
else if (Mapping.getBoolButtonMapping(cState.DpadRight))
{
result = DS4Controls.DpadRight;
}
else if (Mapping.getBoolButtonMapping(cState.Share))
{
result = DS4Controls.Share;
}
else if (Mapping.getBoolButtonMapping(cState.Options))
{
result = DS4Controls.Options;
}
else if (Mapping.getBoolButtonMapping(cState.PS))
{
result = DS4Controls.PS;
}
else if (Mapping.getBoolAxisDirMapping(cState.LX, true))
{
result = DS4Controls.LXPos;
}
else if (Mapping.getBoolAxisDirMapping(cState.LX, false))
{
result = DS4Controls.LXNeg;
}
else if (Mapping.getBoolAxisDirMapping(cState.LY, true))
{
result = DS4Controls.LYPos;
}
else if (Mapping.getBoolAxisDirMapping(cState.LY, false))
{
result = DS4Controls.LYNeg;
}
else if (Mapping.getBoolAxisDirMapping(cState.RX, true))
{
result = DS4Controls.RXPos;
}
else if (Mapping.getBoolAxisDirMapping(cState.RX, false))
{
result = DS4Controls.RXNeg;
}
else if (Mapping.getBoolAxisDirMapping(cState.RY, true))
{
result = DS4Controls.RYPos;
}
else if (Mapping.getBoolAxisDirMapping(cState.RY, false))
{
result = DS4Controls.RYNeg;
}
else if (Mapping.getBoolTouchMapping(tp.leftDown))
{
result = DS4Controls.TouchLeft;
}
else if (Mapping.getBoolTouchMapping(tp.rightDown))
{
result = DS4Controls.TouchRight;
}
else if (Mapping.getBoolTouchMapping(tp.multiDown))
{
result = DS4Controls.TouchMulti;
}
else if (Mapping.getBoolTouchMapping(tp.upperDown))
{
result = DS4Controls.TouchUpper;
}
}
return(result);
}
public void Setup()
{
Mapping.CreateConfiguration();
}
/// <summary>
/// Compares this Mapping to another object.
/// </summary>
/// <param name="obj">The other object.</param>
/// <returns>True if the other object is a Mapping and equal to this one.</returns>
public override bool Equals(object obj)
{
Mapping rhs = (Mapping)obj;
return(_netType == rhs._netType && _bsonType == rhs._bsonType);
}
public CSharpGenerator(TemplateParser templateParser, TextWriter textWriter, Mapping mapping, List <string> includedFiles)
: base(templateParser)
{
this.TextRenderer = new TextRenderer(textWriter, mapping);
this.IncludedFiles = includedFiles;
}
