public static IEnumerable<ITypeDescription> Read(IObjectContainer database,
TypeResolver typeResolver)
{
new {database, typeResolver}.CheckNotNull();
var reader = new MetaDataReader(typeResolver, ExtractStoredClasses(database.Ext().StoredClasses()));
return reader.CreateTypes(database.Ext()).ToList();
}
public ObjectDetails(long id)
{
this.id = id;
objectContainer = Db4oClient.Client;
m_genObject = objectContainer.Ext().GetByID(id);
objectContainer.Ext().Activate(m_genObject, 1);
}
private static void TraverseIndex(IObjectContainer container)
{
// #example: Traverse index
IStoredField storedField = container.Ext()
.StoredClass(typeof (Item)).StoredField("data", typeof (int));
storedField.TraverseValues(new IndexVisitor());
// #end example
}
private void IndexDatabase(IndexWriter writer, IObjectContainer container)
{
IEnumerable<Versiculo> versiculos = container.Query<Versiculo>();
foreach(Versiculo versiculo in versiculos){
Document doc = CreateVersiculoDoc(container.Ext().GetID(versiculo), versiculo);
writer.AddDocument(doc);
}
}
public static void ListRefreshedResult(IObjectContainer container, IObjectSet items, int depth)
{
Console.WriteLine(items.Count);
foreach (object item in items)
{
container.Ext().Refresh(item, depth);
Console.WriteLine(item);
}
}
private static void Refresh(IObjectContainer db, IList<Person> allPersons)
{
foreach (Person objToRefresh in allPersons)
{
// #example: refresh a object
db.Ext().Refresh(objToRefresh, int.MaxValue);
// #end example
}
}
// #example: An object container for this unit of work
private void ListAllPeople(IObjectContainer rootContainer)
{
using (IObjectContainer container = rootContainer.Ext().OpenSession())
{
foreach (Person person in from Person p in container select p)
{
Console.WriteLine(person.Name);
}
}
}
public void RunWith(IObjectContainer db)
{
IStoredClass storedClass = db.Ext().StoredClass(targetClazz);
IStoredField storedField = storedClass.StoredField(fieldName, fieldType);
IObjectSet result = db.Query(targetClazz);
Assert.AreEqual(1, result.Count);
object obj = result.Next();
object value = (object)storedField.Get(obj);
Assert.AreEqual(fieldValue, value);
}
public static void CarSnapshotRollbackRefresh(IObjectContainer db)
{
IObjectSet result=db.QueryByExample(new Car("BMW"));
Car car=(Car)result.Next();
car.Snapshot();
db.Store(car);
db.Rollback();
db.Ext().Refresh(car, int.MaxValue);
Console.WriteLine(car);
}
// #end example:
private void StoreInitialObjects(IObjectContainer rootContainer)
{
using (IObjectContainer container = rootContainer.Ext().OpenSession())
{
container.Store(new Person("Joe"));
container.Store(new Person("Jan"));
container.Store(new Person("Joanna"));
container.Store(new Person("Phil"));
}
}
public Db4oEmbeddedReplicationProvider(IObjectContainer objectContainer, string name
)
{
// TODO: Add additional query methods (whereModified )
IConfiguration cfg = objectContainer.Ext().Configure();
cfg.Callbacks(false);
_name = name;
_container = (ExternalObjectContainer)objectContainer;
_reflector = _container.Reflector();
_signatureMap = new Db4oSignatureMap(_container);
_activationStrategy = CreateActivationStrategy();
}
private static void RefreshAfterRollback(IObjectContainer container)
{
// #example: Refresh objects after rollback
Pilot pilot = container.Query<Pilot>()[0];
pilot.Name = "New Name";
container.Store(pilot);
container.Rollback();
// use refresh to return the in memory objects back
// to the state in the database.
container.Ext().Refresh(pilot, int.MaxValue);
// #end example
}
// #end example
// #example: An object container for the background task
private void UpdateSomePeople(IObjectContainer rootContainer)
{
using (IObjectContainer container = rootContainer.Ext().OpenSession())
{
var people = from Person p in container
where p.Name.Equals("Joe")
select p;
foreach (Person joe in people)
{
joe.Name = "New Joe";
container.Store(joe);
}
}
}
private void AssertChangesHaveBeenStored(IObjectContainer container)
{
var session = container.Ext().OpenSession();
try
{
var item = ((NamedItem
) session.Query(typeof (NamedItem))[0]);
Assert.AreEqual("New Name", item.GetName());
}
finally
{
session.Close();
}
}
private void AssertChangesHaveBeenStored(IObjectContainer container)
{
IObjectContainer session = container.Ext().OpenSession();
try
{
CommitTimeStampsWithTPTestCase.NamedItem item = ((CommitTimeStampsWithTPTestCase.NamedItem
)session.Query(typeof(CommitTimeStampsWithTPTestCase.NamedItem))[0]);
Assert.AreEqual("New Name", item.GetName());
}
finally
{
session.Close();
}
}
private void ScanThroughKnownClassesInfo(IObjectContainer db)
{
IReflectClass[] clazzArray = db.Ext().KnownClasses();
for (int clazzIndex = 0; clazzIndex < clazzArray.Length; ++clazzIndex)
{
IReflectClass clazz = clazzArray[clazzIndex];
IReflectField[] fieldArray = clazz.GetDeclaredFields();
for (int fieldIndex = 0; fieldIndex < fieldArray.Length; ++fieldIndex)
{
IReflectField field = fieldArray[fieldIndex];
field.GetName();
field.GetFieldType();
}
}
}
private static void RegisterObjectIdUpdaterEvent(IObjectContainer db, ObjectEventHandler activationTracker)
{
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(db);
eventRegistry.Activated += activationTracker;
activationCount = 0;
eventRegistry.Instantiated += delegate(object sender, ObjectEventArgs args)
{
SupportObjectId obj = args.Object as SupportObjectId;
if (obj != null)
{
obj.ObjectId = db.Ext().GetID(obj);
}
};
}
private void RenderCollection(TreeGridNode rootNode, object currObj, IReflectField field)
{
container = Db4oClient.Client;
object value = field.Get(currObj);
if (value != null)
{
container.Ext().Activate(value, 2);
ICollection coll = (ICollection)value;
CreateCollectionNode(field, value, ref rootNode, coll.Count.ToString());
}
else
{
CreateCollectionNode(field, value, ref rootNode, "0");
}
}
public ActionResult FlushDb()
{
foreach (var o in _db.Ext().StoredClasses())
{
try
{
var type = typeof(Instructor).Assembly.GetType(o.GetName());
foreach (var thing in _db.Query(type))
{
_db.Delete(thing);
}
}
catch (Exception)
{
}
}
return(Content("DONE"));
}
public static bool IsCollection(object expandedObj)
{
try
{
if (expandedObj != null)
{
IObjectContainer objectContainer = Db4oClient.Client;
IReflectClass refClass = objectContainer.Ext().Reflector().ForObject(expandedObj);
return(refClass.IsCollection());
}
return(false);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
/// <summary>
/// Counts all entities in the attached data store, or if it's null then all entities from all all stores.
/// </summary>
/// <returns>The total number of entities counted.</returns>
public override int CountEntities()
{
int total = 0;
List <IDataStore> stores = new List <IDataStore>();
// Count the list of stores
// If the DataStore property is null then get all stores.
if (DataStore == null)
{
foreach (string dataStoreName in DataAccess.Data.GetDataStoreNames())
{
stores.Add(Provider.Stores[dataStoreName]);
}
}
// Otherwise use the single store attached to this adapter
else
{
stores.Add(DataStore);
}
// Load data from the stores
foreach (IDataStore store in stores)
{
if (!store.IsClosed)
{
IObjectContainer container = ((Db4oDataStore)store).ObjectContainer;
if (!container.Ext().IsClosed())
{
IQuery query = container.Query();
query.Constrain(typeof(IEntity));
IObjectSet os = query.Execute();
total = os.Count;
}
}
}
return(total);
}
public static void SaveCollections(long id, int level)
{
try
{
IObjectContainer objectContainer = Db4oClient.Client;
if (id == 0)
{
return;
}
object topObject = objectContainer.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(topObject, level);
Db4oClient.Client.Ext().Store(topObject, level);
Db4oClient.Client.Commit();
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public void TraverseObjTree(ref TreeGridNode rootNode, object currObj, string classname)
{
container = Db4oClient.Client;
IReflectClass refClass = DataLayerCommon.ReflectClassForName(classname);
if (refClass == null)
{
return;
}
string type1 = refClass.ToString();
if (!String.IsNullOrEmpty(type1))
{
try
{
IType type = Db4oClient.TypeResolver.Resolve(refClass);
if (type.IsPrimitive)
{
TreeGridNode node = new TreeGridNode();
rootNode.Nodes.Add(node);
node.Cells[0].Value = ClassNameFor(container.Ext().Reflector().ForObject(currObj).GetName());
node.Cells[1].Value = currObj.ToString();
node.Cells[1].ReadOnly = checkReadonlyStatus();
SetFieldType(node, type);
node.Tag = currObj;
node.ImageIndex = 2;
return;
}
IReflectField[] fieldArr = DataLayerCommon.GetDeclaredFieldsInHeirarchy(refClass);
rootNode = TraverseFields(rootNode, currObj, fieldArr);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
}
public long GetFreeSizeofDatabase()
{
IObjectContainer objectContainer = Db4oClient.Client;
long freeSizeOfDB;
try
{
freeSizeOfDB = objectContainer.Ext().SystemInfo().FreespaceSize();
}
catch (NotImplementedException)
{
freeSizeOfDB = -1;
}
catch (Exception oEx)
{
freeSizeOfDB = -1;
LoggingHelper.HandleException(oEx);
}
return(freeSizeOfDB);
}
public void AddProxyInfoToDb(ProxyAuthentication proxyAuthObj)
{
if (Db4oClient.RecentConnFile == null)
{
Db4oClient.RecentConnFile = Config.OMNConfigDatabasePath();
}
_proxyAuthObj = proxyAuthObj;
_container = Db4oClient.RecentConn;
ProxyAuthenticator proxyobj = ReturnProxyAuthenticationInfo();
if (proxyobj == null)
{
_container.Store(this);
}
else
{
proxyobj._proxyAuthObj = proxyAuthObj;
_container.Store(proxyobj);
}
_container.Commit();
_container.Ext().Refresh(proxyobj, 1);
}
private void AssertItemStoredField(object expectedValue)
{
IObjectContainer db = OpenContainer();
try
{
IObjectSet objectSet = db.Query(typeof(FieldsToTypeHandlerMigrationTestCase.Item)
);
Assert.AreEqual(1, objectSet.Count);
FieldsToTypeHandlerMigrationTestCase.Item item = (FieldsToTypeHandlerMigrationTestCase.Item
)objectSet.Next();
IStoredField storedField = db.Ext().StoredClass(typeof(FieldsToTypeHandlerMigrationTestCase.Item
)).StoredField("_id", null);
object actualValue = storedField.Get(item);
Assert.AreEqual(expectedValue, actualValue);
}
finally
{
db.Close();
}
}
protected void Add_Document_for_User_Click(object sender, EventArgs e)
{
int count;
string docname;
float versionOfDoc;
System.Web.HttpContext context = System.Web.HttpContext.Current;
string docname_versionOfDoc = (String)context.Session["docNameVersionNo"];
List <String> compare = new List <string>();
compare = docname_versionOfDoc.Split(':').ToList();
docname = compare[0];
versionOfDoc = float.Parse(compare[1]);
string username = (string)Session["UserName"];
try
{
Config path = new Config();
DB = Db4oFactory.OpenFile(path.addressOfDocument);
IObjectSet result = DB.QueryByExample(new Document_model(docname, versionOfDoc));
Document_model docmodel = (Document_model)result.Next();
count = docmodel.Count_document_reviever - 1;
docmodel.Count_document_reviever = count;
docmodel.List_reviever.Remove(username);
if (docmodel.Count_document_reviever == 0)
{
docmodel.DocumentStatus = "Complete";
}
DB.Ext().Store(docmodel, 3);
DB.Close();
Page.RegisterStartupScript("Alert&Redirect", "<script>alert('Review Successfull!!'); location.href='./Document_page.aspx';</script>");
}
catch
{
}
}
private void btnOpenDb4o_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = ".yap";
dlg.Filter = "db4o file (*.yap)|*.yap";
dlg.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;
if ((bool)dlg.ShowDialog())
{
if (db != null)
{
db.Close();
}
originFile = dlg.FileName;
tbFilePath.Text = originFile;
db = Db4oFactory.OpenFile(originFile);
var ext = db.Ext();
PopulateCombos(db);
}
}
/// <summary>
/// Search and return a project in the database. Returns null if the
/// project is not found
/// </summary>
/// <param name="filename">
/// A <see cref="System.String"/> with the project's video file name
/// </param>
/// <returns>
/// A <see cref="LongoMatch.DB.Project"/>
/// </returns>
public Project GetProject(Guid id)
{
Project ret = null;
IObjectContainer db = Db4oFactory.OpenFile(DBFile);
Log.Debug("Getting project with ID: " + id);
try {
IQuery query = GetQueryProjectById(db, id);
IObjectSet result = query.Execute();
ret = (Project)db.Ext().PeekPersisted(result.Next(), 10, true);
} catch (Exception e) {
Log.Error("Could not get project with ID: " + id);
Log.Exception(e);
} finally {
CloseDB(db);
}
if (ret != null && FixProjectCoordinates(ret))
{
UpdateProject(ret);
}
return(ret);
}
public void AddProxyInfoToDb(ProxyAuthentication proxyAuthObj)
{
if (Db4oClient.RecentConnFile == null)
{
Db4oClient.RecentConnFile = Config.OMNConfigDatabasePath();
}
_proxyAuthObj = proxyAuthObj;
_container = Db4oClient.RecentConn;
ProxyAuthenticator proxyobj = ReturnProxyAuthenticationInfo();
if (proxyobj == null)
{
_container.Store(this);
}
else
{
proxyobj._proxyAuthObj = proxyAuthObj;
_container.Store(proxyobj);
}
_container.Commit();
_container.Ext().Refresh(proxyobj, 1);
}
private void comboType_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
if (comboType.SelectedIndex < 0)
{
return;
}
comboIds.Items.Clear();
objList.Clear();
IStoredClass c = clzList[comboType.SelectedIndex];
var ids = c.GetIDs();
foreach (var id in ids)
{
var o = db.Ext().GetByID(id);
objList.Add(o);
comboIds.Items.Add(string.Format("{0} - {1}", id, o));
}
Msg(string.Format("{0} objects for class [{1}] are listed.\n", ids.Length, c.GetName()));
}
internal void RenameFolderInDatabase(FavouriteFolder oldFavFolder, FavouriteFolder newFavFolder)
{
try
{
container = Db4oClient.RecentConn;
FavouriteList favList = FetchAllFavouritesForAConnection();
List <FavouriteFolder> lstFavFolder = favList.lstFavFolder;
bool check = false;
FavouriteFolder temp = null;
foreach (FavouriteFolder str in lstFavFolder)
{
if (str != null)
{
if (str.FolderName.Equals(oldFavFolder.FolderName))
{
temp = str;
check = true;
break;
}
}
}
if (check == true)
{
lstFavFolder.Remove(temp);
container.Delete(temp);
temp.FolderName = newFavFolder.FolderName;
lstFavFolder.Add(temp);
favList.lstFavFolder = lstFavFolder;
container.Ext().Store(favList, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public override bool RunJob()
{
bool bError = false;
try
{
if (servidor.IsRunning())
{
IObjectContainer dbcliente = Db4oFactory.OpenClient(this.sServer, Convert.ToInt32(this.sPort),
this.sUsuario, this.sPassword);
dbcliente.Ext().Backup(sBackupFile);
dbcliente.Close();
}
}
catch (Exception ex)
{
bError = true;
Log.AddToLog(sJobName, ex.Message);
}
return(bError);
}
private void AssertHasIndexInfo(IObjectContainer db)
{
IStoredClass[] scArray = db.Ext().StoredClasses();
for (int scIndex = 0; scIndex < scArray.Length; ++scIndex)
{
IStoredClass sc = scArray[scIndex];
if (!sc.GetName().Equals(typeof(KnownClassesIndexTestCase.WithIndex).FullName))
{
continue;
}
IStoredField[] sfArray = sc.GetStoredFields();
for (int sfIndex = 0; sfIndex < sfArray.Length; ++sfIndex)
{
IStoredField sf = sfArray[sfIndex];
if (sf.HasIndex())
{
return;
}
}
Assert.Fail("no index found");
}
}
public static void DeleteObject(long id)
{
IObjectContainer objectContainer = Db4oClient.Client;
try
{
if (id == 0)
{
return;
}
object obj = objectContainer.Ext().GetByID(id);
Db4oClient.Client.Delete(obj);
Db4oClient.Client.Ext().Purge();
Db4oClient.Client.Commit();
ObjectCache.RemoveObject(id);
}
catch (Exception oEx)
{
objectContainer.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public static void AssertDataClassKnown(string databaseFileName, IEmbeddedConfiguration
config, bool expected)
{
IObjectContainer db = Db4oEmbedded.OpenFile(config, databaseFileName);
try
{
var storedClass = db.Ext().StoredClass(typeof(Data
));
if (expected)
{
Assert.IsNotNull(storedClass);
}
else
{
Assert.IsNull(storedClass);
}
}
finally
{
db.Close();
}
}
public void SetIndex(ArrayList fieldnames, string className, ArrayList Indexed, string path, bool customConfig)
{
IObjectContainer con = null;
try
{
IEmbeddedConfiguration embeddedConfig = !customConfig?Db4oEmbedded.NewConfiguration() : Config();
for (int i = 0; i < fieldnames.Count; i++)
{
embeddedConfig.Common.ObjectClass(className).ObjectField(fieldnames[i].ToString()).Indexed(
Convert.ToBoolean(Indexed[i]));
}
con = Db4oEmbedded.OpenFile(embeddedConfig, path);
IReflectClass clazz = con.Ext().Reflector().ForName(className);
con.QueryByExample(clazz);
}
finally
{
con.Close();
}
}
static public List <Disponibilidad> Buscar(Disponibilidad DisponibilidadBuscar)
{
using (IObjectContainer db = Connect.getDataBase())
{
long id = DisponibilidadBuscar.Id;
List <Disponibilidad> lRes = new List <Disponibilidad>();
try
{
DisponibilidadBuscar.dbId = DisponibilidadBuscar.Id;
//db.Ext().Bind(DisponibilidadBuscar, id);
Connect.setdbId(db, DisponibilidadBuscar);
object o2 = db.Ext().GetByID(id);
DisponibilidadBuscar = (Disponibilidad)o2;
/*DisponibilidadBuscar.dbId = DisponibilidadBuscar.Id;
* if (DisponibilidadBuscar.Id>0)
* {
* DisponibilidadBuscar.dbId = null;
* }*/
IObjectSet result = db.QueryByExample(DisponibilidadBuscar);
while (result.HasNext())
{
Disponibilidad o = (Disponibilidad)result.Next();
Connect.getdbId(db, (object)o);
lRes.Add(o);
}
return(lRes);
}
finally
{
db.Close();
}
}
return(null);
}
/// <summary>
/// Counts all entities of the specified type from the corresponding data store.
/// </summary>
/// <param name="type">The type of entity to retrieve.</param>
/// <returns>The total number of entities counted.</returns>
public override int CountEntities(Type type)
{
int total = 0;
using (LogGroup logGroup = LogGroup.StartDebug("Counting entities of the specified type."))
{
IObjectContainer objectContainer = ((Db4oDataStore)GetDataStore(type)).ObjectContainer;
// If the object container is closed then skip the query
if (objectContainer != null && !objectContainer.Ext().IsClosed())
{
IQuery query = objectContainer.Query();
query.Constrain(type);
IObjectSet os = query.Execute();
total = os.Count;
LogWriter.Debug("Total: " + total.ToString());
}
}
return(total);
}
public void deleteRecentQueriesForAConnection()
{
List <OMQuery> qList = new List <OMQuery>();
IObjectSet objSet = null;
try
{
container = Db4oClient.RecentConn;
IQuery query = container.Query();
query.Constrain(typeof(RecentQueries));
query.Descend("m_connParam").Descend("m_connection").Constrain(m_connParam.Connection);
objSet = query.Execute();
if (objSet != null)
{
RecentQueries recQueries = (RecentQueries)objSet.Next();
for (int i = 0; i < recQueries.QueryList.Count; i++)
{
OMQuery q = recQueries.m_queryList[0];
if (q != null)
{
// m_queryList.Remove(q);
container.Delete(q);
}
}
recQueries.m_queryList.Clear();
recQueries.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis();
container.Ext().Store(recQueries, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
private static void ReferenceCacheExample()
{
using (IObjectContainer client1 = Db4oClientServer.OpenClient("localhost", 1337, "sa", "sa"),
client2 = Db4oClientServer.OpenClient("localhost", 1337, "sa", "sa"))
{
// #example: Reference cache in client server
Person personOnClient1 = QueryForPerson(client1);
Person personOnClient2 = QueryForPerson(client2);
Console.Write(QueryForPerson(client2).Name);
personOnClient1.Name = ("New Name");
client1.Store(personOnClient1);
client1.Commit();
// The other client still has the old data in the cache
Console.Write(QueryForPerson(client2).Name);
client2.Ext().Refresh(personOnClient2, int.MaxValue);
// After refreshing the date is visible
Console.Write(QueryForPerson(client2).Name);
// #end example
}
}
protected virtual void SetMessageRecipient(IObjectContainer container, IMessageRecipient
recipient)
{
SetMessageRecipient(container.Ext().Configure(), recipient);
}
protected virtual IMessageSender MessageSender(IObjectContainer client)
{
return(client.Ext().Configure().ClientServer().GetMessageSender());
}
public List <UsuarioModel> ListarUsuarios()
{
List <UsuarioModel> lista = new List <UsuarioModel>();
foreach (var a in db.Query <Usuario>())
{
lista.Add(new UsuarioModel()
{
Id = db.Ext().GetID(a),
Nombre = a.Nombre
});
}
return(lista);
}
private void RenderArray(TreeGridNode rootNode, object currObj, IReflectField field)
{
container = Db4oClient.Client;
object obj = field.Get(currObj);
if (obj != null)
{
container.Ext().Activate(obj, 2);
int length = container.Ext().Reflector().Array().GetLength(obj);
CreateCollectionNode(field, obj, ref rootNode, length.ToString());
}
else
{
CreateCollectionNode(field, obj, ref rootNode, "0");
}
}
internal void RenameFolderInDatabase(FavouriteFolder oldFavFolder, FavouriteFolder newFavFolder)
{
try
{
container = Db4oClient.RecentConn;
FavouriteList favList = FetchAllFavouritesForAConnection();
List<FavouriteFolder> lstFavFolder = favList.lstFavFolder;
bool check = false;
FavouriteFolder temp = null;
foreach (FavouriteFolder str in lstFavFolder)
{
if (str != null)
{
if (str.FolderName.Equals(oldFavFolder.FolderName))
{
temp = str;
check = true;
break;
}
}
}
if (check == true)
{
lstFavFolder.Remove(temp);
container.Delete(temp);
temp.FolderName = newFavFolder.FolderName;
lstFavFolder.Add(temp);
favList.lstFavFolder = lstFavFolder;
container.Ext().Store(favList, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
private bool OnlyNeedUpdate(IObjectContainer container)
{
return(container.Ext().IsStored(state));
}
private static void StoreEntry(IObjectContainer rootContainer)
{
using (var container = rootContainer.Ext().OpenSession())
{
var toTest = new WithAutoIDs();
container.Store(toTest);
}
}
private void btnOpenDb4o_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = ".yap";
dlg.Filter = "db4o file (*.yap)|*.yap";
dlg.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;
if ((bool)dlg.ShowDialog())
{
if (db != null)
{
db.Close();
}
originFile = dlg.FileName;
tbFilePath.Text = originFile;
db = Db4oFactory.OpenFile(originFile);
var ext = db.Ext();
PopulateCombos(db);
}
}
protected virtual IMessageSender MessageSender(IObjectContainer client)
{
return client.Ext().Configure().ClientServer().GetMessageSender();
}
protected virtual void SetMessageRecipient(IObjectContainer container, IMessageRecipient
recipient)
{
SetMessageRecipient(container.Ext().Configure(), recipient);
}
private void PrintStats(IObjectContainer con, string filename)
{
Tree unavailable = new TreeString(Remove);
Tree noConstructor = new TreeString(Remove);
// one element too many, substract one in the end
IStoredClass[] internalClasses = con.Ext().StoredClasses();
for (int i = 0; i < internalClasses.Length; i++)
{
string internalClassName = internalClasses[i].GetName();
Type clazz = ReflectPlatform.ForName(internalClassName);
if (clazz == null)
{
unavailable = unavailable.Add(new TreeString(internalClassName));
}
else
{
if (!CanCallConstructor(internalClassName))
{
noConstructor = noConstructor.Add(new TreeString(internalClassName));
}
}
}
unavailable = unavailable.RemoveLike(new TreeString(Remove));
noConstructor = noConstructor.RemoveLike(new TreeString(Remove));
if (unavailable != null)
{
PrintHeader("UNAVAILABLE");
unavailable.Traverse(new _IVisitor4_80());
}
if (noConstructor != null)
{
PrintHeader("NO PUBLIC CONSTRUCTOR");
noConstructor.Traverse(new _IVisitor4_88());
}
PrintHeader("CLASSES");
Sharpen.Runtime.Out.WriteLine("Number of objects per class:");
ByRef ids = ByRef.NewInstance(new TreeInt(0));
if (internalClasses.Length > 0)
{
Tree all = new TreeStringObject(internalClasses[0].GetName(), internalClasses[0]);
for (int i = 1; i < internalClasses.Length; i++)
{
all = all.Add(new TreeStringObject(internalClasses[i].GetName(), internalClasses[
i]));
}
all.Traverse(new _IVisitor4_107(ids));
}
PrintHeader("SUMMARY");
Sharpen.Runtime.Out.WriteLine("File: " + filename);
Sharpen.Runtime.Out.WriteLine("Stored classes: " + internalClasses.Length);
if (unavailable != null)
{
Sharpen.Runtime.Out.WriteLine("Unavailable classes: " + unavailable.Size());
}
if (noConstructor != null)
{
Sharpen.Runtime.Out.WriteLine("Classes without public constructors: " + noConstructor
.Size());
}
Sharpen.Runtime.Out.WriteLine("Total number of objects: " + (((Tree)ids.value).Size
() - 1));
}
private void CloseDB(IObjectContainer db)
{
db.Ext().Purge();
db.Close();
}
private void RenderCollection(TreeGridNode rootNode, object currObj, IReflectField field)
{
container = Db4oClient.Client;
object value = field.Get(currObj);
if (value != null)
{
container.Ext().Activate(value, 2);
ICollection coll = (ICollection)value;
CreateCollectionNode(field, value, ref rootNode, coll.Count.ToString());
}
else
{
CreateCollectionNode(field, value, ref rootNode, "0");
}
}
/// <summary>deactivates each object.</summary>
/// <remarks>deactivates each object.</remarks>
public virtual void Rollback(IObjectContainer container, object obj)
{
container.Ext().Deactivate(obj);
}
public IExtObjectContainer Ext()
{
return(session.Ext());
}
private void PopulateCombos(IObjectContainer db)
{
comboType.Items.Clear();
clzList.Clear();
var clzs = db.Ext().StoredClasses();
foreach (var c in clzs)
{
//if (c.GetName().StartsWith("Unionless"))
{
comboType.Items.Add(c.GetName() + " - " + c.GetIDs().Length);
clzList.Add(c);
}
}
Msg(string.Format("{0} classes are listed.\n", clzs.Length));
}
internal void AddFolderToDatabase(FavouriteFolder favFolder)
{
try
{
container = Db4oClient.RecentConn;
if (m_lstFavfolder != null)
{
FavouriteList favList = FetchAllFavouritesForAConnection();
if (favList == null)
{
favList = new FavouriteList(m_connParam);
List<FavouriteFolder> lstFavfolder = new List<FavouriteFolder>();
favList.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis();
lstFavfolder.Add(favFolder);
container.Store(favList);
container.Commit();
return;
}
container.Activate(favList, 5);
List<FavouriteFolder> lstFavFolder = favList.lstFavFolder;
bool check = false;
FavouriteFolder temp = null;
foreach (FavouriteFolder str in lstFavFolder)
{
if (str != null)
{
if (str.FolderName.Equals(favFolder.FolderName))
{
temp = str;
check = true;
break;
}
}
}
if (check == false)
{
lstFavFolder.Add(favFolder);
}
else
{
lstFavFolder.Remove(temp);
lstFavFolder.Add(favFolder);
container.Delete(temp);
}
favList.lstFavFolder = lstFavFolder;
container.Ext().Store(favList, 5);
container.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public List <Hashtable> ObjectIDToUIObjects(PagingData pgdata, Hashtable attribList)
{
try
{
Hashtable hashFieldValue;
object rowObj = null;
if (pgdata.ObjectId.Count < pgdata.EndIndex)
{
pgdata.EndIndex = pgdata.ObjectId.Count;
}
if (attribList.Count == 0)
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
if (rClass != null)
{
IReflectField[] reff = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
if (reff == null)
{
return(m_lstRowContent);
}
for (int i = pgdata.StartIndex; i < pgdata.EndIndex; i++)
{
if (pgdata.ObjectId[i] == 0)
{
continue;
}
rowObj = objectContainer.Ext().GetByID(pgdata.ObjectId[i]);
if (rowObj != null)
{
if (m_refresh)
{
objectContainer.Ext().Refresh(rowObj, 1);
}
else
{
objectContainer.Ext().Activate(rowObj, 1);
}
}
if (rowObj != null)
{
hashFieldValue = checkforprimitives(reff, rowObj, pgdata.ObjectId[i]);
m_lstRowContent.Add(hashFieldValue);
}
}
}
}
else
{
int length = GetDepth(attribList);
for (int i = pgdata.StartIndex; i < pgdata.EndIndex; i++)
{
hashFieldValue = new Hashtable();
m_hashRowContent = new Hashtable();
foreach (string attribute in attribList.Keys)
{
if (pgdata.ObjectId[i] == 0)
{
continue;
}
rowObj = objectContainer.Ext().GetByID(pgdata.ObjectId[i]);
if (rowObj != null)
{
if (m_refresh)
{
objectContainer.Ext().Refresh(rowObj, length);
}
else
{
objectContainer.Ext().Activate(rowObj, length);
}
hashFieldValue = UpdateResults(rowObj, attribute);
}
}
if (hashFieldValue.Count != 0)
{
if (!hashFieldValue.ContainsKey(BusinessConstants.DB4OBJECTS_REF))
{
hashFieldValue.Add(BusinessConstants.DB4OBJECTS_REF, pgdata.ObjectId[i]);
}
m_lstRowContent.Add(hashFieldValue);
}
}
}
return(m_lstRowContent);
}
catch (Exception oEx)
{
//LoggingHelper.HandleException(oEx);
LoggingHelper.ShowMessage(oEx, "Maybe Can't find 'enum' Type. ");
return(new List <Hashtable>( ));
}
}
private void ConvertToNew(IObjectContainer db1, string f2)
{
worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.WorkerSupportsCancellation = true;
worker.ProgressChanged += Worker_ProgressChanged;
worker.DoWork += (sender, e) =>
{
IObjectContainer db2 = Db4oFactory.OpenFile(f2);
var clist = db1.Ext().StoredClasses();
worker.ReportProgress(0, string.Format("{0} classes are listed.", clist.Length));
Assembly assembly = Assembly.LoadFile(assemblyFile);
worker.ReportProgress(0, string.Format("Assembly [{0}] is loaded.", assemblyFile));
foreach (Type t in assembly.GetTypes())
{
worker.ReportProgress(0, string.Format("++Type [{0}] is loaded.", t));
}
foreach (IStoredClass c in clist)
{
// try to list objects.
var ids = c.GetIDs();
worker.ReportProgress(0, string.Format("{0} objects for class [{1}] are listed.", ids.Length, c.GetName()));
foreach (var id in ids)
{
var o = db1.Ext().GetByID(id);
var o2 = PopulateFrom(id, o, c, assembly);
if (o2 != null)
{
db2.Store(o2);
}
}
}
db2.Commit();
db2.Close();
};
worker.RunWorkerAsync();
}
