3D Client Programmer

Reflection이란 쉽게 말하면 프로그램이 Runtime 중에 자료형, 변수명, 데이터 값을 가져올 수 있는 기능이다.

이 Reflection을 이용하면 작업해야하는 코드량을 줄일 수 있다.

예를 들면 구조체를 만들어서 등록하면 UI가 자동으로 생성하게한다거나, Backend에서 내려주는 데이터를 자동으로 Parsing한다거나 등등 다양하게 활용이 가능하다.

참고 : https://learn.microsoft.com/ko-kr/cpp/dotnet/reflection-cpp-cli?view=msvc-170

다른 언어에서는 언어차원에서 기본으로 제공되고 있으나, C++에서는 현재 C++차기 버전에 추가된다고 한다.

https://isocpp.org/files/papers/P2996R4.html

하지만, 지금 당장 사용을 해야되기 때문에 라이브러리를 여러가지 조사를 해보았다.

1. RTTR

- git : https://github.com/rttrorg/rttr

이 라이브러리를 가장 처음에 접했다. 잘만들어져있고 개발할 때 잘 사용하였으나 치명적인 약점이 있다.

이 라이브러리는 DLL로만 빌드 및 배포가 가능하기 때문에 프로그램에 RTTR을 추가하게 되면 DLL도 같이 배포를 해야만 한다.

2. ENTT::META

- git : https://github.com/skypjack/entt

이 라이브러리는 Header Only이다. 즉 Header만 추가해서 사용하면 모든 기능을 사용할 수 있다.

src/entt/meta 에 있는 헤더들을 이용해서 개발하면 된다.

이 라이브러리는 meta로 만들어졌다가 뒤에 entt 에 포함되면서 좀더 사용이 용이하게 개량되었다.

이 라이브러리의 사용법과 굉장히 유사하지만, stl container가 추가되었고, 좀 더 사용이 편하게 개량되었다고 보면된다.

https://github.com/skypjack/meta

예제 코드

#include <entt/meta/meta.hpp>
#include <entt/meta/factory.hpp>
#include <entt/meta/policy.hpp>
#include <entt/meta/container.hpp>
#include <string>
#include <vector>
#include <iostream>
#include <memory>
#include <map>

std::map<entt::id_type, std::string> gHasheNames;
#define REGISTER_TYPE(Type)                                                                             \
    gHasheNames[entt::hashed_string(typeid(Type).name()).value()] = typeid(Type).name();                \
    entt::meta_factory<Type>().type(entt::hashed_string(typeid(Type).name()));

#define REGISTER_BASE(ChildType, ParentType)                                                            \
    entt::meta_factory<ChildType>().base<ParentType>();

// 수정: entt::as_ref_t 정책 추가
#define REGISTER_DATA(Type, Data, Name)                                                                 \
    entt::meta_factory<Type>().data<&Type::Data, entt::as_ref_t>(entt::hashed_string(Name));            \
    gHasheNames[entt::hashed_string(Name).value()] = Name;

// item 구조체 정의
struct item
{
    int price;
    std::string name;
};

// Person 구조체 정의
struct Person
{
    int age;                            // 나이 (정수)
    std::string name;                   // 이름 (문자열)
    std::vector<std::string> hobbies;   // 취미 (문자열 벡터)
    std::vector<item> items;            // 아이템 (item 구조체 벡터)

    // 생성자 추가
    Person(int age_, std::string name_, std::vector<std::string> hobbies_, std::vector<item> items_)
        : age(age_), name(name_), hobbies(hobbies_), items(items_) {}
};

// Student 구조체 정의 (Person 상속)
struct Student : public Person
{
    int grade;                          // 학년 (정수)
    std::string school;                 // 학교 (문자열)
    std::vector<std::string> subjects;  // 과목 (문자열 벡터)

    // 생성자 추가
    Student(int age_, std::string name_, std::vector<std::string> hobbies_, std::vector<item> items_,
        int grade_, std::string school_, std::vector<std::string> subjects_)
        : Person(age_, name_, hobbies_, items_), grade(grade_), school(school_), subjects(subjects_) {}
};

// Teacher 구조체 정의 (Person 상속)
struct Teacher : public Person
{
    int salary;                         // 연봉 (정수)
    std::string subject;                // 과목 (문자열)
    std::vector<std::string> students;  // 학생 (문자열 벡터)

    // 생성자 추가
    Teacher(int age_, std::string name_, std::vector<std::string> hobbies_, std::vector<item> items_,
        int salary_, std::string subject_, std::vector<std::string> students_)
        : Person(age_, name_, hobbies_, items_), salary(salary_), subject(subject_), students(students_) {}
};

int main()
{
    // 구조체를 EnTT 리플렉션 시스템에 등록
    REGISTER_TYPE(Person)
        REGISTER_DATA(Person, age, "age")
        REGISTER_DATA(Person, name, "name")
        REGISTER_DATA(Person, hobbies, "hobbies")
        REGISTER_DATA(Person, items, "items")

    REGISTER_TYPE(Student)
        REGISTER_BASE(Student, Person)
        REGISTER_DATA(Student, grade, "grade")
        REGISTER_DATA(Student, school, "school")
        REGISTER_DATA(Student, subjects, "subjects")

    REGISTER_TYPE(Teacher)
        REGISTER_BASE(Teacher, Person)
        REGISTER_DATA(Teacher, salary, "salary")
        REGISTER_DATA(Teacher, subject, "subject")
        REGISTER_DATA(Teacher, students, "students")

    // Person, Student, Teacher 객체를 포함하는 벡터 생성
    std::vector<std::unique_ptr<Person>> people;
    people.push_back(std::make_unique<Person>(30, "kim", std::vector<std::string>{ "reading", "gaming" }, std::vector<item>{ {100, "sword"}, {200, "shield"} }));
    people.push_back(std::make_unique<Student>(20, "lee", std::vector<std::string>{ "studying" }, std::vector<item>{}, 3, "harvard", std::vector<std::string>{ "physics", "chemistry" }));
    people.push_back(std::make_unique<Teacher>(40, "park", std::vector<std::string>{ "teaching" }, std::vector<item>{}, 2000000, "math", std::vector<std::string>{ "alice", "bob" }));

    // 각 객체의 모든 멤버를 출력하고 수정
    for (auto& person_ptr : people)
    {
        // 객체를 meta_handle로 래핑하여 실제 타입 유지
        entt::meta_handle meta_handle(person_ptr.get());

        // 객체의 런타임 타입 가져오기
        auto meta_type = meta_handle.type();

        std::cout << "Type: " << meta_type.info().name() << std::endl;

        // 모든 데이터 멤버 순회
        for (auto member : meta_type.data())
        {
            // 멤버 이름 가져오기
            std::string member_name = gHasheNames[member.first];
            auto value = member.second.get(meta_handle);

            // 타입별로 처리
            if (value.type().id() == entt::resolve<int>().id()) {
                int val = value.cast<int>();
                std::cout << member_name << ": " << val << std::endl;
                // 수정: 1 증가
                member.second.set(meta_handle, entt::meta_any{ val + 1 });
                std::cout << "Modified " << member_name << ": " << member.second.get(meta_handle).cast<int>() << std::endl;
            }
            else if (value.type().id() == entt::resolve<std::string>().id()) {
                std::string val = value.cast<std::string>();
                std::cout << member_name << ": " << val << std::endl;
                // 수정: "_modified" 추가
                auto& str_ref = value.cast<std::string&>();
                str_ref += "_modified";
                std::cout << "Modified " << member_name << ": " << member.second.get(meta_handle).cast<std::string>() << std::endl;
            }
            else if (value.type().id() == entt::resolve<std::vector<std::string>>().id()) {
                auto vec_str = value.cast<std::vector<std::string>>();
                std::cout << member_name << ": ";
                for (const auto& str : vec_str) std::cout << str << " ";
                std::cout << std::endl;
                // 수정: "new_element" 추가
                auto& vec_ref = value.cast<std::vector<std::string>&>();
                vec_ref.push_back("new_element");
                std::cout << "Modified " << member_name << ": ";
                for (const auto& str : member.second.get(meta_handle).cast<std::vector<std::string>>()) std::cout << str << " ";
                std::cout << std::endl;
            }
            else if (value.type().id() == entt::resolve<std::vector<item>>().id()) {
                auto vec_item = value.cast<std::vector<item>>();
                std::cout << member_name << ": ";
                for (const auto& it : vec_item) std::cout << it.name << "(" << it.price << ") ";
                std::cout << std::endl;
                // 수정: 새로운 아이템 추가
                auto& vec_ref = value.cast<std::vector<item>&>();
                vec_ref.push_back({ 300, "new_item" });
                std::cout << "Modified " << member_name << ": ";
                for (const auto& it : member.second.get(meta_handle).cast<std::vector<item>>()) std::cout << it.name << "(" << it.price << ") ";
                std::cout << std::endl;
            }
            else {
                std::cout << member_name << ": Unknown type" << std::endl;
            }
        }
        std::cout << "-----" << std::endl;
    }

    return 0;
}

전역 변수를 만들어놓았지만, 전역 변수가 초기화 되기 전에 사용되면서 크래시가 발생하는 경우가 있다.

이것을 Static Initialization Order Fiasco(정적 초기화 순서 실패, 정적 초기화 순서 재앙) 이라고 불린다.

참고 : https://en.cppreference.com/w/cpp/language/siof

예를 들어 아래와 같이 NamePool이라는 전역 객체가 있을 때 FName 객체의 생성자를 호출했을 때 NamePool 객체가 생성이 되지 않은 상태에서 NamePool에 데이터를 넣으려다가 크래시가 발생할 수 있다.

std::unordered_map<uint64, FString> NamePool;

FName::FName(FStringView InString)
{
    FString String = InString.data();
    HashCode = Hash(String.data());
    NamePool[HashCode] = String; // <- 여기서 Crash
}

FName::FName(const WIDECHAR* InString)
	:FName(FStringView(InString))
{
}

FString FName::ToString() const
{
    FString Out;
    ToString(Out);
    return Out;
}

void FName::ToString(FString& Out) const
{
    if (HashCode == 0)
    {
        return;
    }

    Out = NamePool[HashCode];
}

이를 방지하기 위해선 아래와 같이 코드를 수정하면 된다.

std::unordered_map<uint64, FString>& GetNamePool() // <- 이 함수가 중요
{
    static std::unordered_map<uint64, FString> NamePool;
    return NamePool;
}

FName::FName(FStringView InString)
{
    FString String = InString.data();
    HashCode = Hash(String.data());
    GetNamePool()[HashCode] = String;
}

FName::FName(const WIDECHAR* InString)
	:FName(FStringView(InString))
{
}

FString FName::ToString() const
{
    FString Out;
    ToString(Out);
    return Out;
}


void FName::ToString(FString& Out) const
{
    if (HashCode == 0)
    {
        return;
    }

    Out = GetNamePool()[HashCode];
}

이 방법을 "Construct on First Use" 아이디엄 이라고 부른다.

참고 : https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Construct_On_First_Use

1.웹뷰2의 환경 설정 및 기본 샘플 빌드 방법

• https://learn.microsoft.com/ko-kr/microsoft-edge/webview2/get-started/win32

2.위 샘플에서 WebView2에 대한 소스 코드

// <-- WebView2 sample code starts here -->
// Step 3 - Create a single WebView within the parent window
// Locate the browser and set up the environment for WebView
CreateCoreWebView2EnvironmentWithOptions(nullptr, nullptr, nullptr,
    Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
        [hWnd](HRESULT result, ICoreWebView2Environment* env) -> HRESULT 
        {
            // Create a CoreWebView2Controller and 
            // get the associated CoreWebView2 whose parent is the main window hWnd
            env->CreateCoreWebView2Controller(
                hWnd, 
                Callback<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>(
                [hWnd](HRESULT result, ICoreWebView2Controller* controller) -> HRESULT 
                {
                    if (controller != nullptr) 
                    {
                        webviewController = controller;
                        webviewController->get_CoreWebView2(&webview);
                    }
                    
                    // Add a few settings for the webview
                    // The demo step is redundant since the values are the default settings
                    wil::com_ptr<ICoreWebView2Settings> settings;
                    webview->get_Settings(&settings);
                    settings->put_IsScriptEnabled(TRUE);
                    settings->put_AreDefaultScriptDialogsEnabled(TRUE);
                    settings->put_IsWebMessageEnabled(TRUE);
                    
                    // Resize WebView to fit the bounds of the parent window
                    RECT bounds;
                    GetClientRect(hWnd, &bounds);
                    webviewController->put_Bounds(bounds);

                    // Schedule an async task to navigate to Bing
                    webview->Navigate(L"https://www.bing.com/");

                    return S_OK;
                }).Get());
            return S_OK;
        }).Get());

WebView2의 코드는 Callback 기반으로 동작한다.

• 웹뷰2를 유저가 설정한 옵션에 맞게 생성한다
  • CreateCoreWebView2EnvironmentWithOptions
    • https://learn.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/webview2-idl?view=webview2-1.0.2478.35#createcorewebview2environmentwithoptions
  • Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>
    • 결과 값으로 들어오는 env 를 가지고 controller를 생성한다
      • env->CreateCoreWebView2Controller
  • CoreWebView2Controller를 생성하고 부모가 기본 창 hWnd인 연결된 ICoreWebView2를 가져온다
  • ICoreWebView2를 이용하여 웹뷰의 크기와 url을 입력할 수 있다
  • 위에 코드로 웹뷰2에 www.bing.com 사이트가 뜨는 것 까지는 동작이 된다.

// Step 4 - Navigation events
// register an ICoreWebView2NavigationStartingEventHandler to cancel any non-https navigation
EventRegistrationToken token;
webview->add_NavigationStarting(Callback<ICoreWebView2NavigationStartingEventHandler>(
    [](ICoreWebView2* webview, ICoreWebView2NavigationStartingEventArgs* args) -> HRESULT 
    {
        wil::unique_cotaskmem_string uri;
        args->get_Uri(&uri);
        std::wstring source(uri.get());
        if (source.substr(0, 5) != L"https") 
        {
            args->put_Cancel(true);
        }
        return S_OK;
    }).Get(), &token);

• Navigate할 때 이벤트를 등록할 수 있다
• 위에 코드는 Navigation을 시작할 때 uri가 https 가 아니면 사이트를 열지 않겠다는 이벤트를 등록한다

// Step 5 - Scripting
// Schedule an async task to add initialization script that freezes the Object object
webview->AddScriptToExecuteOnDocumentCreated(L"Object.freeze(Object);", nullptr);
// Schedule an async task to get the document URL
webview->ExecuteScript(L"window.document.URL;", Callback<ICoreWebView2ExecuteScriptCompletedHandler>(
    [](HRESULT errorCode, LPCWSTR resultObjectAsJson) -> HRESULT 
    {
        LPCWSTR URL = resultObjectAsJson;
        //doSomethingWithURL(URL);
        return S_OK;
    }).Get());

• WebView2 컨트롤에 JavaScript 코드를 삽입할 수 있다
• 삽입된 JavaScript는 JavaScript가 제거될 때까지 모든 새로운 최상위 문서와 모든 하위 프레임에 적용된다

// Step 6 - Communication between host and web content
// Set an event handler for the host to return received message back to the web content
webview->add_WebMessageReceived(Callback<ICoreWebView2WebMessageReceivedEventHandler>(
    [](ICoreWebView2* webview, ICoreWebView2WebMessageReceivedEventArgs* args) -> HRESULT 
    {
        wil::unique_cotaskmem_string message;
        args->TryGetWebMessageAsString(&message);
        // processMessage(&message);
        webview->PostWebMessageAsString(message.get());
        return S_OK;
    }).Get(), &token);

// Schedule an async task to add initialization script that
// 1) Add an listener to print message from the host
// 2) Post document URL to the host
webview->AddScriptToExecuteOnDocumentCreated(
    L"window.chrome.webview.addEventListener(\'message\', event => alert(event.data));" \
    L"window.chrome.webview.postMessage(window.document.URL);",
    nullptr);

• 호스트와 웹 콘텐츠의 통신도 가능하다 (postMessage)
• Web -> Host
  • WebView2 컨트롤 내에서 실행되는 웹 콘텐츠는 메서드를 통해 호스트에 게실될 수 있으며 window.chrome.webview.postMessage는 호스트에 등록된 ICoreWebView2WebMessageReceivedEventHandler 이벤트 핸들러에 의해 처리된다
• Host -> Web
  • ICoreWebView2::PostWebMessageAsString
  • ICoreWebView2::PostWebMessageAsJSON
  • 위 메서드를 통해 웹 콘텐츠에 메시지를 보낼 수 있으며 이 메시지는 리스너에 추가된 핸들러에 의해 포착된다
  • window.chrome.webview.addEventListener 이 통신 메커니즘을 사용하면 호스트에 기본 API를 실행하도록 요청하는 메시지를 전달하여 웹 콘텐츠가 기본 기능을 사용할 수 있다
• 메커니즘을 이해하기 위한 예로 WebView2에서 문서 URL을 출력하려고하면 다음 단계가 발생한다
  • 호스트는 수신된 메시지를 웹 콘텐츠로 다시 반환하기 위한 핸들러를 등록합니다.
  • 호스트는 호스트에서 메시지를 인쇄하기 위해 핸들러를 등록하는 스크립트를 웹 콘텐츠에 삽입합니다.
  • 호스트는 호스트에 URL을 게시하는 웹 콘텐츠에 스크립트를 삽입합니다.
  • 호스트의 핸들러가 트리거되어 메시지(URL)를 웹 콘텐츠에 반환합니다.
  • 웹 콘텐츠의 핸들러가 트리거되고 호스트(URL)의 메시지를 인쇄합니다.

1. WebView2 (https://learn.microsoft.com/en-us/microsoft-edge/webview2/)

2. 개발환경 세팅하기 (https://learn.microsoft.com/en-us/microsoft-edge/webview2/get-started/win32)

3. API Reference (https://learn.microsoft.com/en-us/microsoft-edge/webview2/webview2-api-reference?tabs=dotnetcsharp)

4. github (https://github.com/MicrosoftEdge/WebView2Samples)

5. 참고하면 좋은 사이트
    - https://mariusbancila.ro/blog/2020/01/28/using-microsoft-edge-in-a-native-windows-desktop-app-part-1/

다른 글 이외에 잡다하지만 유용해 보이는 것들에 대해 정리...

https://en.cppreference.com/w/cpp/utility/source_location

https://en.cppreference.com/w/cpp/utility/functional/bind_front

https://en.cppreference.com/w/cpp/types/is_constant_evaluated

https://en.cppreference.com/w/cpp/atomic/atomic_ref

https://en.cppreference.com/w/cpp/experimental/atomic_shared_ptr

https://en.cppreference.com/w/cpp/thread/counting_semaphore

https://en.cppreference.com/w/cpp/thread/latch

https://en.cppreference.com/w/cpp/thread/barrier

https://en.cppreference.com/w/cpp/io/basic_osyncstream

그 동안 std::thread를 사용한 예제를 보면 다음과 같다

void ThreadWork()
{
    while(true)
    {
        // work...
    }
};

int main()
{
    std::thread t(ThreadWork);
    
    // 쓰레드가 종료되길 기다려줘야 한다.
    if (t.joinable())
    {
        t.join();
    }
}

이번에 jthread는 쉽게 말하면 소멸자에서 join을 해준다. 즉 위의 코드를 아래와 같이 변경할 수 있다.

void ThreadWork()
{
    while(true)
    {
        // work...
    }
};

int main()
{
    std::jthread t(ThreadWork);
}

하지만 위의 코드들은 thread가 종료되지 않는다. 종료되는 코드를 추가하면 다음과 같다.

bool gRunning =true;

void ThreadWork()
{
    while(gRunning)
    {
        // work...
    }
};

int main()
{
    std::thread t(ThreadWork);
    
    // 쓰레드 종료 요청
    gRunning = false;
    
    // 쓰레드가 종료되길 기다려줘야 한다.
    if (t.joinable())
    {
        t.join();
    }
}

jthread를 이용하면 조금 더 우아하게 종료할 수 있게 된다.

void ThreadWork(std::stop_token stopToken)
{
    while(true)
    {
        if (stopToken.stop_requested())
            break;
    }
};

int main()
{
    std::jthread t(ThreadWork);
    
    t.request_stop();
}

그 동안 사용했던 std::thread를 좀 더 관리하기 쉬워질 것 같다.

C++을 좀 사용해보신분들은 이미 fmt::format을 많이 쓰고 있었을거라고 생각한다.

이제 동일한 기능이 C++20에도 포함이 되었다.

// format : format string 반환
auto str = std::format("{}, {}, {}", 1, 1.1, asdf);

// format_to : 결과를 output iterator에 반환
std::string buffer;
format_to(std::back_inserter(buffer), "{}, {}, {}", 1, 1.1, asdf);

// format_to_n : 최대 n개의 문자를 output iterator에 반환
std::string buffer2;
format_to(std::back_inserter(buffer2), 2, "{}, {}, {}", 1, 1.1, asdf);

만약 문자열에 "{" 를 사용하고 싶으면 {{ 와 같이 두개를 사용하면된다.

auto str = format("{{asdf {}}}", 5);

순서 지정하는 방법

format("{}, {}, {}", 10, 20, 30);
format("{1}, {0}, {2}", 10, 20, 30);

빈칸 채우는 문자 지정 (default : space)
정렬
 < left : 숫자가 아니면 default
 > right : 숫자면 default
 ^ center

format("{:10}", 5);   // "         5"
format("{:*<10}", 5); // "5*********"
format("{:*>10}", 5); // "*********5"
format("{:*^10}", 5); // "****5*****"

부호 (정수나 부동소수점에 사용)
 + : 양수면 + 붙여라
 - : 음수면 - 붙여라

format("{0:}, {0:+}, {0:-}", 0) // 0, +0, 0
format("{0:}, {0:+}, {0:-}", 1) // 1, +1, 1
format("{0:}, {0:+}, {0:-}", -1) // -1, -1, -1

정수에 대한 이진수, 팔진수, 십육진수 표현
 b : 이진수
 미지정 : 팔진수
 x : 십육진수
 #015 : 0을 15개의 padding 추가

format("#015", 0x78)  "000000000000120"
format("#015b", 0x78) "0b0000001111000"
format("#015x", 0x78) "0x0000000000078"

위에서 {:10} 은 최소 10개를 만든다는 뜻이었다. 반대로 최대 갯수도 지정할 수 있다.
precision 부동소수점과 문자열의 최대 갯수를 지정

double d = 123.456789;

format("{:.50}", d);            // "123.45678900000000555777....."
format("{:.8}", d);             // "123.45679" - 반올림됨
format("{:.5}", d);             // "123.46" - 반올림됨
format("{:.5}", "Hello World");	// "Hello"

타입 지정
 s : string
 b : binary 0b로 시작
 B : b와 같지만 0B로 시작
 d : decimal
 o : octal
 x : hexadecimal 0x로 시작
 X : x와 같지만 0X로 시작
 부동소수점 관련 (e, E, f, F ,g, G) : 생략... (지수 표시, 정밀도 등등...)

전 세계에서 사용하는 프로그램을 개발할 때 시간이 관련된 작업을 하게 될 것이다.

이때 Local Time으로 시간 계산을 하게되면 나라마다의 시차를 계산하기 어려워진다.

그렇기 때문에 UTC(Coordinated Universal Time 협정 세계시)를 이용하여 시간을 계산하게 된다

- 영국 : UTC+0.00 (Greenwich Mean Time, GMT)
- 한국 : UTC+9.00
- 뉴욕 : UTC-5.00
...

이렇듯 각 나라마다 시간 계산을 해줘야하는데, 드디어 C++20에서 지원해주게 되었다.

using namespace std;
using namespace std::chrono;

auto utcTime :: system_clock::now();
cout << utcTime << endl;

auto localTime = zoned_time(current_zone(), utcTime);
cout << localTime << endl;

auto localTime2 = zoned_time("Asia/Shanghai"s, utcTime);
cout << localTime2 << endl;

추가로 유닉스 시간이라는 개념에 대해서 알아둬야한다.

유닉스 시간(Unix Time)은 시각을 나타내는 방식이고, POSIX, Epoch 시간이라고도 부른다.
1970년 1월 1일 00:00:00 협정 세계시(UTC) 부터의 경과 시간을 초로 환산하여 정수로 나타낸 것이다.

using namespace std;
using namespace std::chrono;

auto utcTime = system_clock::now();

int64_t hoursSinceUtc = duration<hours>(utcTime.time_since_epoch()).count();
int64_t utcEpoch = duration<seconds>(utcTime.time_since_epoch()).count();