KR100280820B1 - C＋＋ 객체지향 프로그래밍 시스템에서의 객체에 영속성부여 방법 - Google Patents

Abstract

본 발명은 C++ 응용 프로그램에서 생성하는 객체에 영속성을 부여하기 위한 방법으로 사용자에게 기존 C++ 응용 프로그램에서 객체를 생성하던 개념과 동일한 개념으로 객체를 생성할 수 있는 인터페이스를 제시하고, 이에 대한 구현 방법을 제시하는 것으로서, C++ 응용 프로그램에서 생성하는 객체에 영속성을 부여하는데 있어서, 객체지향 데이터베이스 시스템의 C++ 응용 프로그램 인터페이스로 영속 가능 클래스(OM_POBJECT)에 객체 생성 연산자(new())를 오버로드하여 다음과 같이

매개 변수가 없는 객체 생성 연산자 (OM_POBJECT::new())

영속성 여부를 매개 변수로 갖는 객체 생성 연산자 (OM_POBJECT::new (persistent))

영속성 여부와 타입명을 매개 변수로 갖는 객체 생성 연산자 (OM_POBJECT:: new(persistent, typename))

를 사용하고, 호출되는 영속 객체 생성 연산자의 동작 단계 및 컨스트락터 함수에 대한 동작 단계를 이용하여 상기 인터페이스를 지원하는 것을 특징으로 한다.

Description

Ｃ＋＋ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법

본 발명은 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성을 부여하는 방법에 관한 것이다.

일반적으로 객체지향 프로그래밍 시스템에서의 객체에 영속성을 부여하는 방법으로서, 가장 초보적인 방법은 영속성을 부여하고자 하는 프로그램 객체에 대해 사용자가 파일 시스템이나 데이터베이스에 저장 요구를 호출함으로서 영속성을 부여하는 방법이 있다. 이 방법은 사용자 입장에서 파일 시스템이나 데이터베이스에 저장할 때와 저장된 객체를 사용하기 위해 적재하는 책임을 지고, 이에 대해 조작을 해 주어야 하므로 자료의 일관성 및 사용에 부담을 준다.

이와 같은 문제점을 해결한 것이 객체지향 프로그램 시스템과 데이터베이스 시스템을 통합하여 시스템에서 자동으로 저장 및 추출을 담당해 주는 것이다. 자동으로 저장 및 추출을 수행하기 위해서는 시스템에 이와 같은 작업이 필요한 객체라는 사실을 알려 주어야 하며, 이를 알려 주는 방법에 따라 사용의 용이성 및 시스템의 이식성에 차이가 난다.

C++ 객체지향 프로그래밍 시스템과 데이터베이스 시스템을 통합하여 C++ 객체에 영속성을 부여하는 방법은 크게 C++ 언어 자체를 확장하여 영속 객체임을 알려 주는 방법과 영속성을 제공하는 클래스를 정의하고, 그 서브 클래스들의 객체에 한하여 영속성을 부여하도록 영속 클래스 라이브러리를 제공하는 방식이 있다.

C++ 언어 확장 방식은 타입과 직교적으로 객체에 영속성을 부여할 수 있다는 장점이 있으나, 일반 C++ 프로그래밍 환경에서 동작하기 위해서는 전 처리기나 특수 컴파일러가 제공되어야 하므로 이식성에 문제가 있다.

영속 클래스 라이브러리 방식은 특정 클래스에 속하는 객체에 한하여 영속성을 부여하므로 타입과 영속성이 직교적이지 못하다는 단점이 있으나, 실세계에서 데이터베이스 시스템내에 클래스가 미리 모형화되지 않은 상태에서 객체를 저장하는 일은 없으므로, 크게 문제가 되지 않는다. 영속 클래스 라이브러리 방법에서도 영속 클래스에 속하는 모든 객체를 영속 객체로 만드는 방법과 사용자의 선택에 의해 영속 객체, 임시 객체로 제공하는 방법이 있다. 모두 영속 객체로 만드는 방법은 같은 타입의 객체일지라도 임시 객체로 활용하기 위해서는 또 다른 타입을 만들어야 하는 등 사용자에게 융통성을 제공하지 못한다는 단점이 있다.

영속 클래스 라이브러리 방식에서는 영속 객체와 임시 객체를 얼마나 인식 없이 사용할 수 있느냐에 따라 사용의 용이성이 달라진다. 현재 상용 객체지향 데이터베이스 시스템 업체들로 구성된 상용 표준 단체인 오디엠지이(이하, ODMG라 칭함)의 C++ 결합에서는 영속 가능 클래스를 정의하고, 영속 가능 클래스에 속하는 객체로 임시 객체, 영속 객체 모두 생성 가능한 다음과 같은 인터페이스를 제안하고 있다.

특정 클래스(이하, POBJECT라 칭함)를 영속 가능 클래스로 정의하고, 이 클래스로부터 계승받은 클래스의 객체들만 영속 객체가 가능하며, 영속 객체가 되기 위해서는 객체 생성시 영속 객체가 생성되도록 요구하여야 한다. 영속 객체 생성 요구를 일반 C++ 객체 생성시 사용하는 생성 오퍼레이터(이하, new()라 칭함)를 이용하는 것과 같은 방법으로 사용할 수 있도록 POBJECT의 메소드로 오퍼레이터 new()를 다음과 같이 오버로드하여 제공한다.

1) POBJECT::new() // 임시 객체 생성

2) POBJECT::new(밀집 객체 정보, 생성할 객체의 타입명) // 영속 객체 생성

3) POBJECT::new(데이터베이스 정보, 생성할 객체의 타입명) // 영속 혹은 임시 객체 생성

두번째 인터페이스에서 매개 변수로 전달하는 밀집 객체 정보는 실제 생성된 객체의 데이터베이스내 저장 위치에 대한 정보로서, 이 매개 변수의 존재 여부에 의해 객체의 영속성이 결정되고 있다. 세번째 인터페이스에서는 데이터베이스 정보 변수 타입에 임시 객체 여부를 나타내는 플래그를 정적(static) 변수를 정의하고, 이 값에 의해 영속 객체, 임시 객체를 생성하고 있다. ODMG의 C++ 바인딩에서 제안한 영속 객체 생성 인터페이스는 임시 객체를 생성할 때는 new 오퍼레이터 다음에 나오는 클래스명을 이용하여 생성된 객체의 타입을 결정하는데, 영속 객체 생성을 위한 new 오퍼레이터는 매개 변수로 생성할 객체의 타입명을 요구하고 있다.

ODMG의 C++ 바인딩은 C++ 응용 프로그램 객체에 영속성을 부여하는 방법에 대한 사용자 인터페이스만 제시하고 있으며, 실제 구현 방법에 대해서는 전혀 언급된 바가 없으며, 이 표준안에 적합하다고 공언하는 상용 시스템이 있으나, 내부 동작 알고리즘이나 구현 기술에 대해서는 구체화 된 것이 없는 실정이다.

따라서, 본 발명은 ODMG의 C++ 바인딩에서 제시한 인터페이스를 보완하고, 이를 구현하는 방법에 대하여 제시하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법을 제공하는데 그 목적이 있다.

상술한 목적을 달성하기 위한 본 발명은 C++ 응용 프로그램의 객체에 영속성을 부여하는 방법에 대한 기술로서, 상용 표준안인 ODMG의 C++ 바인딩에서 제시한 인터페이스를 보완하여 영속 가능 클래스(이하, OM_POBJECT라 칭함)에 다음과 같이 객체 생성 연산자 new()를 오버로드하여 제시한다.

1) OM_POBJECT::new()

2) OM_POBJECT::new(영속성 여부)

3) OM_POBJECT::new(영속성 여부, 타입명)

첫번째 new 오퍼레이터는 임시 객체를 생성하는 new 오퍼레이터이고, 두번째 new 오퍼레이터는 영속성 여부(이하, persistent라 칭함)에 의해 객체의 영속 여부를 결정하며, 생성되는 객체의 클래스는 new 오퍼레이터 다음에 나오는 클래스명에 의해 결정한다. 세번째 new 오퍼레이터는 persistent에 의해 객체의 영속 여부를 결정하고, 생성되는 객체의 클래스는 명시된 매개 변수 타입명(이하, typename이라 칭함)에 의해 일차 결정하고, 잘못된 클래스명이면 new 오퍼레이터 다음에 나오는 클래스명에 의해 결정한다.

상기에서, 제시한 객체 생성 인터페이스는 영속 가능 클래스의 모든 객체는 동일한 인터페이스를 이용하여 사용자가 원하는 대로 임시 객체, 영속 객체를 모두 생성할 수 있고, 두번째 인터페이스를 이용하면 생성되는 객체의 클래스명을 추가로 명시하지 않고도 영속 객체를 생성할 수 있다. 세번째 인터페이스를 이용하여 객체 생성시에는 클래스 구조 정의문이 없이도 객체 생성이 가능하도록 OM_POBJECT 클래스를 구현한다.

상기한 인터페이스를 일관성있게 구현할 수 있는 다음과 같은 내부 알고리즘을 제시한다.

C++ 응용 프로그램에서 영속 객체를 생성하는 new()를 호출하면 메모리내 객체 생성 뿐만 아니라 프로그램 종료 후에도 지속되도록 데이터베이스에 객체를 생성하여야 한다. 데이터베이스에 객체를 생성한다는 것은 생성될 객체에 대한 클래스 정보를 알아야 한다는 의미이다. 그러나 두번째 new 오퍼레이터는 클래스명을 입력하지 않고 있으므로, 이에 대한 정보를 달리 얻어야 한다. C++에서는 new()가 호출되는 시점에 클래스에 대한 정보를 얻을 수 없고 오직 메모리만 할당하므로 어떤 클래스에 객체를 생성할 지 알 수 없다. 클래스 명을 제공하는 메소드를 클래스의 멤버 함수로 정의한다 하더라도 객체가 생성된 후에나 객체가 속한 클래스에 정의된 메소드를 호출할 수 있으므로 new() 호출시 활용할 수 없다. 그러므로 본 발명에서는 메소드 중 가장 먼저 호출되는, 즉, 사용자 입장에서는 객체 생성시 호출되는 메소드인 컨스트락터 함수를 이용하여, 클래스에 대한 정보를 얻어 new() 호출시 메모리 객체뿐 만 아니라 디스크에도 객체를 생성할 수 있게 한다.

도 1은 본 발명이 적용되는 컴퓨터 시스템 구성도.

도 2는 본 발명이 적용된 객체지향 데이터베이스 시스템의 모듈 구성도.

도 3은 본 발명에 따른 C++ 객체에 영속성 부여 방법에서 사용되는 클래스들의 구조 및 관계도.

도 4는 본 발명에서 사용하는 영속 객체 생성 연산자에 대한 동작 흐름도.

도 5는 본 발명에서 사용하는 영속 가능한 클래스의 컨스트락터 함수에 대한 동작 흐름도.

〈도면의 주요 부분에 대한 부호 설명〉

101 : C++ 객체지향 응용 프로그램

102 및 106 : 객체지향 데이터베이스 시스템(클라이언트 및 서버)

103 및 108 : 램(RAM) 104 및 109 : 씨피유(CPU)

105 및 110 : 아이오피(IOP) 107 : 운영 체제

111 : 비휘발성 저장 장치 112 : 네트워크

201 : C++ 응용 프로그램 202 : 클래스 정의문 생성 도구

203 : C++ 인터페이스 모듈

204 및 208 : 질의 모듈(클라이언트 및 서버)

205 및 209 : 스키마 관리 모듈(클라이언트 및 서버)

206 및 210 : 객체 관리 모듈(클라이언트 및 서버)

211 : 자료 저장 관리 시스템 212 : 데이터베이스

이하, 첨부된 도면을 참조하여 본 발명을 상세히 설명하기로 한다.

도 1은 본 발명이 적용되는 컴퓨터 시스템을 도시한 구성도이다.

영속 객체를 생성하는 C++ 객체지향 응용 프로그램(101)이 클래스 라이브러리로 제공되는 영속성 부여 시스템(102, 객체지향 데이터베이스 시스템의 일부로 클라이언트에 위치함)과 통합되어 주기억 장치인 램(RAM; 103), 프로세서인 씨피유(CPU; 104), 입출력 처리기인 아이오피(IOP; 105)가 동작하는 컴퓨터 시스템 환경에서 동작한다.

영속 객체를 생성하고자 하는 C++ 응용 프로그램의 요구는 네트워크(112)를 통하여 서버쪽에서 운영체제(107)와 RAM(108), CPU(109), IOP(110)의 도움을 받아 비휘발성 저장 장치인 디스크(DISK; 111)에 영속 객체를 관리하는 객체지향 데이터베이스 시스템(106)에 의해 처리된다.

도 2는 본 발명이 적용된 객체지향 데이터베이스 시스템의 모듈 구성도를 도시한 것이다.

C++ 인터페이스 모듈(203)은 C++ 응용 프로그램(201)에서 사용할 응용 프로그래밍 인터페이스를 지원하며, 스키마 관리 모듈(205 및 209)은 클래스 정의 및 변경 등의 스키마 관리와 권한 관리를 담당한다. 클라이언트 스키마 관리 모듈(205)은 스키마 정보 제공 기능을 수행하고, 서버 스키마 관리 모듈(209)은 실제적인 스키마 관리에 필요한 작업을 수행한다.

객체 관리 모듈(206 및 210)은 객체의 생성, 저장, 삭제 및 변경 등과 같은 객체 관리, 객체 식별자 관리, 메모리 객체와 디스크 저장 객체간의 형태 변환, 클라이언트 메모리 내 객체의 캐쉬 지원 기능 등을 수행한다. 디스크에 저장된 객체에 대한 관리는 서버 객체 관리 모듈(210)에 의해 수행되고, 메모리 객체/디스크 객체간의 변환과 메모리 객체 관리는 클라이언트 객체 관리 모듈(206)에서 담당한다.

질의 모듈(204 및 208)은 질의 처리 기능을 지원한다.

통신 관리 모듈(207)은 클라이언트와 서버사이의 통신을 담당한다.

자료 저장 관리 시스템(211)은 비 휘발성 메모리인 디스크에 저장되어 있는 데이터베이스(212)에 실제 자료를 저장 및 관리하며, 서버 객체 관리 모듈(210)에서 요구하는 자료에 대한 실제 접근을 담당한다.

클래스 정의문 생성 도구(202)는 객체지향 데이터베이스 시스템의 기능을 이용하여 영속 객체 관리에 필요한 메소드가 정의된 C++ 헤더 파일을 자동으로 생성해 주는 시스템이다.

본 발명에 포함되는 기술이 내포되어 있는 모듈은 클래스 정의문 생성 도구(202)와 C++ 인터페이스 모듈(203)과 객체 관리 모듈(206 및 210)로 기타 다른 모듈들의 도움을 받아 작업을 수행한다.

도 3은 본 발명에 따른 C++ 객체에 영속성을 부여하는 방법에서 사용되는 클래스들의 구조 및 관계를 도시한 것이다.

OM_POBJECT 클래스(302)가 영속성을 부여하는 인터페이스 클래스로 C++ 응용 프로그램에서 사용자가 T라는 클래스의 영속 객체를 생성하려면 클래스 T(303)는 OM_POBJECT로부터 계승받은 클래스(305)이어야 한다. 영속성 관리 클래스(이하, COM_OBJECT라 칭함; 301)는 실제 영속성을 관리하는 내부 구현 클래스로, OM_ POBJECT는 COM_OBJECT로부터 계승받은(304) 클래스이다.

COM_OBJECT 클래스는 영속성 관리에 필요한 정보들을 저장할 어트리뷰트들(306)과 영속성 관리에 필요한 메소드들(307)로 구성된다. 메소드는 컨스트락터 메소드와 재정의된 오퍼레이터와 일반 메소드로 구분된다. 본 발명과 관련이 있는 메소드는 컨스트락터 메소드(316)와 재정의된 new 오퍼레이터(317)이므로, 이후 일반 메소드에 대해서는 생략한다.

본 발명에서 제시하고자 하는 영속성 부여 방법과 직접적으로 관련이 있는 어트리뷰트는 영속성 플래그(이하, Persistent_flag라 칭함; 308), 객체 식별자(이하, Object_id라 칭함; 309), 저장 객체(이하, Disk_format라 칭함; 311), 클래스 구조 정보(이하, Layout_info라 칭함; 312), 메모리 객체 플래그(이하, Memory_ flag라 칭함; 315)이다.

Persistent_flag(308)는 객체의 영속 여부를 나타내는 플래그이고, Object_ id(309)는 객체 식별자이고, Disk_format(311)은 데이터베이스에 저장되어 있는 객체 모습을 나타내는 버퍼이고, Layout_info(312)는 객체가 속하는 클래스 구조 정보이다. Memory_flag(315)는 현재 객체 모습이 응용 프로그램에서 사용되는 구조체 모습으로 변경되었는지 여부를 나타내는 플래그이다.

그밖에 응용 프로그램 동작 환경인 클라이언트내에 객체 캐쉬를 관리하며, 응용 프로그램에서 영속 객체에 접근하는 것을 제어하는데, 필요한 정보로 변경 플래그(이하, Modify_flag라 칭함; 310), 객체 디스크립터(이하, Com_descript라 칭함; 313), 쓰기 잠금 플래그(이하, Write_lock_flag라 칭함; 314)가 있다.

Modify_flag(310)는 응용 프로그램 동작 환경인 주메모리에 있는 객체와 데이터베이스에 저장되어 있는 객체의 내용이 다른지, 즉, 응용 프로그램에서 변경이 일어났는지 여부를 나타내는 플래그이고, Write_lock_flag(314)는 응용 프로그램의 객체와 데이터베이스에 저장되어 있는 객체간의 일관성을 유지하기 위한 플래그이며, Com_descript(313)는 응용 프로그램에서 영속 객체에 접근하는 것을 관리하기 위한 것이다.

OM_POBJECT 클래스(302)는 COM_OBJECT 클래스(301)를 계승받은 클래스(304)이므로 COM_OBJECT 클래스의 어트리뷰트와 재정의된 new 오퍼레이터를 계승받는다(C++에서 컨스트락터 메소드는 특별한 메소드로 계승 대상이 아니므로 계승되지 않는다). OM_POBJECT(302)에는 자체내에 정의한 어트리뷰트들은 없고, 영속성 관리를 위하여 컨스트락터 메소드(318)와 본 발명에서 제시한 영속 객체 생성을 위한 new 오퍼레이터(319)를 정의하고 있다.

T 클래스(303)는 OM_POBJECT 클래스(302)를 계승받은 클래스(305)이므로 OM_POBJECT 클래스의 어트리뷰트와 OM_POBJECT 클래스 자체내에서 재정의된 new 오퍼레이터를 계승받고, COM_OBJECT 클래스의 어트리뷰트를 계승받는다. 그리고 T 클래스 자체에 사용자가 정의한 어트리뷰트(320)와 두 개의 컨스트락터 메소드(321)가 있다. 이 컨스트락터 메소드는 영속성 관리에 필요한 메소드로 꼭 정의되어 있어야 하며, 이에 대한 정의는 클래스 정의문 생성 도구에 의해 자동으로 수행해 준다.

C++ 프로그램 시스템에서 일반 프로그래밍 객체(즉, 임시 객체)를 생성하는

Obj = new T();

라는 문이 수행되는 절차를 살펴보면 다음과 같다.

일 단계; 프로그램 시스템에서 T에 직접, 간접으로 정의된 오퍼레이터 new()가 있으면 T의 오퍼레이터 new()를 수행시키고, 정의되어 있지 않으면 프로그램 시스템에 정의된 오퍼레이터 new()를 수행시켜 필요한 크기의 메모리를 할당한다. 여기에서 직접 정의의 의미는 T 클래스에서 명시적으로 정의한 것을 말하고, 간접 정의는 T가 계승받은 상위 클래스들의 계층상에 정의되어 있어 계승받은 것을 말한다.

이 단계; T 클래스에 정의되어 있는 T()라는 컨스트락터 함수를 수행시켜 객체를 초기화한다. T 클래스가 S라는 클래스로부터 계승받은 하위 클래스인 경우에는 S() 컨스트락터가 먼저 수행된 뒤 T() 컨스트럭터가 수행된다. T 클래스에 컨스트락터가 여러 개 정의된 경우에는 매개 변수 개수, 타입 등을 고려하여 대응되는 인터페이스를 갖는 컨스트락터가 수행된다.

본 발명에서 제시한 인터페이스를 이용하여 영속 객체를 생성하는 경우에도 마찬가지로, T 라는 클래스가 OM_POBJECT로부터 유도된 영속 가능한 클래스라면, 영속 객체가 수행되는 절차는 다음과 같다.

일 단계; T 클래스에는 직접 정의된 new 오퍼레이터가 없으므로 C++ 프로그래밍 시스템에 의해 OM_POBJECT 클래스에 정의된 3 종류의 오퍼레이터 new()에서 대응되는 인터페이스가 수행된다.

이 단계; C++ 프로그래밍 시스템에 의해 대응되는 T()라는 컨스트락터 함수가 수행된다.

즉, T의 영속 객체 생성은 OM_POBJECT에 정의된 오퍼레이터 new()와 T 클래스의 컨스트락터 함수에 정의된 절차에 따라 수행되므로 이것에 대해 자세히 설명한다.

도 4는 본 발명에서 사용하는 OM_POBJECT에 정의된 영속 객체 생성 오퍼레이터 new()의 동작을 도시한 흐름도이다.

OM_POBJECT의 오퍼레이터 new()는 내부에서 다음과 같이 COM_OBJECT 클래스의 오퍼레이터 new()를 호출한다. 단계(401)로부터 매개 변수가 전혀 없는 OM_ OBJECT::operator new()(402)는 COM_OBJECT::operator new(FALSE)를 호출하고(405 및 406), persistent 매개 변수 하나만 사용하는 OM_POBJECT::operator new (persistent)(403)는 COM_OBJECT::operator new(persistent)(416)를 호출한다(407). persistent와 typename 두 매개변수를 갖는 OM_POBJECT::operator new (persistent, typename)(404)은 typename에 따라(408 및 411) typename이 널이거나(409) 데이터베이스 시스템 내에 이미 생성되어 있는 영속 클래스가 아니면(412) COM_OBJECT::operator new(persistent)(416)를 호출하고(407), 아니면(410 및 413) typename에 해당하는 클래스의 클래스 식별자를 얻어(414) COM_OBJECT ::operator new(persistent, class_extent_id)(417)를 호출한다(415).

상기 과정으로부터, COM_OBJECT::operator new(persistent)의 동작 흐름은 다음과 같이 진행된다.

프로그래밍 시스템에서 제공하는 일반 오퍼레이터 new()를 이용하여 필요한 량만큼 메모리를 할당한다(418). 할당된 메모리가 COM_OBJECT 구조를 가질 때로 대응시켜 COM_OBJECT 구조체의 Persistent_flag 메모리 주소를 구하여, Persistent_ flag 메모리 영역에 입력으로 주어진 persistent 값을 저장한다(419). 할당된 메모리가 COM_OBJECT 구조를 가질 때로 대응시켜 COM_OBJECT 구조체의 Object_id 메모리 주소를 구하여, Object_id 메모리 영역에서 클래스 식별자 자리의 주소를 구하여 -1로 초기화한다(420).

또한, COM_OBJECT::new(persistent, class_extent_id)의 동작 흐름은 다음과 같이 진행된다.

프로그래밍 시스템에서 제공하는 일반 오퍼레이터 new()를 이용하여 필요한 량만큼 메모리를 할당한다(421). 할당된 메모리가 COM_OBJECT 구조를 가질 때로 대응시켜 COM_OBJECT 구조체의 Persistent_flag 메모리 주소를 구하여, Persistent_ flag 메모리 영역에 입력으로 주어진 persistent 값을 저장한다(422). 할당된 메모리가 COM_OBJECT 구조를 가질 때로 대응시켜 COM_OBJECT 구조체의 Object_id 메모리 주소를 구하여, Object_id 메모리 영역에서 클래스 식별자 자리의 주소를 구하여 입력으로 주어진 class_extent_id 값을 저장한다(423).

도 5는 본 발명에서 사용하는 영속 가능한 클래스인 T라는 클래스의 컨스트락터 함수에 대한 동작을 도시한 흐름도이다.

T() 컨스트락터는 먼저 typename을 자신의 이름으로 지정하고(501), 자신의 바로 상위 클래스에 대한 컨스트락터 C(typename)을 호출하고(502) 자체 컨스트락터 내용을 수행한다(503). 상위 클래스는 또 다시 자신의 상위 클래스에 대한 C(typename) 컨스트락터를 호출하고, 이것이 회귀적으로 호출되어(504) 마지막에는 OM_POBJECT(typename)이 호출된다(505). 여기서 typename은 T 클래스이면 "T"가 되고, 최초의 클래스명, 즉, "T"가 마지막 OM_POBJECT의 컨스트락터에까지 전달되어 최종적으로 T에 속하는 객체가 생성되게 한다.

상기에서, OM_POBJECT(typename)(505)는 COM_OBJECT() 컨스트락터를 호출 후(506) 자체 컨스트락터 내용을 수행한다. COM_OBJECT() 컨스트락터는(506) new 오퍼레이터에서 값이 대입된 Persistent_flag와 Object_id 자리를 제외한 나머지 영역을 초기화한다(507). OM_POBJECT(typename) 자체 컨스트락터에서는 Object_id의 클래스 식별자를 확인하여(508) 클래스 식별자에 아직 값이 대입되지 않은 경우(즉, -1인 경우)(509)에는 주어진 typename을 이용하여 클래스 식별자를 얻어(510), 객체를 생성한다(511). 상기 클래스 식별자가 -1이 아닌 경우에는 해당 클래스 식별자를 이용하여 객체를 생성한다(COM_OBJECT::create_object_id(클래스 식별자) 호출)(511).

COM_OBJECT::create_object_id()(511)에서는 Persistent_flag에 따라(512) 임시 객체 혹은 영속 객체를 생성한다. Persistent_flag가 FALSE(513)면 Object_id에 임시 객체 식별자를 부여하고(514), 기본값으로 설정된 객체 버퍼를 만들어 Disk_format에 연결한다(515). Persistent_flag가 TRUE(516)면 서버에 객체 생성을 요구하고(517), 서버로부터 받은 객체 버퍼를 Disk_format에 연결하고 객체 식별자를 얻어 Object_id에 대입한다(518).

상기처럼, 영속 가능한 클래스의 컨스트락터로 T()와 T(typename)의 인터페이스가 필요하고, 이에 대한 구현은 상위 클래스의 컨스트락터 호출 방법을 상기에서 명시한 대로 수행하여야 한다. 그러므로 이와 같은 컨스트락터 인터페이스와 구현을 클래스 정의문 생성 도구를 이용하여 클래스 정의문에 대한 헤더 파일을 생성시 만들어 주므로서 사용자는 전혀 의식없이 사용할 수 있게 한다.

상술한 바와 같이, 본 발명은 C++ 응용 프로그램 객체에 영속성을 부여하는 방법을 제공하므로서, C++ 응용 프로그램에서 영속 객체를 생성할 때 일반 C++ 응용 프로그램 객체를 생성하는 개념과 같은 개념으로 사용할 수 있으며, 또한 객체가 속하는 클래스명을 명시적으로 주지 않고도 사용 가능하므로 사용자에게 사용의 용이성 및 일관성을 제공할 수 있다. 또한 클래스 구조 정보에 대한 클래스 정의문이 없이도 영속 객체 생성이 가능하므로 클래스 정의문을 사전에 얻을 수 없는 응용 프로그램에서도 사용할 수 있다.

Claims (8)

1. C++ 응용 프로그램에서 생성하는 객체에 영속성을 부여하는데 있어서,

   객체지향 데이터베이스 시스템의 C++ 응용 프로그램 인터페이스로 영속 가능 클래스(OM_POBJECT)에 객체 생성 연산자(new())를 오버로드하여 다음과 같이

   매개 변수가 없는 객체 생성 연산자 (OM_POBJECT::new())

   영속성 여부를 매개 변수로 갖는 객체 생성 연산자 (OM_POBJECT::new (persistent))

   영속성 여부와 타입명을 매개 변수로 갖는 객체 생성 연산자(OM_POBJECT:: new(persistent, typename))

   를 사용하고, 호출되는 영속 객체 생성 연산자의 동작 단계 및 컨스트락터 함수에 대한 동작 단계를 이용하여 상기 인터페이스를 지원하는 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
2. 제 1 항에 있어서,

   상기 영속 가능 클래스(OM_POBJECT)의 영속 객체 생성 연산자의 동작 단계는

   프로그램 시스템에 의해 영속 가능 클래스의 객체 생성 연산자를 접수하여 매개변수를 확인하는 제 1 단계와,

   상기 확인 결과 매개변수가 없는 객체 생성 연산자(OM_POBJECT::new())인 경우에는 영속성 관리 클래스(COM_OBJECT)의 영속성 여부를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new(persistent))에서의 영속성 여부를 거짓(FALSE)으로 지정한 후, 호출한 다음에 종료하는 제 2 단계와,

   상기 확인 결과 영속성 여부를 나타내는 하나의 매개변수를 갖는 객체 생성 연산자(OM_POBJECT::new(persistent))인 경우에는 영속성 관리 클래스의 영속성 여부를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new(persistent))를 호출한 후 종료하는 제 3 단계와,

   상기 확인 결과 영속성 여부와 타입명의 두 매개 변수를 갖는 객체 생성 연산자(OM_POBJECT::new(persistent, typename))인 경우에는 타입명이 널 인지 확인하는 제 4 단계와,

   상기 확인 결과에 따라 널인 경우에는 영속성 관리 클래스의 영속성 여부를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new(persistent))를 호출하고, 널이 아닌 경우에는 타입명이 잘못되었는지를 확인하는 제 5 단계와,

   상기 확인 결과에 따라 잘못된 경우에는 영속성 관리 클래스의 영속성 여부를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new(persistent))를 호출하고, 잘못되지 않은 경우에는 타입명의 클래스 식별자를 획득한 후, 영속성 관리 클래스의 영속성 여부와 클래스를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new (persistent, class_extent_id))를 호출한 다음에 종료하는 제 6 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
3. 제 2 항에 있어서,

   상기 영속성 관리 클래스의 영속성 여부를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new(persistent)) 동작 단계는

   일반 객체 생성 연산자를 호출하는 단계와,

   영속성 관리 클래스의 어트리뷰트인 영속성 플래그(Persistent_flag) 메모리 주소를 구하여 영속성 여부 값을 저장하는 단계와,

   객체 식별자(Object_id) 어트리뷰트의 메모리 주소를 구하여 클래스 식별자를 -1로 초기화하는 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
4. 제 2 항에 있어서,

   상기 영속성 관리 클래스의 영속성 여부와 클래스 식별자를 매개 변수로 갖는 객체 생성 연산자(COM_OBJECT::new(persistent, class_extent_id)) 동작 단계는

   일반 객체 생성 연산자를 호출하는 단계와,

   영속성 관리 클래스의 어트리뷰트인 영속성 플래그(Persistent_flag) 메모리 주소를 구하여 입력으로 주어진 영속성 여부 값을 저장하는 단계와,

   객체 식별자(Object_id) 어트리뷰트의 메모리 주소를 구하여 입력으로 주어진 클래스 식별자를 지정하는 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
5. 제 1 항에 있어서,

   상기 컨스트락터 함수에 대한 동작 단계는

   T() 컨스트락터의 타입명을 "T"로 지정하는 제 1 단계와,

   상기 컨스트락터의 상위 클래스의 컨스트락터 C(타입명)을 호출하는 제 2 단계와,

   자체 컨스트락터을 수행한 후, 종료하는 제 3 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
6. 제 5 항에 있어서,

   상기 컨스트락터의 상위 클래스 동작 단계는

   자신의 상위 클래스에 대한 C(타입명)을 호출한 후, 반복해서 회귀적으로 호출하는 단계와,

   마지막 단계에서 영속 가능 클래스(OM_POBJECT)의 컨스트락터 함수(OM_ POBJECT(타입명))를 호출하는 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
7. 제 6 항에 있어서,

   상기 컨스트락터 함수(OM_POBJECT(타입명)) 동작 단계는

   영속성 관리 클래스(COM_OBJECT)의 컨스트락터 함수(COM_OBJECT)를 호출하는 단계와,

   상기 호출된 컨스트락터 함수(COM_OBJECT)가 영속성 플래그, 객체 식별자를 제외한 나머지 어트리뷰트를 초기화하는 단계와,

   상기 영속 가능 클래스 자체 컨스트락트(OM_POBJECT(타입명))에서 상기 객체 식별자의 클래스 식별자가 -1인지 확인하는 단계와,

   상기 확인 결과에 따라 -1인 경우에는 타입명의 클래스 식별자를 얻은 후, 영속성 관리 클래스의 객체 식별자 생성 함수(COM_OBJECT::create_object_id(클래스 식별자))를 호출하고, -1이 아닌 경우에는 바로 영속성 관리 클래스의 객체 식별자 생성 함수를 호출하는 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.
8. 제 7 항에 있어서,

   상기 영속성 관리 클래스의 객체 식별자 생성 함수(COM_OBJECT::create_ object_id(클래스 식별자)) 동작 단계는

   영속성 플래그(Persistent_flag)가 참(TRUE)인지 확인하는 단계와,

   상기 확인 결과 거짓(FALSE)이면 임시 객체 식별자를 생성하여 객체 식별자(Object_id) 어트리뷰트에 지정하고, 객체 버퍼를 초기화하여 디스크_포맷(Disk_ format) 어트리뷰트에 연결하는 단계와,

   상기 확인 결과 참(TRUE)이면 서버에 객체 생성을 요구하고, 서버로부터 획득한 객체 버퍼를 디스크_포맷(Disk_ format) 어트리뷰트에 연결하고 객체 식별자를 획득하여 객체 식별자(Object_id) 어트리뷰트에 대입하는 단계를 포함하여 이루어진 것을 특징으로 하는 C++ 객체지향 프로그래밍 시스템에서의 객체에 영속성 부여 방법.