2007 Fall, TOBESOFT Seminar - Experience Enterprise Web2.0 (투비소프트 세미나)

참가비 무료고, 고급 우산 주고, 추첨을 통해 캠코더, NDS, 상품권 등..
관심있으신 분들 많이 오셔용 =ㅁ=;;
특히 AJAX나 Web쪽에 관심있으신 분들에게 추천합니다
Experience Enterprise Web2.0

RIA & X인터넷 부문 국내 시장점유율 1위의 투비소프트가 또 한번의 도약을 준비합니다.
투비소프트는 현재 업계의 고민인 Enterprise Web2.0에 대한 정의를 내리고
그것을 구축하기 위한 가장 효율적인 방법을 제안하고자 합니다.
현재 시장에서 가장 큰 이슈가 되고 있으나 정의조차 분명하지 않은 Web2.0을
어떻게 기업에서 받아들여 가치를 창출할 수 있을지에 대한 해답을
당사가 준비하고 있는 기업용 솔루션을 통해 제시합니다.

이번 세미나는 Collaboration, KMS으로만 시장에 비추어지고 있는
Enterprise Web2.0.을 재정의하고,
XPLATFOM 2008이란 새로운 제품으로 선보일 RIA, Ajax, Widget, Mashup 등의 기능이
기업에서 어떻게 사용될지에 대한 실제 활용 예를데모시연과 함께 제안함으로써
Web2.0이 궁극적으로 기업들에게 어떤 가치를 제공할 것인지에 대한 비전을 제시할 것입니다.

이번 투비소프트 세미나에서 Enterprise Web2.0에 대한 실체를 직접 경험하시고,
새롭게 탄생할 XPLATFORM의 시작을 함께하시길 바랍니다.
여러분의 많은 참여를 기다리겠습니다.


일시 : 2007년 11월 21일 수요일 13:00~17:30

장소 : 코엑스 인터컨티넨탈 호텔 하모니볼룸(B1)
(약도 http://mplanners.kr/tobesoft/map.htm)


세부일정 및 등록하기


신고

AllowOverride directive - Apache web server configuration

Apache web server  configuration


AllowOverride directive

Syntax: AllowOverride All|None|directive-type [directive-type] ...
Default: AllowOverride All
Context: directory
Status: core

When the server finds an .htaccess file (as specified by AccessFileName) it needs to know which directives declared in that file can override earlier access information.

Note: AllowOverride is only valid in <Directory> sections, not in <Location> or <Files> sections, as implied by the Context section above.

When this directive is set to None, then .htaccess files are completely ignored. In this case, the server will not even attempt to read .htaccess files in the filesystem.

When this directive is set to All, then any directive which has the .htaccess Context is allowed in .htaccess files.

The directive-type can be one of the following groupings of directives.

AuthConfig
Allow use of the authorization directives (AuthDBMGroupFile, AuthDBMUserFile, AuthGroupFile, AuthName, AuthDigestRealmSeed, AuthType, AuthUserFile, Require, etc.).
FileInfo
Allow use of the directives controlling document types (AddEncoding, AddLanguage, AddType, DefaultType, ErrorDocument, LanguagePriority, etc.).
Indexes
Allow use of the directives controlling directory indexing (AddDescription, AddIcon, AddIconByEncoding, AddIconByType, DefaultIcon, DirectoryIndex, FancyIndexing, HeaderName, IndexIgnore, IndexOptions, ReadmeName, etc.).
Limit
Allow use of the directives controlling host access (Allow, Deny and Order).
Options
Allow use of the directives controlling specific directory features (Options and XBitHack).

Example:

AllowOverride AuthConfig Indexes

See Also: AccessFileName and Configuration Files



[펌]http://oops.org/?t=lecture&sb=apache&n=2

AllowOverride Directive


각 디렉토리에 위치한 .htaccess 파일에서 어떤 옵션을 마음대로 제어할 수 있는지 결정한다.  
"All" 또는 "Options", "FileInfo", "AuthConfig", "Limit"의 자유로운 결합이 가능하다.

.htaccess파일은 서버의 각 디렉토리에 만들어서 각 디렉토리에
  대한 접근을 제어하기 위한 것으로 디렉토리에 .htaccess파일이
  있으면, 서버 전체에 작용하는 access.conf 보다 우선권을 가진다.

  .htaccess파일에 대한 Override에 대한 옵션이다. 가능한 옵션은  다음과 같다.

None .htaccess파일을 읽을 수 없게 한다.
All 모든 지정에 대해 가능하게 한다.
Options 규정된 디렉토리 형식을 콘트롤하는 지정의 사용을 허락한다.
FileInfo 문서형식을 콘트롤하는 지정의 사용을 허용한다.
AuthConfig 사용자 인증 지정의 사용을 허용한다. 사용자 인증 변수를 사용한다.
Limit 호스트 접근을 콘트롤하는 지정을 허용한다.
신고

정규표현식 with Javascript(자바스크립트)

항상 쓰고 나서는 까먹는 정규표현식ㅡㅡ
이번에 또 쓸일이 있어서 찾아보고 정리가 잘된 글을 발견해 훔쳐왔다
병민님감자


What is Regular Expression

정규표현식이란 어떤 문자열의 특정 케릭터 조합을 일정한 패턴으로 표현하는것이라고 할 수 있다.

즉, 어느 문자열에서 특정 패턴을 가지는 문자들을 찾아내는것이다. 이러한 특징 때문에 대부분 정규표현식은


1. 특정 변수가 가지는 일정한 패턴이 원하는 패턴과 일치하는지 확인할 때

2. 특정 변수에 들어있는 문자열에서 자신이 원하는 패턴의 특정 문자를 찾아낼때


사용된다. 또한 본 글에서는 with Javascript라 명시했지만 이는 Javascript뿐만이 아니라 곳곳에서 사용되는 일종의 규약임을

인식하기를 바란다.(즉, Javascrip 뿐이 아니라 정규표현식을 지원하는 것이라면 어디서든 비슷하게 사용된다. 크게 차이는 없음)


자바스크립트에서 정규표현식은 1.2 버젼부터 사용이 가능한 관계로 오래된 브라우저의 사용자는 이를 사용 할 수 없다.

또한 자바스크립트에서 정규표현식은 하나의 객체 이다.

Define Regular Expression

자바스크립트에서의 정규표현식은 객체이기 때문에 기본적으로 constructor function 형태로 사용이 가능할 뿐만이 아니라 object initializers 또한 지원한다.


  constructor function 형식 : re = new RegExp("[a-z]");

  object initializers 형식 : re = /[a-z]/;

Use Regular Expression

정규 표현식에 사용되는 형태, 문자는 다음과 같다.

Character

의미

\

\ 다음에 나오는 특수 문자를 문자열로 인식
가령, /라는 특수문자는 일반적으로 프로그램상에서 나누기로 인식하게 되어있습니다. 이것을 나누기가 아닌 그냥 문자열 / 로 인식시키려면 \/ 로 써주면됩니다.

^

라인의 처음과 패턴과 매치
가령, ^A 라고 써주면 검색하고자 하는 문장의 시작문자가 A인지를 검사하는 것입니다.

$

라인의 끝과 패턴과 매치
가령, ^A 라고 써주면 검색하고자 하는 문장의 마지막문자가 A인지를 검사하는 것입니다.

*

0개 이상의 문자와 매치(모든것이라는 의미)

+

1개 이상의 문자와 매치, {1,}와 같은 의미임.

?

0 또는 1개의 문자 의미.
즉, A?b 라면 A라는 문자와 b라는 문자사이에 문자가 0개 또는 1개 가 들어갈 수 있다는 말입니다. 즉, Ab, Aab, Acb등과 같은..

.

1개의 문자와 일치

()

한번 match를 수행해서 나온 결과를 기억함.
예: /(foo)/ 는 foo라는 단어를 검색한 후, 그 단어를 배열등과 같은 저장장소에 남겨두어 나중에 다시 호출할 수 있도록 합니다.

|

OR

{n}

정확히 n개의 문자
예: a{2} 는 a 문자 두 개, 즉, aa를 의미합니다.

{n,}

n개 이상의 문자

{n,m}

n이상 m이하의 문자

[xyz]

문자들의 set를 의미. 가령, [a-z]라면 a부터 z까지의 모든 문자와 매치하는 것으로 []안의 -는 범위를 나타냅니다.

[^xyz]

네가티브(-) 캐릭터 셋

[\b]

백스페이스와 매치

\b

단어의 시작 또는 끝에서 빈 문자열과 매치

\B

단어의 시작 또는 끝이 아닌 곳에서의 빈 문자열과 매치

\cX

control 문자와 매치

\d

0부터 9까지의 아라비아 숫자와 매치. [0-9]과 같은 의미

\f

form-feed와 매치

\n

linefeed와 매치

\r

캐리지 리턴과 매치

\s

화이트스페이스 문자와 매치. [ \t\n\r\f\v]과 같은 의미

\S

\s가 아닌 문자들과 매치. [^ \t\n\r\f\v]과 같은 의미

\t

탭 의미

\v

수직 탭 의미

\w

w는 문자와 숫자를 의미 = [a-zA-Z_0-9]

\W

W는 문자가 아닌 요소, 즉 % 등과 같은 특수 문자를 의미함 = [^a-zA-Z_0-9]

\n

n은 마지막 일치하는 문장

\ooctal
\xhex

8(octal)진수, 10(hex)진수 값

Regular expression(정규 표현식)과 함께 사용하는 함수들

exec

문장에서 매치를 위해 검색을 수행하는 정규 표현식 메소드
배열을 리턴

test

문장에서 매치를 위해 테스트하는 정규표현식 메소드
True 또는 False 리턴

match

문장에서 매치를 위해 검색을 수행하는 string 메소드
배열 또는 null 문자 리턴

search

문장에서 매치를 위해 테스트하는 string 메소드
목차나 -1 리턴

replace

문장에서 매치를 위해 검색을 실행하고 문장을 대체하는 String 메소드

split

문장에서 매치하는 부분을 배열에 할당하는 String 메소드



Sample of Ragular Expression

이는 가장 단순한 형태의 정규표현식으로 쉽게 설명하기 위해 만든것으로 실제로 사용할 수도 있지만 현실에 잘 맞지 않을 수도 있음을 염두하길 바란다.


 YYYY-MM-DD 형태의 날짜 판별 스크립트.

<SCRIPT LANGUAGE="JavaScript">
<!--

function validateDate(){

   if(frm.birthday.value.search(/[12][0-9]{3}-[0-9]{2}-[0-9]{2}/) == -1){
        document.getElementById("birthdayDIV").style.display="block";
        isValidate = false;
    }
    else {
        document.getElementById("birthdayDIV").style.display="none";
    }

}

//-->

이메일 판별용 스크립트.

<SCRIPT LANGUAGE="JavaScript">

function validateEmail(){

    if(frm.email1.value.search(/(\S+)\@(\S+)\.(\S+)/) == -1){
         document.getElementById("emailDIV").style.display="block";
         isValidate = false;
    }
    else {
        document.getElementById("emailDIV").style.display="none";
    }

}

//-->



if(frm.birthday.value.search(/[12][0-9]{3}-[0-9]{2}-[0-9]{2}/) == -1){

위의 날짜 판별용 스크립트에는 () 를 찾아볼 수가 없다. 즉 이를 나중에 다시 불러 쓸 수 없다.

하나하나 뜯어 살펴보도록 하자.


[12] : 1 혹은 2 둘중 하나

[0-9] : 0 1 2 3 4 5 6 7 8 9 중 하나

{3} : [0-9] 를 3번 반복


즉 여기까지 1000 부터 2999 까지의 숫자를 의미한다.

- 는 그냥 문자 -를 의미한다.


[0-9], {2} : 0~9까지의 숫자를 두번 즉, 00부터 99까지.


전부 표현하자면 1000-00-00 부터 2999-99-99까지 표현이 가능하게 되어있다.

if(frm.email1.value.search(/(\S+)\@(\S+)\.(\S+)/) == -1){

이는 각각이 ()로 묶여 있어 이후에 따로 불러서 사용 할 수 있다.


(\S+) : 한개이상 문자열. 이후 $1 로 불러올 수 있다.

\@ : @ 문자 표현

(WS+) : 한개이상 문자열. 이후 $2 로 불러올 수 있다.

\. : . 문자 표현

(WS+) : 한개이상 문자열. 이후 $3 로 불러올 수 있다.


qkfl2@korea.com 을 받았을 경우


alert("이메일은 "+ RegExp.$1 + "@" + RegExp.$2 + "." + RegExp.$3 + "입니다.");


로 불러올 수 있다.



* 갱신 내용 : /w 에 대한 잘못 된 정보. (죄송합니다. 긁어서 확인을 못했네요) 2007/10/9

작성자 : 백병민

출처 : http://blog.naver.com/qkfl4

마지막 갱신일 : 2007년 10월 9일


신고

서버를 개선하였습니다 - apache 2.0 mod_deflate (gzip)

움,, KT에서 업로드 속도를 전혀 내주지 않고 있기때문에 결국-.-

gzip 을 사용해서 html 을 압축해 응답하도록 고쳤습니다

설치된 아파치를 보니 2.x 이네용..

찾아보니 1.3 에서 쓰던 mod_gzip 은 사라지고, 2.x 부터는 mod_deflate 이 대신한다 하는군요.

설치 결과 굉장히.. 빨라졌네요
(index 파일의 html 만 비교해보면 109kbyte 정도 되는 분량이 21kb 정도로 줄었습니다.)
(로드 속도도 눈에 띄게 빨라졌네요 다만 그림 파일은 압축을 하지 않습니다:: 이미 압축된 포맷이기때문에.)


gzip compress 기능을 활성화 하기 위해 httpd.conf 파일에 들어갔던 세팅입니다 (apache 2.0 기준 :: windows 설치 버전)


1. 아래 모듈의 주석("#")을 해제하거나 없을 시에는 작성.
# for gzip response 1
LoadModule deflate_module modules/mod_deflate.so
# for gzip response 2
LoadModule headers_module modules/mod_headers.so

2. 타입에 의한 설정을 이용하였습니다 (다른 방법도 있음)
압축률은 1~9까지 있는데 별로 차이는 없더군요, 테스트결과 1이 더 느린거 같아서 저는 9로 했습니다
########################################################################
# compress code '-'
########################################################################
AddOutputFilterByType DEFLATE text/html text/plain text/xml
# 1 ~ 9
DeflateCompressionLevel 9
########################################################################

3. 브라우저 따라 문제가 있는 것 같더군요 그외 압축을 회피할 경우에 대해 설정합니다(이미 압축이 되어있는 형식의 파일, 압축시 간헐적으로 FF에서 문제가 생기는 파일등)
########################################################################
# no gzip response.
########################################################################
# Netscape 4.x에 문제가 있다...
BrowserMatch ^Mozilla/4 gzip-only-text/html
# Netscape 4.06-4.08에 더 문제가 있다
BrowserMatch ^Mozilla/4\.0[678] no-gzip
# MSIE은 Netscape라고 자신을 알리지만, 문제가 없다
BrowserMatch \bMSIE !no-gzip !gzip-only-text/html
# 압축하지 않을것목록..
SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|png|bmp|zip|tar|rar|alz|a00|ace|txt|mp3|mpe?g|wav|asf|wma|wmv|swf|exe|pdf|doc|xsl|hwp|css|js|java|c|t?gz|bz2|7z)$ no-gzip dont-vary
# 프록시가 잘못된 내용을 전달하지않도록 한다
Header append Vary User-Agent env=!dont-vary
########################################################################


신고

VARIANT, BSTR & SAFEARRAY C++ Tutorial...

http://www.whooper.co.uk/excelvariants.htm

...VARIANT, BSTR & SAFEARRAY C++ Tutorial...

<--Back to Excel Home Page

Introduction

Frustrated by the lack of good articles on the VARIANT data type, I decided to write this short introduction.

The VARIANT type is an all purpose data type used by IDispatch::Invoke both to transmit and receive parameters. It can hold numbers, strings, arrays, error values and IDispatch pointers. An XLL developer could consider the variant to be the Automation equivalent of the do everything Excel XLOPER data type.

Structure

Here is a simplified version of the VARIANT definition. For the full definition see this link.

struct tagVARIANT {
    VARTYPE vt; // unsigned short integer type code
    WORD wReserved1;
    WORD wReserved2;
    WORD wReserved3;
    union {
    //  C++ Type      Union Name   Type Tag                Basic Type
    //  --------      ----------   --------                ----------

        long          lVal;        // VT_I4                ByVal Long
        unsigned char bVal;        // VT_UI1               ByVal Byte
        short         iVal;        // VT_I2                ByVal Integer
        double        dblVal;      // VT_R8                ByVal Double
        VARIANT_BOOL  boolVal;     // VT_BOOL              ByVal Boolean
        SCODE         scode;       // VT_ERROR
        DATE          date;        // VT_DATE              ByVal Date
        BSTR          bstrVal;     // VT_BSTR              ByVal String
        IUnknown      *punkVal;    // VT_UNKNOWN
        IDispatch     *pdispVal;   // VT_DISPATCH          ByVal Object
        SAFEARRAY     *parray;     // VT_ARRAY|*           ByVal array
        // A bunch of other types that don't matter here...
        VARIANT       *pvarVal;    // VT_BYREF|VT_VARIANT  ByRef Variant
        void          * byref;     // Generic ByRef       
    };
};

The variant type is 16 bytes in size.

Here is an example of creating a variant of type double:

VARIANT v;
v.vt= VT_R8;
v.dblVal = 999.999;

This example shows a variant containing all the actual data inside it's 16 byte structure. With the more complex string & safearry types, the data is stored separately and the VARIANT structure just contains a pointer to it.

The Variant String Type - BSTR

Conventional C strings are arrays of type char terminated by a null. Each character is stored in a single byte of 8 bits according to the ANSI encoding map called ASCII. The VARIANT string type, which is called BSTR, is more sophisticated. It has the following features:

(a) Each character is stored in two byes, or 16 bits, in order to allow for larger non Latin based character sets. This wide character storage is called UNICODE, while the conventional 8 bit storage is known as ANSI.

(b) There is an unsigned long integer (32 bit) byte count at the start of the string array, so the maximum length of a BSTR string is 2^32/2=2147483648 characters. The string "Hello World" has eleven characters, so at the start of the array one would find a byte count length of 22. A byte cont allows nulls to be stored inside the sting if required.

(c) There is a null terminating character at the end of the array.

(d) The BSTR pointer (stored in the variant as v.bstrVal) does not point to the start of the string structure, but rather to the start of the first character, ie four bytes forward of the actual start in which the length is recorded. The advantage of this is that as long as there is no early null character inside the string, a BSRT pointer can be consider as an ordinary pointer to a C style null terminated string, albeit of 16 bit character size. Alternatively, a BSTR can be consider as a buffer of a certain size in which conventional wide character null terminated strings can be stored.

In pictures:

        
In C++ the types are:

ANSI UNICODE
char
or CHAR
unsigned short
or WCHAR
char*
or LPSTR
LPWSTR
const char*
or LPCSTR
LPCWSTR

When working with conventional C strings it's easy to create and delete char arrays to hold the data. However, with the more complex BSTR type you should use the SysAllocString and SysFreeString functions for allocating and deleting; and certainly never never call delete on the pointer (which doesn't even point to the start of the data).

Here are three examples of creating a string VARIANT:

//////////////////////////////////
VARIANT v;
v.vt=VT_BSTR;
v.bstrVal= SysAllocString(L"Hello World"); // L for UNICODE characters

VariantClear(&v); // Calls SysFreeString(v.bstrVal) for us then sets v.vt=VT_EMPTY

//////////////////////////////////
LPVARIANT pV; // VARIANT*
pV= new VARIANT;
pV->vt=VT_BSTR;
pV->bstrVal= SysAllocString(L"Hello World");

VariantClear(pV); // Delete BSTR
delete pV;       // Delete Variant

//////////////////////////////////
VARIANT v;
const char c[12]="Hello World"; // 11 single byte char plus null
LPWSTR p= new WCHAR [ 12 ]; // 12 double byte characters
i=MultiByteToWideChar(CP_ACP, 0, c, -1, p, 12); // ANSI->UNICODE
v.vt=VT_BSTR;
v.bstrVal=SysAllocString(p);
delete p; // String has been copied out of the temporary buffer

VariantClear(&v);
//////////////////////////////////

The function VariantClear deletes any memory attached to the variant (in this case the BSTR "Hello World") and sets v.vt=VT_EMPTY meaning empty or no value. With our earlier example of a numeric variant of type VT_R8, there would of course be no need to call VariantClear because there is no attached data, the numeric value is held inside the structure.

The function VariantInit can be used to initialize a variant by setting v.vt=VT_EMPTY.  The function VariantCopy frees the memory associated with the destination argument and copies the source. VariantChangeType handles coercions between different types including string to numeric and visa versa.

And here is some code that won't work:

VARIANT v;
const char c[12]="Hello World";
char* p= new char [ 4 + (11+1)*2 ];
char* pS=p+4;
MultiByteToWideChar(CP_ACP, 0, c, -1, (LPWSTR) pS, 12);
*( (int*) p)=22;
v.vt=VT_BSTR;
v.bstrVal=(LPWSTR) pS;
VariantClear(&v);

Although it produces a valid variant, VariantClear() or SysFreeString() will not delete the manually allocated memory.

The old C functions strlen() etc will not work with wide character strings but the standard library contains alternatives such as wcslen(), wscpy(), wcscat() (see this link). You can also use SysStringLen() to return (byte_count /2); which will equal wcslen() only if there is no null character stored inside the string.

It's valid to pass a BSRT pointer equal to NULL in order to represent a NULL string.

You will sometimes see OLECHAR and OLESTR("Hello World") in place of WCHAR and L"Hello World". In modern Win 32 code this is equivalent.

Further reading: BSTR API at MSDN  Variant API at MSDN  COleVariant at MSDN  Article about Strings in C++ Part I, Part II

SAFEARRAYs

A SAFEARRAY is a multi dimensional multi type array. To pass a safe array in a variant v, set v.vt to VT_ARRAY | element VT type, and set v.parray to point to the safe array.

Here is the definition of a safe array:

// The SAFEARRAY structure
typedef struct tagSAFEARRAY
{

    USHORT cDims;                        // Number of dimensions
    USHORT fFeatures;                    // Misc flags inc element type
    ULONG cbElements;                    // Element size
    ULONG cLocks;                        // Lock count
    PVOID pvData;                        // Pointer to data
    SAFEARRAYBOUND rgsabound[ cDims];    // Array of dimension structures   

} SAFEARRAY;

// SAFEARRAY Dimension structure
typedef struct tagSAFEARRAYBOUND
{

    ULONG cElements;       // Number of elements in dimension
    LONG lLbound;          // Lower bound of dimension (usually 0)                   

} SAFEARRAYBOUND;

cDims gives the number of dimensions in the array. Eg a one dimensional array has cDims=1.

The bits of the fFeatures flag are described as followed: (Note: it looks complicated but don't worry too much as we will use an API to create our safe arrays and it will take care of this detail for us)

#define FADF_HAVEVARTYPE 0x0080 // An array that has a general VT type.

// If set the two byte VT type is stored four bytes before
//  the start of the SAFEARRAY structure.
// Any VT type except VT_EMPTY and VT_NULL is OK

#define FADF_BSTR 0x0100 // An array of BSTRs.
#define FADF_UNKNOWN 0x0200 // An array of IUnknown*.
#define FADF_DISPATCH 0x0400 // An array of IDispatch*.
#define FADF_VARIANT 0x0800 // An array of VARIANTs.
#define FADF_RESERVED 0xF0E8 // Bits reserved for future use.

#define FADF_AUTO 0x0001 // Array is allocated on the stack.
#define FADF_STATIC 0x0002 // Array is statically allocated.
#define FADF_EMBED invokeURLs=false autostart=trueDED 0x0004 // Array is embedded in a structure.
#define FADF_FIXEDSIZE 0x0010 // Array may not be resized


The SAFEARRYBOUND structure describes each dimension. Eg, in VB Dim x(10 to 100) would equate to lLbound=10 and cElements=91.

There is an API for manipulating safe arrays (see this link: Array Manipulation API), and a variant safe array class derived from the variant structure (see this link: COleSafeArray).

Here is an example of creating a variant containing a one dimensional safe array of longs with size 100 and lower bound 0 using the API.

VARIANT v;
SAFEARRAYBOUND rgb [] = { 100, 0 };
v.vt = VT_ARRAY | VT_I4; // Array of longs
// Now call SafeArrayCreate with type, dimension,
//  and pointer to vector of dimension descriptors

v.parray = SafeArrayCreate(VT_I4, 1, rgb);
long *rgelems; // Pointer to long elements
// Now lock the array for editing and get a pointer
// to the raw elements

SafeArrayAccessData(v.parray, (void**)&rgelems);
// Loop through setting the elements
for (int c = 0; c < 100; c++)
    rgelems[c] = c;
// Release the lock on the array
// (which also invalidates the element pointer)

SafeArrayUnaccessData(v.parray);

// Clear the array releasing the memory
VaraintClear(&v)


And here is another example in which we create a 10 row by 15 column array of variant elements:

v.vt = VT_ARRAY | VT_VARIANT;
SAFEARRAYBOUND sab[2];
sab[0].lLbound = 1; sab[0].cElements = 10;
sab[1].lLbound = 1; sab[1].cElements = 15;
v.parray = SafeArrayCreate(VT_VARIANT, 2, sab);
// Fill with some values...
for(i=1; i<=10; i++) {
    for(int j=1; j<=15; j++)
    {
        // Create entry value for (i,j)
        VARIANT tmp;
        tmp.vt = VT_I4;
        tmp.lVal = i*j;
        // Add to safearray...
        long indices[] = {i,j};
        SafeArrayPutElement(v.parray, indices, (void *)&tmp);
    }
}

VaraintClear(&v)

This code uses the slower technique of multiple calls to SafeArrayPutElement instead of locking the array and accessing directly as in our first example. Another useful function in the API (link above) is SafeArrayGetElement. It also possible, for performance purposes, to avoid the API and create the array by hand, but you will have to get to grips with fFeatures etc.

Conclusion

This concludes my short tutorial on the Variant Data Type. I hope you found it useful!



[MSDN]

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/automat/htm/chap6_7zdz.asp

VARIANT and VARIANTARG

Use VARIANTARG to describe arguments passed within DISPPARAMS, and VARIANT to specify variant data that cannot be passed by reference. When a variant refers to another variant by using the VT_VARIANT | VT_BYREF vartype, the variant being referred to cannot also be of type VT_VARIANT | VT_BYREF. VARIANTs can be passed by value, even if VARIANTARGs cannot. The following definition of VARIANT is described in OAIDL.H automation header file:

To simplify extracting values from VARIANTARGs, Automation provides a set of functions for manipulating this type. Use of these functions is strongly recommended to ensure that applications apply consistent coercion rules.

Value Description
VT_EMPTY No value was specified. If an optional argument to an Automation method is left blank, do not pass a VARIANT of type VT_EMPTY. Instead, pass a VARIANT of type VT_ERROR with a value of DISP_E_PARAMNOTFOUND.
VT_EMPTY | VT_BYREF Not valid.
VT_UI1 An unsigned 1-byte character is stored in bVal.
VT_UI1 | VT_BYREF A reference to an unsigned 1-byte character was passed. A pointer to the value is in pbVal.
VT_UI2 An unsigned 2-byte integer value is stored in uiVal.
VT_UI2 | VT_BYREF A reference to an unsigned 2-byte integer was passed. A pointer to the value is in puiVal.
VT_UI4 An unsigned 4-byte integer value is stored in ulVal.
VT_UI4 | VT_BYREF A reference to an unsigned 4-byte integer was passed. A pointer to the value is in pulVal.
VT_UI8 An unsigned 8-byte integer value is stored in ullVal.
VT_UI8 | VT_BYREF A reference to an unsigned 8-byte integer was passed. A pointer to the value is in pullVal.
VT_UINT An unsigned integer value is stored in uintVal.
VT_UINT | VT_BYREF A reference to an unsigned integer value was passed. A pointer to the value is in puintVal.
VT_INT An integer value is stored in intVal.
VT_INT | VT_BYREF A reference to an integer value was passed. A pointer to the value is in pintVal.
VT_I1 A 1-byte character value is stored in cVal.
VT_I1 | VT_BYREF A reference to a 1-byte character was passed. A pointer the value is in pcVal.
VT_I2 A 2-byte integer value is stored in iVal.
VT_I2 | VT_BYREF A reference to a 2-byte integer was passed. A pointer to the value is in piVal.
VT_I4 A 4-byte integer value is stored in lVal.
VT_I4 | VT_BYREF A reference to a 4-byte integer was passed. A pointer to the value is in plVal.
VT_I8 A 8-byte integer value is stored in llVal.
VT_I4 | VT_BYREF A reference to a 8-byte integer was passed. A pointer to the value is in pllVal.
VT_R4 An IEEE 4-byte real value is stored in fltVal.
VT_R4 | VT_BYREF A reference to an IEEE 4-byte real value was passed. A pointer to the value is in pfltVal.
VT_R8 An 8-byte IEEE real value is stored in dblVal.
VT_R8 | VT_BYREF A reference to an 8-byte IEEE real value was passed. A pointer to its value is in pdblVal.
VT_CY A currency value was specified. A currency number is stored as 64-bit (8-byte), two's complement integer, scaled by 10,000 to give a fixed-point number with 15 digits to the left of the decimal point and 4 digits to the right. The value is in cyVal.
VT_CY | VT_BYREF A reference to a currency value was passed. A pointer to the value is in pcyVal.
VT_BSTR A string was passed; it is stored in bstrVal. This pointer must be obtained and freed by the BSTR functions, which are described in Conversion and Manipulation Functions.
VT_BSTR | VT_BYREF A reference to a string was passed. A BSTR* that points to a BSTR is in pbstrVal. The referenced pointer must be obtained or freed by the BSTR functions.
VT_DECIMAL Decimal variables are stored as 96-bit (12-byte) unsigned integers scaled by a variable power of 10. VT_DECIMAL uses the entire 16 bytes of the Variant.
VT_DECIMAL | VT_BYREF A reference to a decimal value was passed. A pointer to the value is in pdecVal.
VT_NULL A propagating null value was specified. (This should not be confused with the null pointer.) The null value is used for tri-state logic, as with SQL.
VT_NULL | VT_BYREF Not valid.
VT_ERROR An SCODE was specified. The type of the error is specified in scodee. Generally, operations on error values should raise an exception or propagate the error to the return value, as appropriate.
VT_ERROR | VT_BYREF A reference to an SCODE was passed. A pointer to the value is in pscode.
VT_BOOL A 16 bit Boolean (True/False) value was specified. A value of 0xFFFF (all bits 1) indicates True; a value of 0 (all bits 0) indicates False. No other values are valid.
VT_BOOL | VT_BYREF A reference to a Boolean value. A pointer to the Boolean value is in pbool.
VT_DATE A value denoting a date and time was specified. Dates are represented as double-precision numbers, where midnight, January 1, 1900 is 2.0, January 2, 1900 is 3.0, and so on. The value is passed in date.

This is the same numbering system used by most spreadsheet programs, although some specify incorrectly that February 29, 1900 existed, and thus set January 1, 1900 to 1.0. The date can be converted to and from an MS-DOS representation using VariantTimeToDosDateTime, which is discussed in Conversion and Manipulation Functions.

VT_DATE | VT_BYREF A reference to a date was passed. A pointer to the value is in pdate.
VT_DISPATCH A pointer to an object was specified. The pointer is in pdispVal. This object is known only to implement IDispatch. The object can be queried as to whether it supports any other desired interface by calling QueryInterface on the object. Objects that do not implement IDispatch should be passed using VT_UNKNOWN.
VT_DISPATCH | VT_BYREF A pointer to a pointer to an object was specified. The pointer to the object is stored in the location referred to by ppdispVal.
VT_VARIANT Invalid. VARIANTARGs must be passed by reference.
VT_VARIANT | VT_BYREF A pointer to another VARIANTARG is passed in pvarVal. This referenced VARIANTARG, pvarVal, cannot be another VT_VARIANT|VT_BYREF. This value can be used to support languages that allow functions to change the types of variables passed by reference.
VT_UNKNOWN A pointer to an object that implements the IUnknown interface is passed in punkVal.
VT_UNKNOWN | VT_BYREF A pointer to the IUnknown interface is passed in ppunkVal. The pointer to the interface is stored in the location referred to by ppunkVal.
VT_ARRAY | An array of data type was passed. (VT_EMPTY and VT_NULL are invalid types to combine with VT_ARRAY.) The pointer in pparray points to an array descriptor, which describes the dimensions, size, and in-memory location of the array. The array descriptor is never accessed directly, but instead is read and modified using the functions described in Conversion and Manipulation Functions.

신고

ANSI와 UTF-8과의 상호 변환

또 엄청나게 삽질 -.-
이번에는 ANSI <-> UTF-8 문제가 아니라, WideByte 쪽으로 고생 했다

ASP 에서 인자값으로 C++로 넘기는 부분이였는데
VARIANT 타입의 변수를 다루는 것에 뭐 이런게 다있나 하면서 해메고 -_-
그 변수에서의 스트링이 나는 ANSI 나 유니코드로 들어올 줄 알았고 혼자서 삽질을했다

계속 삽질하다가 나중에 char 포인터로 한 바이트씩 디버그해보니까
'<' + '\0' + 'x' + '\0' + 'm' + '\0' + 'l' + '\0' + ......
WideByte 타입 이였었다 -ㅁ-

결국은 답은 간단:
ANSI 코드로 바꿀 경우에는 W2A() 를 쓰고,
유니코드로 바꿀 경우에는 WideCharToMultiByte() 를 쓰면 되더라ㅋ

오랫만에 C++ . . 어렵더라 역시나 공부 좀 할껄 그랬어.. (원래 촘 못한다;)
음 공부 한 것은.. VARIANT 타입에 대해서 조금은 공부했고, (글구 SAFEARRAY 도)
ASP가 보통의 경우에 유니코드, ANSI 이런거 안쓰고 Wide Character 를 쓴다는거 ? ?

퍼온거 more..


신고


티스토리 툴바