github/msft-calculator
1
0
Fork 0
mirror of https://github.com/Microsoft/calculator.git synced 2025-08-22 14:13:30 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove all unused serialization/deserialization from StandardCalculatorViewModel and UnitConverterViewModel

Browse source
This commit is contained in:
Rudy Huyn 2019-03-26 00:22:28 -07:00
commit f634f01381
7 changed files with 3 additions and 374 deletions
Download patch file Download diff file Expand all files Collapse all files

80
src/CalcManager/CalculatorManager.cpp
View file

@ -244,8 +244,6 @@ namespace CalculationManager
{
m_savedCommands.push_back(MapCommandForSerialize(command));
}
this->SerializePrimaryDisplay();
this->SerializeMemory();
m_savedDegreeMode = m_currentDegreeMode;
return;
}
@ -330,47 +328,6 @@ namespace CalculationManager
return commandToLoad;
}
/// <summary>
/// Return saved degree mode which is saved when last time the expression was cleared.
/// </summary>
Command CalculatorManager::SerializeSavedDegreeMode()
{
return m_savedDegreeMode;
}
void CalculatorManager::SerializePrimaryDisplay()
{
m_savedPrimaryValue.clear();
m_currentCalculatorEngine->ProcessCommand(IDC_STORE);
auto memoryObject = m_currentCalculatorEngine->PersistedMemObject();
if (memoryObject != nullptr)
{
m_savedPrimaryValue = SerializeRational(*memoryObject);
}
}
/// <summary>
/// Return serialized primary display that is saved when the expression line was cleared.
/// </summary>
vector<long> CalculatorManager::GetSerializedPrimaryDisplay()
{
return m_savedPrimaryValue;
}
/// <summary>
/// DeSerialize the primary display from vector of long
/// </summary>
/// <param name = "serializedPrimaryDisplay">Serialized Rational of primary display</param>
void CalculatorManager::DeSerializePrimaryDisplay(const vector<long> &serializedPrimaryDisplay)
{
if (serializedPrimaryDisplay.empty())
{
return;
}
m_persistedPrimaryValue = DeSerializeRational(serializedPrimaryDisplay.begin());
this->LoadPersistedPrimaryValue();
}
/// <summary>
/// Load the persisted value that is saved in memory of CalcEngine
/// </summary>
@ -380,43 +337,6 @@ namespace CalculationManager
m_currentCalculatorEngine->ProcessCommand(IDC_RECALL);
}
/// <summary>
/// Serialize the Memory to vector of long
/// </summary>
/// <return type = "std::vector<long>">Serialized Rational of memory</return>
void CalculatorManager::SerializeMemory()
{
m_serializedMemory.clear();
for (auto const& memoryItem : m_memorizedNumbers)
{
auto serialMem = SerializeRational(memoryItem);
m_serializedMemory.insert(m_serializedMemory.end(), serialMem.begin(), serialMem.end());
}
}
vector<long> CalculatorManager::GetSerializedMemory()
{
return m_serializedMemory;
}
/// <summary>
/// DeSerialize the Memory from vector of long
/// </summary>
/// <param name = "serializedMemory">Serialized Rational of memory</param>
void CalculatorManager::DeSerializeMemory(const vector<long> &serializedMemory)
{
vector<long>::const_iterator itr = serializedMemory.begin();
while (itr != serializedMemory.end())
{
Rational memoryItem = DeSerializeRational(itr);
auto lengthMemoryItem = (2 * SERIALIZED_NUMBER_MINSIZE) + memoryItem.P().Mantissa().size() + memoryItem.Q().Mantissa().size();
m_memorizedNumbers.push_back(memoryItem);
itr += lengthMemoryItem;
}
this->SetMemorizedNumbersString();
}
/// <summary>
/// Memorize the current displayed value
/// Notify the client with new the new memorize value vector

8
src/CalcManager/CalculatorManager.h
View file

@ -63,7 +63,6 @@ namespace CalculationManager
// For persistence
std::vector<unsigned char> m_savedCommands;
std::vector<long> m_savedPrimaryValue;
std::vector<long> m_serializedMemory;
std::vector<long> m_currentSerializedMemory;
Command m_currentDegreeMode;
Command m_savedDegreeMode;
@ -110,13 +109,6 @@ namespace CalculationManager
void SetScientificMode();
void SetProgrammerMode();
void SendCommand(_In_ Command command);
void SerializeMemory();
std::vector<long> GetSerializedMemory();
void DeSerializeMemory(const std::vector<long> &serializedMemory);
void SerializePrimaryDisplay();
std::vector<long> GetSerializedPrimaryDisplay();
void DeSerializePrimaryDisplay(const std::vector<long> &serializedPrimaryDisplay);
Command SerializeSavedDegreeMode();
void MemorizeNumber();
void MemorizedNumberLoad(_In_ unsigned int);

211
src/CalculatorUnitTests/CalculatorManagerTest.cpp
View file

@ -181,12 +181,6 @@ namespace CalculatorManagerTest
TEST_METHOD(CalculatorManagerTestMemory);
TEST_METHOD(CalculatorManagerTestSerialize);
TEST_METHOD(CalculatorManagerTestSerializePrecision);
TEST_METHOD(CalculatorManagerTestSerializeMultiple);
TEST_METHOD(CalculatorManagerTestSerializeDegreeMode);
TEST_METHOD(CalculatorManagerTestSerializeMemory);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached_LeadingDecimal);
TEST_METHOD(CalculatorManagerTestMaxDigitsReached_TrailingDecimal);
@ -264,35 +258,6 @@ namespace CalculatorManagerTest
// MaxDigitsReached should have been called once
VERIFY_IS_LESS_THAN(0, pCalculatorDisplay->GetMaxDigitsCalledCount());
}
void SerializeAndDeSerialize()
{
auto serializedCommands = m_calculatorManager->SerializeCommands();
auto serializedMemory = m_calculatorManager->GetSerializedMemory();
auto serializedDisplay = m_calculatorManager->GetSerializedPrimaryDisplay();
Cleanup();
m_calculatorManager->DeSerializePrimaryDisplay(serializedDisplay);
m_calculatorManager->DeSerializeMemory(serializedMemory);
m_calculatorManager->DeSerializeCommands(serializedCommands);
}
void VerifyPersistence()
{
auto savedPrimary = m_calculatorDisplayTester->GetPrimaryDisplay();
auto savedExpression = m_calculatorDisplayTester->GetExpression();
auto savedMemory = m_calculatorDisplayTester->GetMemorizedNumbers();
SerializeAndDeSerialize();
VERIFY_ARE_EQUAL(savedPrimary, m_calculatorDisplayTester->GetPrimaryDisplay());
VERIFY_ARE_EQUAL(savedExpression, m_calculatorDisplayTester->GetExpression());
auto loadedMemory = m_calculatorDisplayTester->GetMemorizedNumbers();
VERIFY_ARE_EQUAL(savedMemory.size(), loadedMemory.size());
for (unsigned int i = 0; i < savedMemory.size(); i++)
{
VERIFY_ARE_EQUAL(savedMemory.at(i), loadedMemory.at(i));
}
}
};
std::shared_ptr<CalculatorManager> CalculatorManagerTest::m_calculatorManager;
@ -866,182 +831,6 @@ namespace CalculatorManagerTest
m_calculatorManager->MemorizeNumber();
}
void CalculatorManagerTest::CalculatorManagerTestSerializeMemory()
{
Cleanup();
Command commands[] = { Command::Command1, Command::CommandNULL };
ExecuteCommands(commands);
for (int i = 0; i < 110; i++)
{
m_calculatorManager->MemorizeNumber();
}
VerifyPersistence();
}
void CalculatorManagerTest::CalculatorManagerTestSerializeDegreeMode()
{
Cleanup();
Command commands[] = { Command::Command1, Command::CommandRAD, Command::CommandSIN, Command::CommandADD,
Command::Command1, Command::CommandGRAD, Command::CommandCOS, Command::CommandADD,
Command::Command1, Command::CommandDEG, Command::CommandTAN, Command::CommandADD,
Command::CommandNULL };
ExecuteCommands(commands);
VerifyPersistence();
}
// 1 + 2 then serialize and deserialize 3 times
// Check if the values are persisted correctly
void CalculatorManagerTest::CalculatorManagerTestSerializeMultiple()
{
Cleanup();
Command commands[] = { Command::Command1, Command::CommandADD, Command::Command2, Command::CommandNULL };
ExecuteCommands(commands);
VerifyPersistence();
VerifyPersistence();
VerifyPersistence();
}
// Calculate 1/3 then serialize and deserialize
// Multiply by 3 and check if the result is 1 not 0.999999999999999999...
void CalculatorManagerTest::CalculatorManagerTestSerializePrecision()
{
CalculatorManagerDisplayTester* pCalculatorDisplay = (CalculatorManagerDisplayTester *)m_calculatorDisplayTester.get();
wstring resultPrimary = L"";
wstring resultExpression = L"";
Cleanup();
Command commands[] = { Command::Command1, Command::CommandDIV, Command::Command3, Command::CommandEQU, Command::CommandNULL };
ExecuteCommands(commands);
SerializeAndDeSerialize();
Command commands2[] = { Command::CommandMUL, Command::Command3, Command::CommandEQU, Command::CommandNULL };
ExecuteCommands(commands2);
VERIFY_ARE_EQUAL(StringReference(L"1"), ref new String(pCalculatorDisplay->GetPrimaryDisplay().c_str()));
}
void CalculatorManagerTest::CalculatorManagerTestSerialize()
{
CalculatorManagerDisplayTester* pCalculatorDisplay = (CalculatorManagerDisplayTester *)m_calculatorDisplayTester.get();
wstring resultPrimary = L"";
wstring resultExpression = L"";
Cleanup();
m_calculatorManager->SendCommand(Command::ModeScientific);
m_calculatorManager->SendCommand(Command::Command1);
m_calculatorManager->SendCommand(Command::CommandADD);
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->SendCommand(Command::CommandMUL);
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->MemorizeNumber();
m_calculatorManager->SendCommand(Command::CommandEQU);
m_calculatorManager->MemorizeNumber();
vector<wstring> memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers();
wstring primaryDisplay = pCalculatorDisplay->GetPrimaryDisplay();
wstring expressionDisplay = pCalculatorDisplay->GetExpression();
SerializeAndDeSerialize();
vector<wstring> memorizedNumbersAfterDeSerialize = pCalculatorDisplay->GetMemorizedNumbers();
wstring primaryDisplayAfterDeSerialize = pCalculatorDisplay->GetPrimaryDisplay();
wstring expressionDisplayAfterDeSerialize = pCalculatorDisplay->GetExpression();
VERIFY_ARE_EQUAL(primaryDisplay, primaryDisplayAfterDeSerialize);
VERIFY_ARE_EQUAL(expressionDisplay, expressionDisplayAfterDeSerialize);
bool isEqual = false;
if (memorizedNumbers.size() < memorizedNumbersAfterDeSerialize.size())
{
isEqual = std::equal(memorizedNumbers.begin(), memorizedNumbers.end(), memorizedNumbersAfterDeSerialize.begin());
}
else
{
isEqual = std::equal(memorizedNumbersAfterDeSerialize.begin(), memorizedNumbersAfterDeSerialize.end(), memorizedNumbers.begin());
}
VERIFY_IS_TRUE(isEqual);
m_calculatorManager->SendCommand(Command::CommandGRAD);
m_calculatorManager->SendCommand(Command::Command5);
m_calculatorManager->SendCommand(Command::Command0);
m_calculatorManager->SendCommand(Command::CommandSIGN);
m_calculatorManager->SendCommand(Command::CommandMUL);
memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplay = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplay = pCalculatorDisplay->GetExpression();
SerializeAndDeSerialize();
memorizedNumbersAfterDeSerialize = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplayAfterDeSerialize = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplayAfterDeSerialize = pCalculatorDisplay->GetExpression();
VERIFY_ARE_EQUAL(primaryDisplay, primaryDisplayAfterDeSerialize);
VERIFY_ARE_EQUAL(expressionDisplay, expressionDisplayAfterDeSerialize);
isEqual = false;
if (memorizedNumbers.size() < memorizedNumbersAfterDeSerialize.size())
{
isEqual = std::equal(memorizedNumbers.begin(), memorizedNumbers.end(), memorizedNumbersAfterDeSerialize.begin());
}
else
{
isEqual = std::equal(memorizedNumbersAfterDeSerialize.begin(), memorizedNumbersAfterDeSerialize.end(), memorizedNumbers.begin());
}
VERIFY_IS_TRUE(isEqual);
m_calculatorManager->SendCommand(Command::Command1);
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->SendCommand(Command::Command3);
m_calculatorManager->SendCommand(Command::CommandPNT);
m_calculatorManager->SendCommand(Command::Command8);
m_calculatorManager->SendCommand(Command::CommandSIGN);
m_calculatorManager->MemorizeNumber();
m_calculatorManager->SendCommand(Command::Command2);
m_calculatorManager->SendCommand(Command::Command3);
m_calculatorManager->MemorizedNumberAdd(0);
m_calculatorManager->SendCommand(Command::CommandCENTR);
m_calculatorManager->SendCommand(Command::Command3);
m_calculatorManager->SendCommand(Command::Command1);
m_calculatorManager->SendCommand(Command::CommandSIN);
m_calculatorManager->MemorizedNumberSubtract(2);
m_calculatorManager->MemorizedNumberLoad(2);
memorizedNumbers = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplay = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplay = pCalculatorDisplay->GetExpression();
SerializeAndDeSerialize();
memorizedNumbersAfterDeSerialize = pCalculatorDisplay->GetMemorizedNumbers();
primaryDisplayAfterDeSerialize = pCalculatorDisplay->GetPrimaryDisplay();
expressionDisplayAfterDeSerialize = pCalculatorDisplay->GetExpression();
VERIFY_ARE_EQUAL(primaryDisplay, primaryDisplayAfterDeSerialize);
VERIFY_ARE_EQUAL(expressionDisplay, expressionDisplayAfterDeSerialize);
isEqual = false;
if (memorizedNumbers.size() < memorizedNumbersAfterDeSerialize.size())
{
isEqual = std::equal(memorizedNumbers.begin(), memorizedNumbers.end(), memorizedNumbersAfterDeSerialize.begin());
}
else
{
isEqual = std::equal(memorizedNumbersAfterDeSerialize.begin(), memorizedNumbersAfterDeSerialize.end(), memorizedNumbers.begin());
}
VERIFY_IS_TRUE(isEqual);
}
// Send 12345678910111213 and verify MaxDigitsReached
void CalculatorManagerTest::CalculatorManagerTestMaxDigitsReached()
{

3
src/CalculatorUnitTests/StandardViewModelUnitTests.cpp
View file

@ -1,4 +1,4 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "pch.h"
@ -76,7 +76,6 @@ namespace CalculatorUnitTests
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::Clear);
viewModel->ButtonPressed->Execute(NumbersAndOperatorsEnum::ClearEntry);
viewModel->ClearMemoryCommand->Execute(nullptr);
viewModel->Deserialize(ref new Platform::Array<unsigned char>(0));
}
TESTITEM* currentItem = item;

25
src/CalculatorUnitTests/UnitConverterTest.cpp
View file

@ -199,8 +199,6 @@ namespace UnitConverterUnitTests
TEST_METHOD(UnitConverterTestGetters);
TEST_METHOD(UnitConverterTestGetCategory);
TEST_METHOD(UnitConverterTestUnitTypeSwitching);
TEST_METHOD(UnitConverterTestSerialization);
TEST_METHOD(UnitConverterTestDeSerialization);
TEST_METHOD(UnitConverterTestQuote);
TEST_METHOD(UnitConverterTestUnquote);
TEST_METHOD(UnitConverterTestBackspace);
@ -252,7 +250,7 @@ namespace UnitConverterUnitTests
// Resets calculator state to start state after each test
void UnitConverterTest::Cleanup()
{
s_unitConverter->DeSerialize(wstring());
s_unitConverter->SendCommand(Command::Reset);
s_testVMCallback->Reset();
}
@ -324,18 +322,6 @@ namespace UnitConverterUnitTests
VERIFY_IS_TRUE(s_testVMCallback->CheckSuggestedValues(vector<tuple<wstring, Unit>>()));
}
// Test serialization
void UnitConverterTest::UnitConverterTestSerialization()
{
wstring test1 = wstring(L"4;Kilograms;Kg;0;0;0;|3;Pounds;Lb;1;1;0;|2;0;Weight;|1;1;0;52.8;116.4039;|1;1;Length;,2;0;Weight;,|1;1;Length;[1;Inches;In;1;1;0;,2;Feet;Ft;0;0;0;,[]2;0;Weight;[3;Pounds;Lb;1;1;0;,4;Kilograms;Kg;0;0;0;,[]|1;Inches;In;1;1;0;[1;Inches;In;1;1;0;:1;0;0;:,2;Feet;Ft;0;0;0;:0.08333333333333332870740406406185;0;0;:,[]2;Feet;Ft;0;0;0;[1;Inches;In;1;1;0;:12;0;0;:,2;Feet;Ft;0;0;0;:1;0;0;:,[]3;Pounds;Lb;1;1;0;[3;Pounds;Lb;1;1;0;:1;0;0;:,4;Kilograms;Kg;0;0;0;:0.45359199999999999519673110626172;0;0;:,[]4;Kilograms;Kg;0;0;0;[3;Pounds;Lb;1;1;0;:2.20461999999999980204279381723609;0;0;:,4;Kilograms;Kg;0;0;0;:1;0;0;:,[]|");
s_unitConverter->SendCommand(Command::Five);
s_unitConverter->SendCommand(Command::Two);
s_unitConverter->SendCommand(Command::Decimal);
s_unitConverter->SendCommand(Command::Eight);
s_unitConverter->SetCurrentCategory(s_testWeight);
s_unitConverter->SetCurrentUnitTypes(s_testKilograms, s_testPounds);
VERIFY_IS_TRUE(s_unitConverter->Serialize().compare(test1) == 0);
}
// Test input escaping
void UnitConverterTest::UnitConverterTestQuote()
@ -363,15 +349,6 @@ namespace UnitConverterUnitTests
VERIFY_IS_TRUE(UnitConverter::Unquote(UnitConverter::Quote(input3)) == input3);
}
// Test de-serialization
void UnitConverterTest::UnitConverterTestDeSerialization()
{
wstring test1 = wstring(L"4;Kilograms;Kg;0;0;0;|3;Pounds;Lb;1;1;0;|2;0;Weight;|1;1;0;52.8;116.4039;|1;1;Length;,2;0;Weight;,|1;1;Length;[1;Inches;In;1;1;0;,2;Feet;Ft;0;0;0;,[]2;0;Weight;[3;Pounds;Lb;1;1;0;,4;Kilograms;Kg;0;0;0;,[]|1;Inches;In;1;1;0;[1;Inches;In;1;1;0;:1;0;0;:,2;Feet;Ft;0;0;0;:0.08333333333333332870740406406185;0;0;:,[]2;Feet;Ft;0;0;0;[1;Inches;In;1;1;0;:12;0;0;:,2;Feet;Ft;0;0;0;:1;0;0;:,[]3;Pounds;Lb;1;1;0;[3;Pounds;Lb;1;1;0;:1;0;0;:,4;Kilograms;Kg;0;0;0;:0.45359199999999999519673110626172;0;0;:,[]4;Kilograms;Kg;0;0;0;[3;Pounds;Lb;1;1;0;:2.20461999999999980204279381723609;0;0;:,4;Kilograms;Kg;0;0;0;:1;0;0;:,[]|");
s_unitConverter->DeSerialize(test1);
VERIFY_IS_TRUE(s_testVMCallback->CheckDisplayValues(wstring(L"52.8"), wstring(L"116.4039")));
VERIFY_IS_TRUE(s_testVMCallback->CheckSuggestedValues(vector<tuple<wstring, Unit>>()));
}
// Test backspace commands
void UnitConverterTest::UnitConverterTestBackspace()
{

46
src/CalculatorUnitTests/UnitConverterViewModelUnitTests.cpp
View file

@ -133,9 +133,7 @@ namespace CalculatorUnitTests
m_setCurUnitTypesCallCount(0),
m_switchActiveCallCount(0),
m_sendCommandCallCount(0),
m_setVMCallbackCallCount(0),
m_serializeCallCount(0),
m_deSerializeCallCount(0)
m_setVMCallbackCallCount(0)
{ }
// IUnitConverter
@ -228,17 +226,6 @@ namespace CalculatorUnitTests
m_curValue = newValue;
}
wstring UnitConverterMock::Serialize()
{
m_serializeCallCount++;
return wstring(L"");
}
void UnitConverterMock::DeSerialize(const wstring& /*serializedData*/)
{
m_deSerializeCallCount++;
}
std::wstring UnitConverterMock::SaveUserPreferences()
{
return L"TEST";
@ -874,37 +861,6 @@ namespace CalculatorUnitTests
VERIFY_IS_TRUE(vm.SupplementaryResults->GetAt(0)->Unit->GetModelUnit() == UNITWHIMSY);
}
// Test deserialization
TEST_METHOD(TestUnitConverterViewModelDeserialization)
{
String ^ serializedTest = L"0[;;;]0[;;;]0[;;;]1[;;;]1.5[;;;]25[;;;]1.5[;;;]25[;;;][###][###]";
shared_ptr<UnitConverterMock> mock = make_shared<UnitConverterMock>();
VM::UnitConverterViewModel vm(mock);
vm.Deserialize(serializedTest);
VERIFY_IS_TRUE(vm.Value1 == L"1.5");
VERIFY_IS_TRUE(vm.Value2 == L"25");
VERIFY_IS_TRUE(vm.GetValueFromUnlocalized() == L"1.5");
VERIFY_IS_TRUE(vm.GetValueToUnlocalized() == L"25");
VERIFY_ARE_EQUAL(vm.Value1Active, false);
VERIFY_ARE_EQUAL(vm.Value2Active, true);
VERIFY_IS_TRUE(mock->m_deSerializeCallCount == 1);
}
// Test serialization
/*TEST_METHOD(TestUnitConverterViewModelSerialization)
{
String ^ serializedTest = L"0[;;;]0[;;;]0[;;;]1[;;;];;;]1.5[;;;[;;;]25[###[;;;]0[;;;]0[;;;][###][###]";
shared_ptr<UnitConverterMock> mock = make_shared<UnitConverterMock>();
VM::UnitConverterViewModel vm(mock);
vm.Value1 = L";;;]1.5[;;;";
vm.Value2 = L"25[###";
vm.Value1Active = false;
vm.Value2Active = true;
String ^ test = vm.Serialize();
VERIFY_IS_TRUE(serializedTest == test);
VERIFY_IS_TRUE(mock->m_serializeCallCount == 1);
}*/
TEST_METHOD(TestOnPaste)
{
shared_ptr<UnitConverterMock> mock = make_shared<UnitConverterMock>();

4
src/CalculatorUnitTests/UnitConverterViewModelUnitTests.h
View file

@ -35,8 +35,6 @@ namespace CalculatorUnitTests
UCM::Category GetCurrentCategory();
void SetCurrentUnitTypes(const UCM::Unit& fromType, const UCM::Unit& toType) override;
void SwitchActive(const std::wstring& newValue);
std::wstring Serialize() override;
void DeSerialize(const std::wstring& serializedData) override;
std::wstring SaveUserPreferences() override;
void RestoreUserPreferences(_In_ const std::wstring& userPreferences) override;
void SendCommand(UCM::Command command) override;
@ -54,8 +52,6 @@ namespace CalculatorUnitTests
UINT m_switchActiveCallCount;
UINT m_sendCommandCallCount;
UINT m_setVMCallbackCallCount;
UINT m_serializeCallCount;
UINT m_deSerializeCallCount;
UCM::Category m_curCategory;
UCM::Unit m_curFrom;