public static void Reset()
{
Names.Clear();
Props.Clear();
PostInitializes.Clear();
Destroys.Clear();
}
public void Merge(Sector metadataSource)
{
if (metadataSource == null)
{
throw new ArgumentNullException("metadataSource");
}
// TODO: This is very fragile; if a new type is added to Sector we need to add more code here.
if (metadataSource.Names.Any())
{
Names.Clear(); Names.AddRange(metadataSource.Names);
}
if (metadataSource.DataFile != null && DataFile != null &&
(metadataSource.DataFile.FileName != DataFile.FileName ||
metadataSource.DataFile.Type != DataFile.Type))
{
throw new Exception(string.Format("Mismatching DataFile entries for {0}", this.Names[0].Text));
}
if (metadataSource.DataFile != null)
{
DataFile = metadataSource.DataFile;
}
Subsectors.AddRange(metadataSource.Subsectors);
Allegiances.AddRange(metadataSource.Allegiances);
Borders.AddRange(metadataSource.Borders);
Routes.AddRange(metadataSource.Routes);
Labels.AddRange(metadataSource.Labels);
Credits = metadataSource.Credits;
Products.AddRange(metadataSource.Products);
StylesheetText = metadataSource.StylesheetText;
}
private void AddName(object sender, RoutedEventArgs e)
{
if (NameBox.Text != "")
{
Names.Clear();
string SqlSelectCommand = "SELECT Name FROM class;";
string SqlAddCommand = string.Format("INSERT INTO class (Name) VALUES ('{0}');", NameBox.Text);
try
{
MySqlCommand comm1 = new MySqlCommand(SqlAddCommand, conn);
MySqlCommand comm2 = new MySqlCommand(SqlSelectCommand, conn);
comm1.ExecuteNonQuery();
MySqlDataReader reader = comm2.ExecuteReader();
while (reader.Read())
{
Names.Add((string)reader["Name"]);
}
reader.Close();
NameBox.Text = "";
}
catch (InvalidOperationException)
{
MessageBox.Show("Connection failed");
}
}
}
private void RemoveName(object sender, RoutedEventArgs e)
{
if (NameBox.Text != "")
{
Names.Clear();
string SqlSelectCommand = "SELECT Name FROM class;";
string SqlDeleteCommand = string.Format("DELETE FROM class WHERE Name='{0}';", NameBox.Text);
try
{
MySqlCommand comm1 = new MySqlCommand(SqlDeleteCommand, conn);
MySqlCommand comm2 = new MySqlCommand(SqlSelectCommand, conn);
comm1.ExecuteNonQuery();
MySqlDataReader reader = comm2.ExecuteReader();
while (reader.Read())
{
Names.Add((string)reader["Name"]);
}
NameBox.Text = "";
reader.Close();
}
catch (InvalidCastException except)
{
MessageBox.Show("Connection failed" + except.Data);
}
}
}
public static void GenerateNames()
{
Names.Clear();
var uniqueNames = Object.FindObjectsOfType <UniqueName>();
foreach (var uniqueName in uniqueNames)
{
var trimmedName = uniqueName.name.TrimEnd();
if (!Names.Contains(trimmedName))
{
Names.Add(trimmedName);
continue;
}
string baseName = trimmedName;
if (Regex.IsMatch(baseName, @".+ \(\d+\)$"))
{
baseName = baseName.Substring(0, baseName.LastIndexOf("(", StringComparison.Ordinal)).TrimEnd();
}
string newName = baseName;
int index = 1;
while (Names.Contains(newName))
{
newName = baseName + " (" + index + ")";
index++;
}
Debug.LogWarning("Object name changed from " + uniqueName.name + " to " + newName, uniqueName);
uniqueName.name = newName;
Names.Add(newName);
}
}
public async Task ExecuteLoadStatsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
var adminManager = new AdminManager(Settings.AccessToken);
Names.Clear();
foreach (var name in await adminManager.PopularNames())
{
Names.Add(name);
}
}
catch (Exception ex)
{
var page = new ContentPage();
page.DisplayAlert("Error", "Unable to load.", "OK");;
}
finally
{
IsBusy = false;
}
}
private static void Clear( )
{
for (var i = 0; i < NamesHash.Length; i++)
{
NamesHash[i] = 0;
}
Names.Clear( );
MemorySizeForNames = 0;
}
/// <summary>
/// save ME3PCCObject to file.
/// </summary>
/// <param name="newFileName">set full path + file name.</param>
/// <param name="saveCompress">set true if you want a zlib compressed pcc file.</param>
public void saveToFile(string newFileName = null, bool WriteToMemoryStream = false)
{
//Refresh header and namelist
listsStream.Seek(0, SeekOrigin.End);
NameOffset = (int)listsStream.Position;
NameCount = Names.Count;
foreach (string name in Names)
{
listsStream.WriteValueS32(-(name.Length + 1));
listsStream.WriteString(name + "\0", (uint)(name.Length + 1) * 2, Encoding.Unicode);
}
listsStream.Seek(0, SeekOrigin.Begin);
listsStream.WriteBytes(header);
// KFreon: If want to write to memorystream instead of to file, exit here
if (WriteToMemoryStream)
{
return;
}
// Heff: try to remove any read-only attribute if we have permission to:
File.SetAttributes(newFileName, FileAttributes.Normal);
while (true)
{
int tries = 0;
try
{
using (FileStream fs = new FileStream(newFileName, FileMode.Create, FileAccess.Write))
{
byte[] test = listsStream.ToArray();
fs.WriteBytes(test);
test = null;
}
break;
}
catch (IOException)
{
System.Threading.Thread.Sleep(50);
tries++;
if (tries > 100)
{
throw new IOException("The PCC can't be written to disk because of an IOException");
}
}
}
listsStream.Dispose();
Exports.Clear();
Imports.Clear();
Names.Clear();
Exports = null;
Imports = null;
Names = null;
GC.Collect();
}
public static void DeInitialize( )
{
for (var i = 0; i < NamesHash.Length; i++)
{
NamesHash[i] = 0;
}
Names.Clear( );
MemorySizeForNames = 0;
Initialized = false;
}
public void SetNames(string[] fields)
{
Names.Clear();
Names.AddRange(fields);
Types = Types.Take(Math.Min(Types.Count, Names.Count)).ToList();
for (int i = Types.Count; i < Names.Count; i++)
{
Types.Add(null);
}
}
/// <summary>
/// Clear the list.
/// </summary>
public void clear()
{
lock (_mutex)
{
// Clear the names.
_names.Clear();
// Store in registry.
this.store();
}
}
public virtual void Clear()
{
ListedNames.Clear();
Names.Clear();
Index = -1;
Buf.Clear();
Buf01.Clear();
EditRec = false;
EditField = false;
ShowDesc = false;
FieldDesc = FieldDesc.None;
BufSize = 0;
FillChar = '\0';
Offset = 0;
ErrorFieldName = null;
ErrorMessage = "";
RecordType = null;
EditRecord = null;
NewRecordUid = 0;
FullDetail = false;
ResolveEffects = false;
LookupMsg = false;
NumberFields = false;
ExcludeROFields = false;
ListNum = 1;
}
public virtual IList <string> GetNames(Func <string, bool> matchFunc = null)
{
if (matchFunc == null)
{
matchFunc = n => true;
}
Names.Clear();
foreach (var fieldName in FieldNames)
{
GetName(fieldName, true);
}
return(Names.Where(matchFunc).ToList());
}
public void Clear()
{
_schema = null;
Path.Clear();
Variables.Clear();
Fragments.Clear();
UsedVariables.Clear();
UnusedVariables.Clear();
DeclaredVariables.Clear();
Names.Clear();
Types.Clear();
Directives.Clear();
OutputFields.Clear();
InputFields.Clear();
Errors.Clear();
IsInError = false;
}
/// <summary>
/// 把命令头解析出来。
/// 每个包中包含多个协议关键字，每个协议关键字用回车换行分开，
/// 因此我们需要调用文本分开函数，然后针对每条命令解析出关键字和值.
/// </summary>
/// <param name="protocolText"></param>
/// <returns></returns>
public bool DecodeProtocolText(string protocolText)
{
Header = "";
Names.Clear();
Values.Clear();
int speIndex = protocolText.IndexOf(ProtocolKey.ReturnWrap);
if (speIndex < 0)
{
return(false);
}
else
{
string[] tmpNameValues = protocolText.Split(new string[] { ProtocolKey.ReturnWrap }, StringSplitOptions.RemoveEmptyEntries);
if (tmpNameValues.Length < 2) //每次命令至少包括两行
{
return(false);
}
for (int i = 0; i < tmpNameValues.Length; i++)
{
string[] tmpStr = tmpNameValues[i].Split(new string[] { ProtocolKey.EqualSign }, StringSplitOptions.None);
if (tmpStr.Length > 1) //存在等号
{
if (tmpStr.Length > 2) //超过两个等号，返回失败
{
return(false);
}
if (tmpStr[0].Equals(ProtocolKey.Command, StringComparison.CurrentCultureIgnoreCase))
{
Command = tmpStr[1];
}
else
{
Names.Add(tmpStr[0].ToLower());
Values.Add(tmpStr[1]);
}
}
}
return(true);
}
}
public void UpdateClient(PersonInfo personInfo)
{
Gender = personInfo.Gender;
BirthDate = personInfo.BirthDate;
BirthDateEstimated = personInfo.BirthDateEstimated;
var personNames = PersonName.Create(personInfo);
Names.Clear();
AddNames(personNames);
var addresses = PersonAddress.Create(personInfo);
Addresses.Clear();
AddAddresss(addresses);
var contacts = PersonContact.Create(personInfo);
Contacts.Clear();
AddContacts(contacts);
}
public Message Build()
{
//if (!HasMessage)
// throw new Exception();
var voices = Voices.ToList();
voices.Sort(CompareVoiceIds);
string novelId = (IsNovel ? "novel " : string.Empty);
string nameId = string.Join("", Names.Select(n => n.Content));
string voiceId = string.Join(" ", voices.Select(ToVoiceId));
string groupId = $"{novelId}{nameId} {voiceId}";
Message m = new Message {
GroupId = groupId,
Script = Script,
Names = Names.ToImmutableArrayLW(),
Messages = Messages.ToImmutableArrayLW(),
Voices = Voices.ToImmutableArrayLW(),
};
Names.Clear();
Messages.Clear();
Voices.Clear();
string msg = m.CreateMessage().Message;
if (msg.Length == 0 || msg == "\n")
{
return(null);
}
if (msg == new string('.', msg.Length))
{
return(null);
}
if (JpUtils.Check(msg))
{
return(null);
}
return(m);
}
private bool Open(Stream stream)
{
try
{
BinaryReader reader = new BinaryReader(stream);
stream.Position = 0;
if (Encoding.ASCII.GetString(reader.ReadBytes(4)) == "PTP0")
{
Names.Clear();
Msg.Clear();
int MSGPos = reader.ReadInt32();
int MSGCount = reader.ReadInt32();
int NamesPos = reader.ReadInt32();
int NamesCount = reader.ReadInt32();
stream.Position = NamesPos;
for (int i = 0; i < NamesCount; i++)
{
int size = reader.ReadInt32();
byte[] OldName = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
string NewName = Encoding.UTF8.GetString(reader.ReadBytes(size));
stream.Position += IOTools.Alignment(stream.Position, 4);
Names.Add(new PTPName(i, OldName, NewName));
}
stream.Position = MSGPos;
for (int i = 0; i < MSGCount; i++)
{
int type = reader.ReadInt32();
byte[] buffer = reader.ReadBytes(24);
string Name = Encoding.ASCII.GetString(buffer.Where(x => x != 0).ToArray());
int StringCount = reader.ReadInt16();
int CharacterIndex = reader.ReadInt16();
PTPMSG mSG = new PTPMSG(i, type, Name, CharacterIndex);
for (int k = 0; k < StringCount; k++)
{
int size = reader.ReadInt32();
byte[] Prefix = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
byte[] OldString = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
byte[] Postfix = reader.ReadBytes(size);
stream.Position += IOTools.Alignment(stream.Position, 4);
size = reader.ReadInt32();
string NewString = Encoding.UTF8.GetString(reader.ReadBytes(size));
stream.Position += IOTools.Alignment(stream.Position, 16);
mSG.Strings.Add(new PTPMSGstr(k, NewString, Prefix, OldString, Postfix)
{
CharacterIndex = CharacterIndex
});
}
Msg.Add(mSG);
}
return(true);
}
return(false);
}
catch (Exception e)
{
Names.Clear();
Msg.Clear();
// Logging.Write("PTPfactory", e.ToString());
return(false);
}
}
public void Dispose()
{
Names.Clear();
Name = string.Empty;
Value = 0;
}
public void OnUserHideOrClosing()
{
ChildTreeItems.Clear();
Names.Clear();
}
/// <summary>
/// Clears all names from the collection.
/// </summary>
public void Clear()
{
Names.Clear();
}