public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
var canonicalPhoneNumbers = phoneNumbers.ToArray();
for (int index = 0; index < canonicalPhoneNumbers.Length; index++)
{
canonicalPhoneNumbers[index] = this.ConvertPhoneToCanonicalForm(canonicalPhoneNumbers[index]);
}
PhonebookEntry entry;
bool isPhonebookEntryExists = !this.entries.TryGetValue(name, out entry);
if (isPhonebookEntryExists)
{
entry = new PhonebookEntry { Name = name, PhoneNumbers = new SortedSet<string>() };
this.entries.Add(name, entry);
this.sortedEntries.Add(entry);
}
foreach (var phoneNumber in canonicalPhoneNumbers)
{
this.allPhoneNumbers.Add(phoneNumber, entry);
}
entry.PhoneNumbers.UnionWith(canonicalPhoneNumbers);
return isPhonebookEntryExists;
}
public static PhonebookEntry Parse(string entry)
{
string[] splitted =
entry.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
string[] names =
splitted[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
int providedNames = names.Length;
string firstName = names[0].Trim();
string middleName = null;
if (providedNames > 1)
{
middleName = names[1].Trim();
}
string lastName = null;
if (providedNames > 2)
{
lastName = names[2].Trim();
}
string nickname = null;
if (providedNames > 3)
{
nickname = names[3].Trim();
}
PhonebookEntry phonebookEntry =
new PhonebookEntry(firstName, middleName, lastName, nickname, splitted[1].Trim(), splitted[2].Trim());
return phonebookEntry;
}
public bool UpdateEntry(PhonebookEntry entry)
{
int i = GetEntryIndexById(entry.Id);
if (i == -1)
return false;
m_Phonebook[GetEntryIndexById(entry.Id)] = entry;
return true;
}
public void TestListEntries()
{
repo.AddPhone("me", new List<string> { "+35929811111", "+35929811112", "+359899777235" });
PhonebookEntry[] actual = (PhonebookEntry[])repo.ListEntries(0, 1);
var entry = new PhonebookEntry();
entry.Name = "me";
entry.PhoneNumbers = new SortedSet<string> { "+35929811111", "+35929811112", "+359899777235" };
var expected = new PhonebookEntry[1];
expected[0] = entry;
Assert.AreEqual(expected[0].ToString(), actual[0].ToString());
}
public IEnumerable<IPhonebookEntry> ListEntries(int start, int count)
{
if (start < 0 || start + count > this.phoneBookNameKey.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
IPhonebookEntry[] listedEntries = new PhonebookEntry[count];
for (int i = start; i <= start + count - 1; i++)
{
IPhonebookEntry entry = this.sortedByNamePhoneEntries[i];
listedEntries[i - start] = entry;
}
return listedEntries;
}
public PhonebookEntry[] ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex + count > this.phonebookByName.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index and/or count of ");
}
PhonebookEntry[] resultPhoneNumbers = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
PhonebookEntry entry = this.phoneEntries[i];
resultPhoneNumbers[i - startIndex] = entry;
}
return resultPhoneNumbers;
}
public IEnumerable<PhonebookEntry> ListEntries(int start, int num)
{
if (start < 0 || start + num > this.entries.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index or count.");
}
this.entries.Sort();
PhonebookEntry[] ent = new PhonebookEntry[num];
for (int i = start; i <= start + num - 1; i++)
{
PhonebookEntry entry = this.entries[i];
ent[i -start] = entry;
}
return ent;
}
public PhonebookEntry[] ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex + count > this.phonebookByName.Count)
{
throw new ArgumentOutOfRangeException("Invalid start index and/or count of ");
}
PhonebookEntry[] resultPhoneNumbers = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
PhonebookEntry entry = this.phoneEntries[i];
resultPhoneNumbers[i - startIndex] = entry;
}
return(resultPhoneNumbers);
}
public bool AddPhone(string name, IEnumerable <string> phoneNumbers)
{
string nameToLowerInvariant = name.ToLowerInvariant();
PhonebookEntry entry;
bool doesEntryNotExists = !this.entriesByName.TryGetValue(nameToLowerInvariant, out entry);
if (doesEntryNotExists)
{
entry = new PhonebookEntry(name);
this.entriesByName.Add(nameToLowerInvariant, entry);
this.sortedEntries.Add(entry);
}
this.AddPhoneNumbersToEntriesByPhone(phoneNumbers, entry);
entry.PhoneNumbers.UnionWith(phoneNumbers);
return(doesEntryNotExists);
}
public PhonebookEntry[] ListEntries(int first, int num)
{
if (first < 0 || first + num > this.dict.Count)
{
Console.WriteLine("Invalid start index or count.");
return null;
}
PhonebookEntry[] list = new PhonebookEntry[num];
for (int i = first; i <= first + num - 1; i++)
{
PhonebookEntry entry = this.sorted[i];
list[i - first] = entry;
}
return list;
}
public void Add(PhonebookEntry newEntry)
{
this.byFirstName.Add(newEntry.FirstName, newEntry);
if (newEntry.MiddleName != null)
{
this.byMiddleName.Add(newEntry.MiddleName, newEntry);
}
if (newEntry.LastName != null)
{
this.byLastName.Add(newEntry.LastName, newEntry);
}
if (newEntry.Nickname != null)
{
this.byNickname.Add(newEntry.Nickname, newEntry);
}
}
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
string nameToLowerCase = name.ToLowerInvariant();
PhonebookEntry phonebookEntry;
bool flag = !this.phonebookByName.TryGetValue(nameToLowerCase, out phonebookEntry);
if (flag)
{
phonebookEntry = new PhonebookEntry(name, phoneNumbers);
this.phonebookByName.Add(nameToLowerCase, phonebookEntry);
this.phoneEntries.Add(phonebookEntry);
}
foreach (var phoneNumber in phoneNumbers)
{
this.phonebookByNumber.Add(phoneNumber, phonebookEntry);
}
return flag;
}
public bool AddPhone(string name, IEnumerable <string> phoneNumbers)
{
string nameToLowerCase = name.ToLowerInvariant();
PhonebookEntry phonebookEntry;
bool flag = !this.phonebookByName.TryGetValue(nameToLowerCase, out phonebookEntry);
if (flag)
{
phonebookEntry = new PhonebookEntry(name, phoneNumbers);
this.phonebookByName.Add(nameToLowerCase, phonebookEntry);
this.phoneEntries.Add(phonebookEntry);
}
foreach (var phoneNumber in phoneNumbers)
{
this.phonebookByNumber.Add(phoneNumber, phonebookEntry);
}
return(flag);
}
public IEnumerable<PhonebookEntry> ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex > this.entries.Count)
{
throw new ArgumentOutOfRangeException("startIndex", "Invalid range");
}
if (count < 0 || startIndex + count > this.entries.Count)
{
throw new ArgumentOutOfRangeException("count", "Invalid range");
}
var listedPhonebookEntries = new PhonebookEntry[count];
for (int i = startIndex; i <= startIndex + count - 1; i++)
{
listedPhonebookEntries[i - startIndex] = this.sortedEntries[i];
}
return listedPhonebookEntries;
}
public bool Add(string name, IEnumerable<string> phoneNumbers)
{
string nameToLower = name.ToLowerInvariant();
IPhonebookEntry entry;
bool entryExists = this.phoneBookNameKey.TryGetValue(nameToLower, out entry);
if (!entryExists)
{
entry = new PhonebookEntry();
entry.Name = name;
entry.PhoneNumbers = new SortedSet<string>();
this.phoneBookNameKey.Add(nameToLower, entry);
this.sortedByNamePhoneEntries.Add(entry);
}
foreach (var number in phoneNumbers)
{
this.phoneBookNumberKey.Add(number, entry);
}
entry.PhoneNumbers.UnionWith(phoneNumbers);
return entryExists;
}
public bool AddPhone(string userName, IEnumerable<string> phoneNumbers)
{
string userNameLowerInvariant = userName.ToLowerInvariant();
PhonebookEntry entry;
bool foundEntry = !_phonebookDictionary.TryGetValue(userNameLowerInvariant, out entry);
if (foundEntry)
{
entry = new PhonebookEntry();
entry.FirstName = userName;
entry.PhoneNumbers = new SortedSet<string>();
_phonebookDictionary.Add(userNameLowerInvariant, entry);
_sortedEntries.Add(entry);
}
foreach (var number in phoneNumbers)
{
_phonebookMultiDictionary.Add(number, entry);
}
entry.PhoneNumbers.UnionWith(phoneNumbers);
return foundEntry;
}
public IEnumerable<PhonebookEntry> ListEntries(int startIndex, int count)
{
if (startIndex < 0 || startIndex > this.dict.Count)
{
throw new ArgumentOutOfRangeException("startIndex", "Invalid range");
}
if (count < 0 || startIndex + count > this.dict.Count)
{
throw new ArgumentOutOfRangeException("count", "Invalid range");
}
var listOfEntries = new PhonebookEntry[count];
for (int index = startIndex; index <= startIndex + count - 1; index++)
{
var entry = this.sorted[index];
listOfEntries[index - startIndex] = entry;
}
return listOfEntries;
}
public bool AddPhone(string name, IEnumerable<string> phones)
{
string name2 = name.ToLowerInvariant();
PhonebookEntry entry;
bool flag = !this.dict.TryGetValue(name2, out entry);
if (flag)
{
entry = new PhonebookEntry();
entry.Name = name;
entry.Phones = new SortedSet<string>();
this.dict.Add(name2, entry);
this.sorted.Add(entry);
}
foreach (var num in phones)
{
this.multidict.Add(num, entry);
}
entry.Phones.UnionWith(phones);
return flag;
}
public bool AddPhone(string userName, IEnumerable <string> phoneNumbers)
{
string userNameLowerInvariant = userName.ToLowerInvariant();
PhonebookEntry entry;
bool foundEntry = !_phonebookDictionary.TryGetValue(userNameLowerInvariant, out entry);
if (foundEntry)
{
entry = new PhonebookEntry();
entry.FirstName = userName;
entry.PhoneNumbers = new SortedSet <string>();
_phonebookDictionary.Add(userNameLowerInvariant, entry);
_sortedEntries.Add(entry);
}
foreach (var number in phoneNumbers)
{
_phonebookMultiDictionary.Add(number, entry);
}
entry.PhoneNumbers.UnionWith(phoneNumbers);
return(foundEntry);
}
/// <summary>
/// Adds new entry if the Person Name is not existing in the list
/// Otherwise updates Person's information about its phone numbers
/// </summary>
/// <param name="name">Person Name</param>
/// <param name="phoneNumbers">Enumeration of phone numbers as strings +359xxxxxxxxxx</param>
/// <returns>
/// true, if a new entry has been appended
/// false, if an existing entry has been updated
/// </returns>
public bool AddPhone(string name, IEnumerable<string> phoneNumbers)
{
var sameEntries = from entry in this.Entries
where entry.Name.ToLowerInvariant() == name.ToLowerInvariant()
select entry;
bool isNewEntry;
if (sameEntries.Count() == 0)
{
PhonebookEntry newEntry = new PhonebookEntry();
newEntry.Name = name;
newEntry.PhoneNumbers = new SortedSet<string>();
foreach (var phoneNumber in phoneNumbers)
{
newEntry.PhoneNumbers.Add(phoneNumber);
}
this.Entries.Add(newEntry);
isNewEntry = true;
}
else if (sameEntries.Count() == 1)
{
PhonebookEntry existingEntry = sameEntries.First();
foreach (var phoneNumber in phoneNumbers)
{
existingEntry.PhoneNumbers.Add(phoneNumber);
}
isNewEntry = false;
}
else
{
throw new ApplicationException("Duplicated name in the phonebook found: " + name);
}
return isNewEntry;
}
private ServiceResponse CreateEntry()
{
string surname = "", firstname = "", phone = "", address = "", error;
XmlNode node = m_InputXml.SelectSingleNode("//x:ServiceRequest/x:Payload/x:CreateEntry/x:surname", m_XmlNamespaceManager);
if (node != null)
surname = node.InnerText;
node = m_InputXml.SelectSingleNode("//x:ServiceRequest/x:Payload/x:CreateEntry/x:firstname", m_XmlNamespaceManager);
if (node != null)
firstname = node.InnerText;
node = m_InputXml.SelectSingleNode("//x:ServiceRequest/x:Payload/x:CreateEntry/x:phone", m_XmlNamespaceManager);
if (node != null)
phone = node.InnerText;
node = m_InputXml.SelectSingleNode("//x:ServiceRequest/x:Payload/x:CreateEntry/x:address", m_XmlNamespaceManager);
if (node != null)
address = node.InnerText;
PhonebookEntry entry = new PhonebookEntry(surname, firstname, phone, address);
m_Phonebook.AddEntry(entry);
bool saved = m_Phonebook.Save(out error);
if (!saved)
return new ServiceResponse(ResponseStatus.Failure, "Phonebook not saved: " + error, "");
return new ServiceResponse(ResponseStatus.Success, "Entry added successfully", "");
}
public PhonebookEntry[] ListEntries(int firstFound, int resultsCount)
{
if (firstFound < 0 || firstFound + resultsCount > _phonebookDictionary.Count)
{
//todo: must be replaced with exception bellow
//throw new IndexOutOfRangeException("Invalid start index or count.");
}
PhonebookEntry[] phonebookEntries = new PhonebookEntry[resultsCount];
try
{
for (int i = firstFound; i <= firstFound + resultsCount - 1; i++)
{
PhonebookEntry entry = this._sortedEntries[i];
phonebookEntries[i - firstFound] = entry;
}
}
catch (ArgumentOutOfRangeException aore)
{
Console.WriteLine("Invalid range");
}
return phonebookEntries;
}
public bool AddPhone(string name, IEnumerable<string> nums)
{
var old = from e in this.entries where e.Name.ToLowerInvariant() == name.ToLowerInvariant() select e;
bool flag;
if (old.Count() == 0)
{
PhonebookEntry obj = new PhonebookEntry(); obj.Name = name;
obj.Phones = new SortedSet<string>();
foreach (var num in nums)
{
obj.Phones.Add(num);
}
this.entries.Add(obj);
flag = true;
}
else if (old.Count() == 1)
{
PhonebookEntry obj2 = old.First();
foreach (var num in nums)
{
obj2.Phones.Add(num);
}
flag = false;
}
else
{
Console.WriteLine("Duplicated name in the phonebook found: " + name);
return false;
}
return flag;
}
public PhonebookEntry[] ListEntries(int firstFound, int resultsCount)
{
if (firstFound < 0 || firstFound + resultsCount > _phonebookDictionary.Count)
{
//todo: must be replaced with exception bellow
//throw new IndexOutOfRangeException("Invalid start index or count.");
}
PhonebookEntry[] phonebookEntries = new PhonebookEntry[resultsCount];
try
{
for (int i = firstFound; i <= firstFound + resultsCount - 1; i++)
{
PhonebookEntry entry = this._sortedEntries[i];
phonebookEntries[i - firstFound] = entry;
}
}
catch (ArgumentOutOfRangeException aore)
{
Console.WriteLine("Invalid range");
}
return(phonebookEntries);
}
/// <summary>
/// Gets a subset of Phonebook entries from the Repository
/// </summary>
/// <param name="start">Starting index of the Repository's array</param>
/// <param name="count">Number of elements</param>
/// <returns>
/// Array of PhonebookEntry if start and count are within Repository's range
/// Otherwise returns empty array (null)
/// </returns>
public PhonebookEntry[] ListEntries(int start, int count)
{
if (start < 0 || start + count > this.Entries.Count)
{
// returns empty Phonebook List on invalid range requested
return null;
}
this.Entries.Sort();
PhonebookEntry[] selectedEntries = new PhonebookEntry[count];
for (int i = start; i <= start + count - 1; i++)
{
PhonebookEntry entry = this.Entries[i];
selectedEntries[i - start] = entry;
}
return selectedEntries;
}
public bool AddEntry(PhonebookEntry entry)
{
m_Phonebook.Add(entry);
return true;
}
private void AddPhoneNumbersToEntriesByPhone(IEnumerable <string> phoneNumbers, PhonebookEntry entry)
{
foreach (var number in phoneNumbers)
{
this.entriesByPhone.Add(number, entry);
}
}
